Aggiornamenti Recenti Attiva/disattiva nidificazione dei commenti | Scorciatoie da tastiera

  • francescoagati 1:09 pm il September 3, 2012 Permalink | Rispondi
    Etichette: angular.js, , livescript   

    Angular.js: caricare i json in modalità dichiarativa 


    Questa è una direttiva che permette di inserire il contenuto dei file json, all’interno dello scope dei controller di angular.js

     
  • francescoagati 2:13 pm il January 2, 2012 Permalink | Rispondi
    Etichette: , jsonrpc, , , ,   

    Ruby: Rack-RPC json e xml rpc server per rack 


    Rack-RPC è un middleware rack che permette di implementare servizi in formato xmlrpc e jsonrpc.

    require 'rack/rpc'
    
    class Server < Rack::RPC::Server
      before_filter :check_auth
    
      def hello_world
        "Hello, world!"
      end
      rpc 'hello_world' => :hello_world
    
      private
    
      def check_auth
        raise "Not authorized" unless authorized
      end
    end


    I servizi vengono incapuslati dentro classi che ereditano da Rack::RPC::Server e supportano i filtri come in rails.
    Il fatto che sia un middleware permette di integrarlo dentro qualsiasi applicazione rails, sinatra,padrino ecc…

     
  • francescoagati 1:54 pm il January 2, 2012 Permalink | Rispondi
    Etichette: assets pipeline, backbone, eco, , ember, , , , , rails3.1, , spine, sprockets, ,   

    Javascript MVC: Gemme da usare con rails 3. 


    Con l’introduzione del paradigma MVC nei browser sono uscite molte nuove librerie javascript come backbone, ember, spine.
    Vediamo per ciascuna di queste quale gemme usare per integrarle facilmente con l’assets pipeline di rails 3.1:

    Backbone.js

    Aggiunge i file underscore.js e backbone.js all’assets pipeline. Ha dei generators per la creazione di models routes e scaffolds che mappano i models di rails.

    aggiunge il supporto di handlerbars alle view di backbone

    Ember.js

    include la libreria di ember, alcuni plugin ember e la precompilazione dei template handlebars grz all’uso di slim

    Spine

    include le librerie di spine, dei generators per la creazione di models controller e view e uno scaffolder per i model di rails.
    Supporta la precompilazione di template in eco, hamljs e ejs

     
  • francescoagati 5:26 pm il June 25, 2011 Permalink | Rispondi
    Etichette: , , , ,   

    javascript: Sammy.js un piccolo sinatra 


    Sammy.js è una libreria, di soli 5k compressi, che si ispira a sinatra per scrivere applicazioni js sfruttando il pattern rest.

    Oltre al router esistono tutta una serie di plugin per il supporto a eventi, storage locali e rest, template (mustage, handlerbar…) e formbuilder.

    Il framework è completamente integrato con jquery, e il codice scritto può facilmente essere embeddato dentro a un plugin.

    app = Sammy("#main", ->
      @use "Mustache"
      @get "#/", ->
        @load("posts.json").renderEach("post.mustache").swap()
    )
    app.run "#/"
    
    // initialize the application
    var app = Sammy('#main', function() {
      // include a plugin
      this.use('Mustache');
    
      // define a 'route'
      this.get('#/', function() {
        // load some data
        this.load('posts.json')
            // render a template
            .renderEach('post.mustache')
            // swap the DOM with the new content
            .swap();
      });
    });
    
    // start the application
    app.run('#/');
    
     
  • francescoagati 9:01 pm il June 19, 2011 Permalink | Rispondi
    Etichette: , , , tdd,   

    Javascript: testare i deferred di jquery con jasmine 


    Jasmine , una libreria di testing in javascript, ha una serie di funzioni che permettono il test di comandi asincroni come eventi, intervalli e chiamate ajax.

    In questo esempio scritto in coffeescript ho fatto un elenco delle possibili tecniche che si posso usare per testare i deferred con jasmine:

    
    checkDeferred=(df,fn) ->
      callback = jasmine.createSpy()
      df.then(callback)
      waitsFor -> callback.callCount > 0
    
      runs -> 
        #expect(callback).toHaveBeenCalled()
        fn.apply @,callback.mostRecentCall.args if fn
    
    checkJson = (path,fn) ->
        checkDeferred $.getJSON(path),fn  
    
    describe "sum", ->
      x=0
      beforeEach ->
        x=1
    
      describe "mmm",->
        it "x==1", ->
          expect(x).toEqual(1)
    
    describe "getJson",->
      it "should be a==1", ->
        checkJson "temporeale.json", (json)->
          console.log(json)
          expect(json.a).toEqual(1)
    
      it "should load 3 times temporeale.json", ->
        checkDeferred $.when($.getJSON("temporeale.json"),$.getJSON("temporeale.json"),$.getJSON("temporeale.json")), (splats...) ->
         expect(splats.length).toEqual(3)
    
      describe "chek then and done", ->
    
          next=false
          list=[]
    
          beforeEach ->
    
            $.getJSON("temporeale.json")
            .then (json1)->
              console.log json1
              list.push json1
              $.getJSON("temporeale.json")
            .then (json2)->
              console.log json2
              list.push json2
              $.getJSON("temporeale.json")
            .then (json3)->
              console.log json3
              list.push json3
            .done ->
              next=true
    
            waitsFor -> next==true
    
          it "should populate list with 3 json", ->
            expect(list.length).toEqual(3)
    
          it "shuold 3 element be a with 1", ->
            expect(list[2].a).toEqual(1)
    

    come vedete alla riga 34 ho definito una variabile next settata a false, nel blocco beforeEach alla riga
    54 definisco il blocco waitsFor.
    In questo modo dico a jasmine di aspettare ad andare avanti a valutare il blocco it solo quando la variabile next è valorizzata con true
    nel blocco done alla riga 52, blocco che viene chiamato alla fine delle 3 chiamate ajax.
    Per i più pigri ecco l’equivalente js:

    (function() {
      var checkDeferred, checkJson;
      var __slice = Array.prototype.slice;
      checkDeferred = function(df, fn) {
        var callback;
        callback = jasmine.createSpy();
        df.then(callback);
        waitsFor(function() {
          return callback.callCount > 0;
        });
        return runs(function() {
          if (fn) {
            return fn.apply(this, callback.mostRecentCall.args);
          }
        });
      };
      checkJson = function(path, fn) {
        return checkDeferred($.getJSON(path), fn);
      };
      describe("sum", function() {
        var x;
        x = 0;
        beforeEach(function() {
          return x = 1;
        });
        return describe("mmm", function() {
          return it("x==1", function() {
            return expect(x).toEqual(1);
          });
        });
      });
      describe("getJson", function() {
        it("should be a==1", function() {
          return checkJson("temporeale.json", function(json) {
            console.log(json);
            return expect(json.a).toEqual(1);
          });
        });
        it("should load 3 times temporeale.json", function() {
          return checkDeferred($.when($.getJSON("temporeale.json"), $.getJSON("temporeale.json"), $.getJSON("temporeale.json")), function() {
            var splats;
            splats = 1 <= arguments.length ? __slice.call(arguments, 0) : [];
            return expect(splats.length).toEqual(3);
          });
        });
        return describe("chek then and done", function() {
          var list, next;
          next = false;
          list = [];
          beforeEach(function() {
            $.getJSON("temporeale.json").then(function(json1) {
              console.log(json1);
              list.push(json1);
              return $.getJSON("temporeale.json");
            }).then(function(json2) {
              console.log(json2);
              list.push(json2);
              return $.getJSON("temporeale.json");
            }).then(function(json3) {
              console.log(json3);
              return list.push(json3);
            }).done(function() {
              return next = true;
            });
            return waitsFor(function() {
              return next === true;
            });
          });
          it("should populate list with 3 json", function() {
            return expect(list.length).toEqual(3);
          });
          return it("shuold 3 element be a with 1", function() {
            return expect(list[2].a).toEqual(1);
          });
        });
      });
    }).call(this);
    
     
  • francescoagati 1:46 pm il June 15, 2011 Permalink | Rispondi
    Etichette: , , ,   

    Javascript: JsonSelect un css selector per json 


    JsonSelect è un linguaggio selettore ispirato ai selettori css e xpath. Attualmente disponibile per javascript,nodejs e ruby permette di fare patternmacthing, anche molto complessi, su strutture dati json caricate in memoria.

    La sintassi è simile ai css selector esempi come questi:

    :has(.lang:val(“Spanish”)) > .level

    string:last-child

    .weight:expr(x<180) ~ .name .first

    le potete trovare nel sito dove c’è anche una demo online per filtrare i dati.

     
  • francescoagati 10:36 pm il June 13, 2011 Permalink | Rispondi
    Etichette: , ,   

    Javascript: Js2coffee convertire javascrit in coffeescript 


    Js2coffee è un pacchetto di node js che permette di convertire script javascript anche molto complessi in coffeescript.

    Questa libreria può essere utilizzata da linea di comando installando direttamente con npm, oppure direttamente da browser copiando il javascript al sito di Js2Coffee.

    Trovate il sorgente e la guida d’installazione anche sul repository di github.

     
  • francescoagati 8:00 pm il June 11, 2011 Permalink | Rispondi
    Etichette: , , ,   

    Javascript: Quello che non vi hanno mai detto e la programmazione funzionale 


    Forse nessuno ve l’ha mai voluto dire….

    ma javascript……

    è anche un …..

    linguaggio….

    …..funzionale…..

    …..come……

    HASKELL

    quindi….

    buona visione con queste slide….

     
  • francescoagati 7:17 pm il June 11, 2011 Permalink | Rispondi
    Etichette: ,   

    Ruby e scala a confronto 


    Un interessante slide che ho trovato oggi mette a confronto questi 2 linguaggi sulla sintassi, modello funzionale, modello a oggetti, frameworks web e librerie.

    A voi i commenti ;-)

     
  • francescoagati 10:22 pm il June 10, 2011 Permalink | Rispondi
    Etichette: hmvc, kohana, , , , , , , , ,   

    Php: Framework mvc e nuovi paradigmi di programmazione 


    Con l’arrivo di php 5.3  una ventata di aria fresca inizia a girare nei framework web di php. E oltre ad adeguarsi alle nuove caratteristiche del linguaggio vengono introdotti nuovi paradigmi di programmazione.

    In particolare:

    Symfony2 – Introduce il concetto di dependency injection nella sua struttura mvc

    Lithium – Usa un approccio basato sull’aop (Aspected Oriented Programming) attraverso l’uso di filtri.

    Kohana – Introduce il concetto di HMVC (Hierarchical Model View Controller)

    Silex – Si appoggia a  symfony2 e Pimple  (un sistema di dependency injection) per fare un sistema minimale  di routing ispirato a Sinatra

    In queste 4 slide vengono presentate i paradigmi di questi 4 framework:

     
c
Componi il tuo articolo
j
Next post/Next comment
k
Previous post/Previous comment
r
Rispondi
e
Modifica
o
Show/Hide comments
t
Go to top
l
Go to login
h
Show/Hide help
shift + esc
Annulla
Iscriviti

Ricevi al tuo indirizzo email tutti i nuovi post del sito.