siren 0.2.0

data/lib/siren/node.rb

@@ -0,0 +1,37 @@
+module Siren
+  module Node
+    
+    def from_json(hash)
+      object = self.new
+      hash.each do |key, value|
+        object.instance_variable_set("@#{key}", value)
+        if Reference === value
+          value.on(:resolve) do |ref, root, symbols|
+            object.instance_variable_set("@#{key}", ref.find(root, symbols, object))
+          end
+        end
+      end
+      object
+    end
+    
+    @classes = {}
+    
+    def self.extended(base)
+      @classes[base.name.split('::').last] = base
+    end
+    
+    def self.from_json(hash)
+      hash = Siren.parse(hash) if String === hash
+      return hash unless Hash === hash && hash[TYPE_FIELD]
+      klass = find_class(hash[TYPE_FIELD])
+      klass ? klass.from_json(hash) : hash
+    end
+    
+    def self.find_class(name)
+      name = name.to_s.gsub(/\/(.?)/) { "::#{$1.upcase}" }.gsub(/(?:^|_)(.)/) { $1.upcase }
+      @classes[name]
+    end
+    
+  end
+end
+

data/lib/siren/parser.rb

@@ -0,0 +1,205 @@
+# Based on http://www.json.org/json_parse.js (public domain)
+
+module Siren
+  class Parser
+    
+    include Walker
+    
+    ESCAPEE = {
+      '"'   => '"',
+      '\\'  => '\\',
+      '/'   => '/',
+      'b'   => '\b',
+      'f'   => '\f',
+      'n'   => '\n',
+      'r'   => '\r',
+      't'   => '\t'
+    }
+    
+    attr_reader :at,     # The index of the current character
+                :ch      # The current character
+    
+    def parse(source, &reviver)
+      @text = source.dup
+      @at, @ch = 0, ' '
+      result = value!
+      white!
+      error! "Syntax error" if @ch
+      
+      walk(result, &reviver)
+    end
+    
+  private
+    
+    def next!(c = nil)
+      # If a c parameter is provided, verify that it matches the current character.
+      error! "Expected '#{c}' instead of '#{@ch}'" if c && c != @ch
+      
+      # Get the next character. When there are no more characters,
+      # return the empty string.
+      @ch = @text[at].chr rescue nil
+      @at += 1
+      @ch
+    end
+    
+    # Parse a number value.
+    def number!
+      string = ''
+      if @ch == '-'
+        string = '-'
+        next!('-')
+      end
+      while @ch >= '0' && @ch <= '9'
+        string += @ch
+        next!
+      end
+      if @ch == '.'
+        string += '.'
+        while next! && @ch >= '0' && @ch <= '9'
+          string += @ch
+        end
+      end
+      if @ch == 'e' || @ch == 'E'
+        string += @ch
+        next!
+        if @ch == '-' || @ch == '+'
+          string += @ch
+          next!
+        end
+        while @ch >= '0' && @ch <= '9'
+          string += @ch
+          next!
+        end
+      end
+      string.to_f
+    rescue
+      error! "Bad number"
+    end
+    
+    #Parse a string value.
+    def string!
+      string = ''
+      # When parsing for string values, we must look for " and \ characters.
+      if @ch == '"'
+        while next!
+          if @ch == '"'
+            next!
+            return string
+          elsif ch == '\\'
+            next!
+            if @ch == 'u'
+              uffff = 0
+              4.times do
+                hex = next!.to_i(16)
+                uffff = uffff * 16 + hex
+              end
+              string += uffff.chr
+            elsif String === ESCAPPE[@ch]
+              string += ESCAPPE[@ch]
+            else
+              break
+            end
+          else
+            string += @ch
+          end
+        end
+      end
+      error! "Bad string"
+    end
+    
+    # Skip whitespace.
+    def white!
+      next! while @ch && @ch <= ' '
+    end
+    
+    # true, false, undefined or null.
+    def word!
+      case @ch
+        when 't'
+          %w(t r u e).each { |c| next!(c) }
+          return true
+        when 'f'
+          %w(f a l s e).each { |c| next!(c) }
+          return nil
+        when 'n'
+          %w(n u l l).each { |c| next!(c) }
+          return nil
+      end
+      error! "Unexpected '#{@ch}'"
+    end
+    
+    # Parse an array value.
+    def array!
+      array = []
+      
+      if @ch == '['
+        next!('[')
+        white!
+        if @ch == ']'
+          next!(']')
+          return array   # empty array
+        end
+        while @ch
+          array << value!
+          white!
+          if @ch == ']'
+            next!(']')
+            return array
+          end
+          next!(',')
+          white!
+        end
+      end
+      error! "Bad array"
+    end
+    
+    # Parse an object value.
+    def object!
+      object = {}
+
+      if @ch == '{'
+        next!('{')
+        white!
+        if @ch == '}'
+          next!('}')
+          return object   # empty object
+        end
+        while @ch
+          key = string!
+          white!
+          next!(':')
+          error! 'Duplicate key "#{key}"' if object.has_key?(key)
+          object[key] = value!
+          white!
+          if @ch == '}'
+            next!('}')
+            return object
+          end
+          next!(',')
+          white!
+        end
+      end
+      error! "Bad object"
+    end
+    
+    # Parse a JSON value. It could be an object, an array, a string, a number,
+    # or a word.
+    def value!
+      white!
+      case @ch
+        when '{' then object!
+        when '[' then array!
+        when '"' then string!
+        when '-' then number!
+        else       @ch >= '0' && @ch <= '9' ? number! : word!
+      end
+    end
+    
+    # Call error when something is wrong.
+    def error!(message = nil)
+      raise Exception
+    end
+    
+  end
+end
+

data/lib/siren/reference.rb

@@ -0,0 +1,30 @@
+module Siren
+  class Reference
+    
+    include Eventful
+    
+    def self.flush!
+      @@cache = {}
+    end
+    
+    def self.resolve!(root, symbols)
+      @@cache.each { |id, ref| ref.resolve!(root, symbols) }
+    end
+    
+    def initialize(hash)
+      @query = Siren.compile_query(hash[REF_FIELD])
+      @@cache ||= {}
+      @@cache[hash.__id__] = self
+    end
+    
+    def resolve!(root, symbols)
+      fire(:resolve, root, symbols)
+    end
+    
+    def find(root, symbols, current)
+      @query.value(root, symbols, current)
+    end
+    
+  end
+end
+

data/lib/siren/walker.rb

@@ -0,0 +1,33 @@
+module Siren
+  module Walker
+    
+    # If there is a reviver function, we recursively walk the new structure,
+    # passing each name/value pair to the reviver function for possible
+    # transformation, starting with a temporary root object that holds the result
+    # in an empty key. If there is not a reviver function, we simply return the
+    # result.
+    def walk(data, &reviver)
+      data = parse(data) if String === data
+      return data unless block_given?
+      
+      walker = lambda do |holder, key|
+        value = holder[key]
+        
+        Siren.each(value) do |k, val|
+          v = walker.call(value, k)
+          if v.nil?
+            holder.delete(k)
+          else
+            value[k] = v
+          end
+        end
+        
+        reviver.call(holder, key, value)
+      end
+      
+      walker.call({"" => data}, "")
+    end
+    
+  end
+end
+

data/test/fixtures/beatles.json

@@ -0,0 +1,11 @@
+{
+    "people": [
+        {"name":  "John",   "age":  23},
+        {"name":  "Paul",   "age":  21},
+        {"name":  "George", "age":  12},
+        {"name":  "Ringo",  "age":  17}
+    ],
+    
+    "adults": {"$ref": "$.people[? @.age >= 18 ]"}
+}
+

data/test/fixtures/car.rb

@@ -0,0 +1,14 @@
+class Car
+  extend Siren::Node
+  
+  attr_reader :brand
+  
+  def initialize(brand = nil)
+    @brand = brand
+  end
+  
+  def ==(other)
+    @brand == other.brand
+  end
+end
+

data/test/fixtures/names.json

@@ -0,0 +1,7 @@
+[
+    {"first": "Thom",   "last": "Yorke"},
+    {"first": "Jonny",  "last": "Greenwood"},
+    {"first": "Ed",     "last": "O'Brien"},
+    {"first": "Colin",  "last": "Greenwood"},
+    {"first": "Phil",   "last": "Selway"}
+]

data/test/fixtures/people.json

@@ -0,0 +1,34 @@
+{
+    "people": [
+        {
+            "type":   "person",
+            "cars": [
+                {
+                    "type":   "car",
+                    "brand":  "ford"
+                }
+            ]
+        },
+        
+        {
+            "type":   "person",
+            "cars": [
+                {
+                    "type":   "Car",
+                    "brand":  "ferrari"
+                },
+                
+                {
+                    "type":   "car",
+                    "brand":  "bentley"
+                },
+                
+                {
+                    "type":   "car",
+                    "brand":  "zonda"
+                }
+            ]
+        }
+    ]
+}
+

data/test/fixtures/person.rb

@@ -0,0 +1,15 @@
+class Person
+  extend Siren::Node
+  
+  attr_reader :id, :cars, :favourite, :handle
+  
+  def initialize(*cars)
+    @cars = cars.map { |brand| Car.new(brand) }
+  end
+  
+  def ==(other)
+    @cars.size == other.cars.size &&
+        @cars.all? { |car| other.cars.include?(car) }
+  end
+end
+

data/test/fixtures/refs.json

@@ -0,0 +1,26 @@
+[
+    {
+        "id":   "mike",
+        "favourite":  {"$ref": "mike"}
+    },
+    
+    {
+        "type": "person",
+        "id":   "bob",
+        "favourite":  {"$ref": "bob"}
+    },
+    
+    {
+        "type": "person",
+        "id":   "romeo",
+        "handle":     {"$ref": "@.id"},
+        "favourite":  {"$ref": "juliet"}
+    },
+    
+    {
+        "type": "person",
+        "id":   "juliet",
+        "favourite":  {"$ref": "romeo"}
+    }
+]
+

data/test/fixtures/store.json

@@ -0,0 +1,32 @@
+{ "store": {
+    "book": [ 
+      { "category": "reference",
+        "author": "Nigel Rees",
+        "title": "Sayings of the Century",
+        "price": 8.95
+      },
+      { "category": "fiction",
+        "author": "Evelyn Waugh",
+        "title": "Sword of Honour",
+        "price": 12.99
+      },
+      { "category": "fiction",
+        "author": "Herman Melville",
+        "title": "Moby Dick",
+        "isbn": "0-553-21311-3",
+        "price": 8.99
+      },
+      { "category": "fiction",
+        "author": "J. R. R. Tolkien",
+        "title": "The Lord of the Rings",
+        "isbn": "0-395-19395-8",
+        "price": 22.99
+      }
+    ],
+    "bicycle": {
+      "color": "red",
+      "price": 19.95
+    }
+  }
+}
+