Grunt - podsumowanie mojej zabawy z pakietami do automatyzowania pracy

Skoro ostatnio odrzuciłem na razie używanie generatorów, to może napiszę czego się nauczyłem?

mamy 2 pliki:

package.json

{
  "name": "project",
  "title": "file_project",
  "version": "0.0.1",
  "homepage": "localhost",
  "author": {name:"Born-kes"}
}

i Gruntfile.js
...

to w tym drugim, mogę korzystać z danych zadeklarowanych w innym miejscu:

np.

grunt.initConfig({
   pkg: grunt.file.readJSON('package.json'),

   concat: {
      dist: {
        src: ['<%= pkg.title %>/*.js', 'test/{,*/}*.js'],
        dest: 'dist/<%= pkg.name %>.js'
      }
   },
   uglify: {
      dist: {
        src: '<%= concat.dist.dest %>',
        dest: 'dist/<%= pkg.name %>.min.js'
      }
    },

Wniosek jak tego użyć?

Daje to wrażenie, że można mieć powiedzmy już gotowe konfiguracje i dołączać je grunt.file.readJSON do projektu, a większość zmian opiera się o plik package.json.

To wygląda zachęcająco.

Faworyt:

Chyba najczęściej używanym pakietem jest grunt-contrib-watch - obserwator projektu.
Przeładowuje on Tasksi po każdej modyfikacji i może "piszczeć" jak któryś task coś znajdzie np.zrobimy literówkę, albo coś przestało działać...

Zmniejszanie plików

grunt-contrib-uglify minimalizuje plik usuwając zbędne białe znaki i czasem nazwy zmiennych by skrócić kod. Szybko działa i pozwala mieć fajny przejrzysty kod z tysiącem komentarzy, a na boku tworzy kod czysty od naszych komentarzy i spakowany (zminifikowany).
grunt-contrib-htmlmin - minifikuje pliki HTML
grunt-contrib-cssmin - minifikuje pliki CSS

grunt-contrib-connect umnie strasznie zamula, ale odświerzanie okna przeglądarki po każdej modyfikacji to fajny bajer jak się ma dwa monitory.

grunt-usemin - pozwala podmieniać fragmenty kodu , np używać tagów w HTML do generowania strony bez potrzeby generowania jej przez serwer www.

Pilnowanie składni i poprawności kodu

grunt-contrib-jshint pozwala mieć konfiguracje w pliku w projekcie ( plik .jshint ), nie wiem co na to praktycy, ale chyba porządkuje kod.

grunt-eslint jest chyba lepiej wspierany (od grunt-contrib-jshint) , będę starał się go lepiej poznać. Kontroluje semantycznosć kodu, czyli między innymi literówki i poprawność.

grunt-contrib-concat pozwala łączyć pliki, ale szału niema, jeszcze nie jestem na etapie by każdy fragmęt kodu (funkcjonalność, zadanie) mieć w innym pliku.

grunt-karma - pozwala pisać testy jednostkowe.

Ciekawostka

NodeJS ma jeszcze dostęp do phpUnit od composera. Czytałem, że composer potrafi używać pakietów nodejs :-) - na stonie o drupalu 8, jest duży poradnik.
Ciekawostka może ktoś skorzysta, szkoda mi trochę czasu na takie zabawy.


Jak coś jeszcze znajdę to dopiszę do listy

Kupno działki, opieka nad dziećmi i kilka książek i tygodni później, od rozpoczęcia porządkowania wiedzy.

Książki o :
-wzorcach projektowych,
- testowaniu danych,
- Twórcy ofiary i

i efektem jest Class'a testowa,
Ogarnę gita i dodam link do repozytorium.

/**
 * Class ExampleTest
 * $this->assertTrue
 * $this->assertFalse
 * $this->assertEquals ==
 * $this->assertSame ===
 * $this->assertContains('value', $array) ['value']
 * $this->assertArrayHasKey('key', $array) ['key'=>'value']
 * $this->assertInternalType('array', $a); type_of2

$date = new DateTime();
$this->assertInstanceOf('DateTime', $date);
 */

<?php
use PHPUnit\Framework\TestCase;
  
   class EtestTest extends TestCase
{
    /** @var  \Prophecy\Prophecy\ObjectProphecy */
    private $prophet;
    private $mock;
    private $Basic;
    private $x;

    protected function setup() {
        $this->prophet = new \Prophecy\Prophet;
        /** @var Prophecy\Prophet $x TYPE_NAME */
        $x = $this->x = $this->prophet->prophesize()->willImplement ('Basic\Routing');


        $x->get('b')->willReturn('hello b');
        $x->get('a')->willReturn('hello');
        $this->mock = $x->reveal();

        $this->Basic   = new \Basic\Basic($this->mock);
    }

    protected function tearDown() {
        $this->prophet->checkPredictions();
    }

    public function testBasicRun()
    {
        //$this->x->get('b')->willReturn('hello nowe');

         $this->assertEquals($this->Basic->run(), 'hello b') ;
        return true;
    }

    /**
     * jeśli test poprzedni działa
     * @depends testBasicRun
     */
    public function testNext($a)
    {
        $this->assertTrue($a);

    }

    /**
     * Dane z Provider'a
     * @dataProvider additionProviderOne
     * @dataProvider additionProviderSecond
     */
    public function testAdd($a, $b, $expected)
    {
        $this->assertSame($expected, $a + $b, "{$a}, {$b}, {$expected}");
    }
    /**
     * Dane z Provider'a
     * @dataProvider additionProviderOne
     * @dataProvider additionProviderSecond
     */
    public function testAddSecond()
    {
        list( $a, $b, $expected) = func_get_args();
        $this->assertSame($expected, $a + $b, "{$a}, {$b}, {$expected}");
    }

    public function additionProviderOne()
    {
        return [
            [0, 0, 0],
            [0, 1, 1],
            [1, 0, 1],
         //   [1, 1, 3]
        ];
    }

    public function additionProviderSecond()
{
    return [
        'adding zeros'  => [0, 0, 0],
        'zero plus one' => [0, 1, 1],
        'one plus zero' => [1, 0, 1],
     //   'one plus one'  => [1, 1, 3]
    ];
}

    public function testFailingInclude()
    {
        $this->expectException(Error::class);

        throw @include 'not_existing_file.php';
    }

    public function testExpectFooActualFoo()
    {
        $this->expectOutputString('foo');
        echo 'foo';
    }
}

// cls => czeuszczenie cmd