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

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…

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

• backbone-rails:

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.

• backbone-handlebars:

aggiunge il supporto di handlerbars alle view di backbone

Ember.js

• rasputin:

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

Spine

• spine.rails:

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

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('#/');

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);

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.

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.

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….

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

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: