representable 0.0.1.alpha1 → 0.0.1

data/lib/representable/definition.rb

@@ -43,7 +43,7 @@ module Representable
       elsif opts[:from] == :namespace
         opts[:from] = '*'
         @sought_type = :namespace
-      elsif opts[:from].to_s.starts_with?('@')
+      elsif opts[:from].to_s =~ /^@/  # FIXME: move me to xml.
         @sought_type = :attr
         opts[:from].sub!('@', '')
       end
@@ -65,7 +65,6 @@ module Representable
       sought_type.is_a?(Class)
     end
     
-    
     def name?
       @name == '*'
     end
@@ -88,16 +87,6 @@ module Representable
       
       value
     end
-    
-    def to_ref
-      case sought_type
-      when :attr          then XMLAttributeRef
-      when :text          then XMLTextRef
-      when :namespace     then XMLNameSpaceRef
-      when Symbol         then raise ArgumentError, "Invalid type argument #{sought_type}"
-      else                     XMLObjectRef
-      end.new(self)
-    end
 
   private
     def extract_type(as)

data/lib/representable/json.rb

@@ -0,0 +1,66 @@
+require 'json'
+require 'representable/bindings/json_bindings'
+
+module Representable
+  module JSON
+    BINDING_FOR_TYPE = {  # TODO: refactor #representable_accessor for better extendability.
+      :text     => TextBinding,
+    }
+    def self.binding_for_definition(definition)
+      (BINDING_FOR_TYPE[definition.sought_type] or ObjectBinding).new(definition)
+    end
+    
+    def self.included(base)
+      base.class_eval do
+        include Representable
+        include InstanceMethods
+      end
+      base.extend ClassMethods  # DISCUSS: do that dynamically?
+    end
+    
+    module ClassMethods
+      # Creates a new Ruby object from XML using mapping information declared in the class.
+      #
+      # Example:
+      #  book = Book.from_xml("<book><name>Beyond Java</name></book>")
+      def from_json(data, options={})
+        # DISCUSS: extract #from_json call in Bindings to this place.
+        data = ::JSON[data] if data.is_a?(String) # DISCUSS: #from_json sometimes receives a string (in nestings).
+        data ||= {}
+        
+        data = data[representation_name] unless options[:wrap] == false
+        
+        create_from_json.tap do |inst|
+          refs = representable_attrs.map {|attr| JSON.binding_for_definition(attr) }
+          
+          refs.each do |ref|
+            value = ref.value_in(data)
+            
+            inst.send(ref.definition.setter, value)
+          end
+        end
+      end
+      
+    private
+      def create_from_json(*args)
+        new(*args)
+      end
+    end
+    
+    module InstanceMethods # :nodoc:
+      # Returns a Nokogiri::XML object representing this object.
+      def to_json(options={})
+        attributes = {}.tap do |root|
+          refs = self.class.representable_attrs.map {|attr| JSON.binding_for_definition(attr) }
+          
+          refs.each do |ref|
+            value = public_send(ref.accessor) # DISCUSS: eventually move back to Ref.
+            ref.update_json(root, value) if value
+          end
+        end
+        
+        options[:wrap] == false ? attributes : {self.class.representation_name => attributes}
+      end
+    end
+  end # Xml
+end

data/lib/representable/version.rb

@@ -1,3 +1,3 @@
 module Representable
-  VERSION = "0.0.1.alpha1"
+  VERSION = "0.0.1"
 end

data/lib/representable/xml.rb

@@ -1,50 +1,44 @@
+require 'representable'
+require 'representable/bindings/xml_bindings'
+
 module Representable
-  module Xml
-    module Declarations
-      # Sets the name of the XML element that represents this class. Use this
-      # to override the default lowercase class name.
-      #
-      # Example:
-      #  class BookWithPublisher
-      #   xml_name :book
-      #  end
-      #
-      # Without the xml_name annotation, the XML mapped tag would have been "bookwithpublisher".
-      def xml_name(name)
-        self.explicit_representation_name = name
-      end
-      
-      def xml_accessor(*args) # TODO: remove me, just for back-compat.
-        representable_accessor(*args)
+  module XML
+    BINDING_FOR_TYPE = {
+      :attr     => AttributeBinding,
+      :text     => TextBinding,
+      :namespace=> NamespaceBinding,
+    }
+    
+    def self.binding_for_definition(definition)
+      (BINDING_FOR_TYPE[definition.sought_type] or ObjectBinding).new(definition)
+    end
+    
+    def self.included(base)
+      base.class_eval do
+        include Representable
+        include InstanceMethods
+        extend ClassMethods
       end
-      
+    end
+    
+    class Definition < Representable::Definition
+      # FIXME: extract xml-specific from Definition.
     end
     
     module ClassMethods
+    def definition_class
+      Definition
+    end
+    
+      # Creates a new Ruby object from XML using mapping information declared in the class.
       #
-      # Creates a new Ruby object from XML using mapping information
-      # annotated in the class.
-      #
-      # The input data is either an XML::Node, String, Pathname, or File representing
-      # the XML document.
-      #
-      # Example
-      #  book = Book.from_xml(File.read("book.xml"))
-      # or
+      # Example:
       #  book = Book.from_xml("<book><name>Beyond Java</name></book>")
-      #
-      # _initialization_args_ passed into from_xml will be passed into
-      # the object's .new, prior to populating the xml_attrs.
-      #
-      # After the instatiation and xml population
-      #
-      # See also: xml_initialize
-      #
       def from_xml(data, *args)
         xml = Nokogiri::XML::Node.from(data)
 
         create_from_xml(*args).tap do |inst|
-          refs = representable_attrs.map {|attr| attr.to_ref }
+          refs = representable_attrs.map {|attr| XML.binding_for_definition(attr) }
           
           refs.each do |ref|
             value = ref.value_in(xml)
@@ -61,12 +55,12 @@ module Representable
     end
     
     module InstanceMethods # :nodoc:
-      # Returns an XML object representing this object
+      # Returns a Nokogiri::XML object representing this object.
       def to_xml(params={})
         params.reverse_merge!(:name => self.class.representation_name)
         
         Nokogiri::XML::Node.new(params[:name].to_s, Nokogiri::XML::Document.new).tap do |root|
-          refs = self.class.representable_attrs.map {|attr| attr.to_ref }
+          refs = self.class.representable_attrs.map {|attr| XML.binding_for_definition(attr) }
           
           refs.each do |ref|
             value = public_send(ref.accessor) # DISCUSS: eventually move back to Ref.

data/representable.gemspec

@@ -12,17 +12,18 @@ Gem::Specification.new do |s|
   s.email       = ["apotonick@gmail.com"]
   s.homepage    = "http://representable.apotomo.de"
   s.summary     = %q{Maps representation documents from and to Ruby objects. Includes XML and JSON support, plain properties and compositions.}
-  s.description = %q{CMaps representation documents from and to Ruby objects. Includes XML and JSON support, plain properties and compositions.}
+  s.description = %q{Maps representation documents from and to Ruby objects. Includes XML and JSON support, plain properties and compositions.}
   
   s.files         = `git ls-files`.split("\n")
   s.test_files    = `git ls-files -- {test,spec,features}/*`.split("\n")
   s.executables   = `git ls-files -- bin/*`.split("\n").map{ |f| File.basename(f) }
   s.require_paths = ["lib"]
   
-  s.add_dependency "activesupport",  "~> 3.0.0"
+  s.add_dependency "activesupport"
   s.add_dependency "hooks"
   s.add_dependency "nokogiri"
   s.add_dependency "i18n"
+  s.add_dependency "json"
   
   s.add_development_dependency "rspec"
   s.add_development_dependency "test_xml"

data/test/bindings_test.rb

@@ -0,0 +1,110 @@
+require 'test_helper'
+
+class ReferenceTest < MiniTest::Spec
+  describe "ObjectRef with []" do
+    before do
+      @ref = Representable::XML::ObjectBinding.new(Representable::Definition.new(:songs, :as => [Hash]))
+    end
+      
+    it "responds to #default" do
+      assert_equal [], @ref.send(:default)
+    end
+  end
+  
+  
+  describe "TextRef#value_in" do
+    def parse_xml(xml); Nokogiri::XML::Node.from(xml); end
+    
+    before do
+      @ref = Representable::XML::TextBinding.new(Representable::Definition.new(:song))
+    end
+    
+    it "returns found value" do
+      assert_equal "Unkoil", @ref.value_in(parse_xml("<a><song>Unkoil</song></a>"))
+    end
+  end
+end
+
+class DefinitionTest < MiniTest::Spec
+  describe "generic API" do
+    before do
+      @def = Representable::Definition.new(:songs)
+    end
+    
+    it "responds to #typed?" do
+      assert ! @def.typed?
+      assert Representable::Definition.new(:songs, :as => Hash).typed?
+      assert Representable::Definition.new(:songs, :as => [Hash]).typed?
+    end
+  end
+  
+  
+  describe "#apply" do
+    it "works with a single item" do
+      @d = Representable::Definition.new(:song)
+      assert_equal 2, @d.apply(1) { |v| v+1 }
+    end
+    
+    it "works with collection" do
+      @d = Representable::Definition.new(:song, :as => [])
+      assert_equal [2,3,4], @d.apply([1,2,3]) { |v| v+1 }
+    end
+    
+    it "skips with collection and nil" do
+      @d = Representable::Definition.new(:song, :as => [])
+      assert_equal nil, @d.apply(nil) { |v| v+1 }
+    end
+  end
+    
+  describe ":as => []" do
+    before do
+      @def = Representable::Definition.new(:songs, :as => [], :tag => :song)
+    end
+    
+    it "responds to #accessor" do
+      assert_equal "songs", @def.accessor
+    end
+    
+    it "responds to #array?" do
+      assert @def.array?
+    end
+    
+    it "responds to #name" do
+      assert_equal "songs", @def.accessor 
+    end
+    
+    it "responds to #instance_variable_name" do
+      assert_equal :"@songs", @def.instance_variable_name
+    end
+    
+    it "responds to #setter" do
+      assert_equal :"songs=", @def.setter
+    end
+    
+    it "responds to #sought_type" do
+      assert_equal :text, @def.sought_type
+    end
+  end
+    
+    
+  describe ":as => [Item]" do
+    before do
+      @def = Representable::Definition.new(:songs, :as => [Hash])
+    end
+    
+    it "responds to #sought_type" do
+      assert_equal Hash, @def.sought_type
+    end
+  end
+  
+  
+  describe ":as => Item" do
+    before do
+      @def = Representable::Definition.new(:songs, :as => Hash)
+    end
+    
+    it "responds to #sought_type" do
+      assert_equal Hash, @def.sought_type
+    end
+  end
+end

data/test/json_test.rb

@@ -0,0 +1,130 @@
+require 'test_helper'
+require 'representable/json'
+
+module JsonTest
+  class APITest < MiniTest::Spec
+    Json = Representable::JSON
+    Def = Representable::Definition
+    
+    describe "Xml module" do
+      describe "#binding_for_definition" do
+        it "returns ObjectBinding" do
+          assert_kind_of Json::ObjectBinding, Json.binding_for_definition(Def.new(:band, :as => Hash))
+        end
+        
+        it "returns TextBinding" do
+          assert_kind_of Json::TextBinding, Json.binding_for_definition(Def.new(:band))
+        end
+      end
+    end
+  end
+
+  class PropertyTest < MiniTest::Spec
+    describe "property :name" do
+      class Band
+        include Representable::JSON
+        representable_property :name
+      end
+      
+      it "#from_json creates correct accessors" do
+        band = Band.from_json({:band => {:name => "Bombshell Rocks"}}.to_json)
+        assert_equal "Bombshell Rocks", band.name
+      end
+    
+      it "#to_json serializes correctly" do
+        band = Band.new
+        band.name = "Cigar"
+        
+        assert_equal "{\"band\"=>{\"name\"=>\"Cigar\"}}", band.to_json.to_s
+      end
+    end
+    
+    describe "property :name, :as => []" do
+      class CD
+        include Representable::JSON
+        representable_property :songs, :as => []
+      end
+      
+      it "#from_json creates correct accessors" do
+        cd = CD.from_json({:cd => {:songs => ["Out in the cold", "Microphone"]}}.to_json)
+        assert_equal ["Out in the cold", "Microphone"], cd.songs
+      end
+    
+      it "#to_json serializes correctly" do
+        cd = CD.new
+        cd.songs = ["Out in the cold", "Microphone"]
+        
+        assert_equal "{\"cd\"=>{\"songs\"=>[\"Out in the cold\", \"Microphone\"]}}", cd.to_json.to_s
+      end
+    end
+  end
+
+  class TypedPropertyTest < MiniTest::Spec
+    describe ":as => Item" do
+      class Label
+        include Representable::JSON
+        representable_property :name
+      end
+      
+      class Album
+        include Representable::JSON
+        representable_property :label, :as => Label
+      end
+      
+      it "#from_json creates one Item instance" do
+        album = Album.from_json({:album => {:label => "Fat Wreck"}}.to_json)
+        assert_equal "Bad Religion", album.label.name
+      end
+      
+      describe "#to_json" do
+        it "serializes" do
+          label = Label.new; label.name = "Fat Wreck"
+          album = Album.new; album.label = label
+          
+          assert_equal "{\"album\"=>{\"label\"=>{\"name\"=>\"Fat Wreck\"}}}", album.to_json.to_s
+        end
+      end
+    end
+  end
+
+
+  class CollectionTest < MiniTest::Spec
+    describe ":as => [Band]" do
+      class Band
+        include Representable::JSON
+        representable_property :name
+        
+        def initialize(name="")
+          self.name = name
+        end
+      end
+      
+      class Compilation
+        include Representable::JSON
+        representable_property :bands, :as => [Band]
+      end
+      
+      describe "#from_json" do
+        it "pushes collection items to array" do
+          cd = Compilation.from_json({:compilation => {:bands => [
+            {:name => "Cobra Skulls"},
+            {:name => "Diesel Boy"}]}}.to_json)
+          assert_equal ["Cobra Skulls", "Diesel Boy"], cd.bands.map(&:name).sort
+        end
+        
+        it "collections can be empty" do
+          cd = Compilation.from_json({:compilation => {}}.to_json)
+          assert_equal [], cd.bands
+        end
+      end
+      
+      it "responds to #to_json" do
+        cd = Compilation.new
+        cd.bands = [Band.new("Diesel Boy"), Band.new("Bad Religion")]
+        
+        assert_equal "{\"compilation\"=>{\"bands\"=>[{\"name\"=>\"Diesel Boy\"}, {\"name\"=>\"Bad Religion\"}]}}", cd.to_json.to_s
+      end
+    end
+      
+  end
+end