JavaScript - TDD - konfiguracja środowiska

Wpis ten traktuje jako notatkę odnośnie konfiguracji środowiska pod pisanie testów do JavaScriptu.

Piszemy w Intellij, do uruchomienia testów używamy js-test-driver.

Ściagamy JsTestDriver.jar, wrzucamy do jakiegoś folderu, odpalamy server

java -jar JsTestDriver.jar --port 9876

teraz wchodzimy w przeglądarce na http://localhost:9876/ i klikamy capture

Przeglądarka połączyła się z serwerem, będzie to nasze środowisko do uruchamiania testów. Możliwe jest jednoczesne więcej niż połączenie, wtedy będziemy mieli pewność, że testy przechodzą zarówno na IE7, IE8 oraz innych mniej popularnych przeglądarkach.

Przechodzimy do IDE, domyślnie do głównego folderu wrzucamy JsTestDriver.jar i tworzymy plik konfiguracyjny jsTestDriver.conf, przykładowa zawartość:

server: http://localhost:9876
load:
  - src/main/js/*.js
  - src/test/js/*.js

Dla Intellij 7 czy tam 8 istniał fikuśny plugin do uruchamiania testów w stylu JUnitu, ale nikomu nie chce się go przystosować do 9 więc trzeba zastosować pewne obejście.

File - Settings - External Tools - Add
Dajemy name JsTestRun, resztę zostawiamy uzupełniając pola

Program: C:\Program Files\Java\jre6\bin\java.exe
tu wiadomo, ścieżka do JRE

Parameters: -jar $ProjectFileDir$\JsTestDriver.jar --tests all
tu w zależności gdzie wrzuciliśmy jara

Working directory: $ProjectFileDir$\
wiadomo
ok, ok

Tworzmy przykładowe klasy i testy (przykłady ze strony projektu)

myapp = {};

myapp.Greeter = function() { };

myapp.Greeter.prototype.greet = function(name) {
  return "Hello " + name + "!";
};

GreeterTest = TestCase("GreeterTest");

GreeterTest.prototype.testGreet = function() {
  var greeter = new myapp.Greeter();
  assertEquals("Hello World!", greeter.greet("World"));
};

klikamy Tools - JsTestRun i otrzymujemy (np dla chrome, IE8), Settings - keymap warto dodać hotkey, w założeniu testy będziemy często uruchamiać.

Total 2 tests (Passed: 2; Fails: 0; Errors: 0) (0,00 ms)
  Chrome 8.0.552.215: Run 1 tests (Passed: 1; Fails: 0; Errors 0)
 (0,00 ms)
  Internet Explorer 8.0: Run 1 tests (Passed: 1; Fails: 0; Errors 0)
 (0,00 ms)

i gitara

edit...
jednak komuś się zachciało i dodano wsparcie w Intellij9

Scala x04 - Metody ciąg dalszy

Java dostarcza nam 2 sposoby przekazywania argumentów do metod, przez referencje (a właściwie jej kopię) oraz przez wartość (dla typów prymitywnych). Scala udostępnia nam trzecią możliwość, przekazywanie argumentów przez nazwę (call-by-name). Jest to moje tłumaczenie, jak ktoś zna lepsza/oficjalne to proszę o korektę.
Definiujemy przykładową metodę, której wykonanie zajmuje dużo czasu, ta np. wykonuje miliard różnych czynności, wypisuje komunikat i zwraca jakiś tam rezultat (podwojony argument)

scala> def czasochlonnaMetoda(x : Int):Int = {
     //zaawansowane operacje na zmiennej x,
     //pobieranie danych z bazy na podstawie xmla
     //otrzymanego z web service'u 
       println("trwalo to z godzine")
       return 2 * x
     }
czasochlonnaMetoda: (Int)Int

Definiujemy drugą metodę, przyjmuje ona 2 argumenty, zwraca pierwszy w przypadku gdy jest on większy od zera, lub drugi w innej sytuacji.

scala> def szybkaMetoda(x : Int, y : Int):Int = {
      println("wykonujemy szybka metode")
      if(x > 0) x
      else y
     }
szybkaMetoda: (Int,Int)Int

//wywołujemy szybką metodę,
// przekazując jako 2 argument rezultat wykonania czasochłonnej metody
scala> szybkaMetoda(2, czasochlonnaMetoda(2))
trwalo to z godzine
wykonujemy szybka metode
res2: Int = 2

Wszystko przebiegło jak się spodziewaliśmy, wywołana została czasochłonna metoda, następnie wykonało się ciało szybkiej metody. Z treści metody widzimy, iż drugi argument nie był w ogóle wykorzystywany, a jednak straciliśmy na jego ewaluacje sporo czasu. Zdefiniujmy teraz szybką metodę w trochę inny sposób

//w liście parametrów dodajemy dziwny znaczek
scala> def szybszaMetoda(x : Int, y : => Int):Int = {
      println("szybsza metoda")
        if(x > 0) x
        else y
      }
szybszaMetoda: (Int,=> Int)Int

//i ponownie wywołujemy metodę
scala> szybszaMetoda(1, czasochlonnaMetoda(2))
szybsza metoda
res3: Int = 1

Ku naszemu zdziwieniu czasochłonna metoda w ogóle nie została wywołana, nie potrzebowaliśmy czasochłonnej ewaluacji drugiego parametru i nie została ona wykonana, coś pięknego. Stosujący przekazywanie parametrów przez nazwę, określenie ich wartości odbywa się dopiero w momencie, gdy następuje do nich odwołanie w ciele metody. Obrazuje to przykład

scala> szybszaMetoda(-1, czasochlonnaMetoda(2))
szybsza metoda
trwalo to z godzine
res4: Int = 4

Wyświetlany jest komunikat z szybszej metody, dopiero potem wykonuje się metoda, której rezultat przekazaliśmy jako parametr

Scala x03 - Metody

Definicje metod rozpoczynają się od słowa def, następnie występuje nazwa metody wraz z listą parametrów i ich typów w nawiasach okrągłych. Poza nawiasem mamy dwukropek i typ zwracanej wartości, a po znaku równości ciało metody. Przykładowa definicja metody zwracającej różnicę 2 liczb wygląda następująco:

scala> def roznica(odjemna : Int, odjemnik : Int): Int = {
        return odjemna - odjemnik
      }
roznica: (Int,Int)Int

scala> roznica(2,4)
res0: Int = -2

Oczywiście w Scali polowa powyższego kodu jest opcjonalna, można powyższą metodę zapisać tak:

scala> def roznica(odjemna : Int, odjemnik :Int) = {
        odjemna - odjemnik
      }
roznica: (Int,Int)Int

Typ zwracanej wartości jest automagicznie wykrywany, więc można go opuścić (oczywiście w wielu wypadkach wskazane jest jednak jawne określenie). Metody domyślnie zwracają wynik działania ostatniej linijki ich kodu, więc return również można ominąć. Idąc dalej...

//jeżeli ciało funkcji zawiera jedną instrukcję, {} są opcjonalne
scala> def roznica(odjemna : Int, odjemnik : Int) = odjemna - odjemnik
roznica: (Int,Int)Int

Oczywiście możemy tworzyć również metody nie przyjmujące żadnych parametrów i nie zwracające żadnej wartości

scala> def sayDupa() = println("dupa")
sayDupa: ()Unit
scala> sayDupa
dupa

Jak widać typem zwracanej wartości jest Unit, odpowiednik void znanego z Javy (wszystkie metody klasy Javy zwracające void, są mapowane do metod zwracających Unit).

Scala x02 - Zmienne

W Scali istnieją 2 typy zmiennych vals i vars. Val to zmienna przypominająca zmienna final z Javy, raz przypisanej do nich wartości nie można zmienić. Var to natomiast zwykłe zmienne, których wartość możemy zmieniać.

//definiujemy zmienna val
scala> val zmienna = "dupa"
//łańcuchy znaków w Scali zaimplementowano jako Javowe Stringi  
zmienna: java.lang.String = dupa   

scala> zmienna = "dupa2"
:5: error: reassignment to val
       zmienna = "dupa2"
//próba ponownego przypisania wartości do zmiennej kończy się błędem               

scala> var zmiennaVar = "Pierwsza wartosc" //definiujemy zmienną var
zmiennaVar: java.lang.String = Pierwsza wartosc

scala> zmiennaVar = "Nowa wartosc"
zmiennaVar: java.lang.String = Nowa wartosc
//tu już nie dostajemy komunikatu o błędzie,
//nowa wartość została przypisana
scala> println(zmiennaVar)
Nowa wartosc
scala>

Ciekawą rzeczą, jaką można zauważyć w tym przykładzie jest automatyczne wykrywanie typu zmiennej. Gdzie tylko to możliwe możemy pozostawiać kompilatorowi kontrole typu zmiennej, jednak nic nie szkodzi aby samemu go określić.

//w odróżnieniu od Javy, pierwsze nazwa zmiennej,
//potem dwukropek, następnie opcjonalny typ
//i przypisanie wartości.
scala> var x:java.lang.Long = 1L  
x: java.lang.Long = 1

Dla uzupełnienia, wszystkie typy prymitywne znane z Javy mają swoje odpowiedniki w Scali, np scala.Boolean odpowiada boolean, scala.Float to float. Kompilator Scali automagicznie zamienia, gdzie tylko możliwe, typy Scali na prymitywy.

Scala x01 - Podstawy

I oto nadszedł pierwszy wpis na temat Scali. Nie będę rozpisywał się na temat teoretycznych cech języka, historii itd, te informacje łatwo można odnaleźć w Wikipedii
Co potrzebujemy aby zacząć programować w Scali?
Po pierwsze musimy posiadać JDK w wersji 1.5 lub wyższej. Programy napisane w Scali uruchamiane są na wirtualnej maszynie, więc bez Javy się nie obejdziemy.
Następnie pobieramy dystrybucje Scali, wypakowywujemy, oraz ustawiamy zmienne środowiskowe(PATH w Windows), aby mieć dostęp do plików znajdujących się w katalogu bin.
Jeżeli wszystko wykonaliśmy poprawnie, możemy sprawdzić wersję oraz uruchomić REPL (read-eval-print loop).

$ scala -version
Scala code runner version 2.7.5.final -- Copyright 2002-2009, LAMP/EPFL
$ scala
Welcome to Scala version 2.7.5.final (Java HotSpot(TM) Client VM,
 Java 1.6.0_14).
Type in expressions to have them evaluated.
Type :help for more information.
scala>
scala> 1 + 1
res0: Int = 2

Istnieją 3 sposoby uruchamiania programów
1. Używamy z linii poleceń.
2. Umieszczamy kod w pliku, następnie wywołujemy

$ scala foo.scala

3. Możemy przeprowadzić kompilacje do plików klas, z których można utworzyć archiwum JAR, tak samo jak w przypadku Javy. Używamy kompilatora scalac

$ scalac foo.scala bar.scala

Istnieje także kompilator fsc (fast scala compiler), skracający czas kompilacji (uruchamia się jako osobny proces)

Gratuluje, możesz zacząć tworzyć w Scali :)

Reanimacja, reaktywacja

Po długiej przerwie w końcu udało mi się zebrać w sobie i postanowiłem reaktywować bloga. O czym będę pisał dalej? Na pewno nie zmieni się charakter wpisów, dalej będą notki o frameworkach, językach i tego typu dziwnych rzeczach. Będę starał się napisać co nieco o Scali, może uda mi się utworzyć jakaś serie wpisów na temat tego zdobywającego coraz większą popularność języka programowania. Ale co by nie zapeszać wstrzymam się z większymi obietnicami, zobaczymy jak czas i chęci pozwolą.

NetBeans 6.5 juz jest!

Ukazała się finalna wersja NetBeans IDE 6.5!
Po raz pierwszy mamy możliwość pracy z IDE w naszym ojczystym języku.
Aby pobrac wersje pl należy na oficjalnej stronie wybrać more languages.
Jeżeli chcecie dowiedzieć się wiecej na temat tłumaczenia zapraszam tutaj :)