representable 1.7.7 → 1.8.0

data/lib/representable/serializer.rb

@@ -2,8 +2,14 @@ require "representable/deserializer"
 
 module Representable
   class ObjectSerializer < ObjectDeserializer
-    def call # TODO: make typed? switch here!
-      return @object if @object.nil?
+    def initialize(binding, object)
+      super(binding)
+      @object = object
+    end
+
+    def call
+      # return unless @binding.typed? # FIXME: fix that in XML/YAML.
+      return @object if @object.nil? # DISCUSS: move to Object#serialize ?
 
       representable = prepare(@object)
 
@@ -12,8 +18,7 @@ module Representable
 
   private
     def serialize(object, user_options)
-      # TODO: this used to be handled in #serialize where Object added it's behaviour. treat scalars as objects to remove this switch:
-      return object unless @binding.typed?
+      return object unless @binding.representable?
 
       object.send(@binding.serialize_method, user_options.merge!({:wrap => false}))
     end

data/lib/representable/version.rb

@@ -1,3 +1,3 @@
 module Representable
-  VERSION = "1.7.7"
+  VERSION = "1.8.0"
 end

data/lib/representable/xml.rb

@@ -52,7 +52,7 @@ module Representable
     # Returns a Nokogiri::XML object representing this object.
     def to_node(options={})
       options[:doc] ||= Nokogiri::XML::Document.new
-      root_tag = options[:wrap] || representation_wrap
+      root_tag = options[:wrap] || representation_wrap(options)
 
       create_representation_with(Nokogiri::XML::Node.new(root_tag.to_s, options[:doc]), options, PropertyBinding)
     end

data/lib/representable/xml/collection.rb

@@ -1,5 +1,3 @@
-require 'representable/hash/collection'
-
 module Representable::XML
   module Collection
     include Representable::XML

data/lib/representable/yaml.rb

@@ -1,4 +1,3 @@
-require 'representable/hash'
 require 'representable/bindings/yaml_bindings'
 
 module Representable

data/representable.gemspec

@@ -21,6 +21,7 @@ Gem::Specification.new do |s|
 
   s.add_dependency "nokogiri"
   s.add_dependency "multi_json"
+  s.add_dependency "uber"
 
   s.add_development_dependency "rake"
   s.add_development_dependency "test_xml", ">= 0.1.6"

data/test/as_test.rb

@@ -0,0 +1,43 @@
+require 'test_helper'
+
+class AsTest < MiniTest::Spec
+  for_formats(
+    :hash => [Representable::Hash, {"title" => "Wie Es Geht"}, {"title" => "Revolution"}],
+    # :xml  => [Representable::XML, "<open_struct>\n  <song>\n    <name>Alive</name>\n  </song>\n</open_struct>", "<open_struct><song><name>You've Taken Everything</name></song>/open_struct>"],
+    # :yaml => [Representable::YAML, "---\nsong:\n  name: Alive\n", "---\nsong:\n  name: You've Taken Everything\n"],
+  ) do |format, mod, input, output|
+
+    let (:song) { representer.prepare(Song.new("Revolution")) }
+    let (:format) { format }
+
+
+    describe "as: with :symbol" do
+      representer!(:module => mod) do
+        property :name, :as => :title
+      end
+
+      it { render(song).must_equal_document output }
+      it { parse(song, input).name.must_equal "Wie Es Geht" }
+    end
+
+
+    describe "as: with lambda" do
+      representer!(:module => mod) do
+        property :name, :as => lambda { |*| "#{self.class}" }
+      end
+
+      it { render(song).must_equal_document({"Song" => "Revolution"}) }
+      it { parse(song, {"Song" => "Wie Es Geht"}).name.must_equal "Wie Es Geht" }
+    end
+
+
+    describe "lambda arguments" do
+      representer! do
+        property :name, :as => lambda { |*args| args.inspect }
+      end
+
+      it { render(song, :volume => 1).must_equal_document({"[{:volume=>1}]" => "Revolution"}) }
+      it { parse(song, {"[{:volume=>1}]" => "Wie Es Geht"}, :volume => 1).name.must_equal "Wie Es Geht" }
+    end
+  end
+end

data/test/class_test.rb

@@ -0,0 +1,124 @@
+require 'test_helper'
+
+class ClassTest < BaseTest
+
+  class RepresentingSong
+    attr_reader :name
+
+    def from_hash(doc, *args)
+      @name = doc["__name__"]
+
+      self # DISCUSS: do we wanna be able to return whatever we want here? this is a trick to replace the actual object
+    end
+  end
+
+
+  describe "class: ClassName, only" do
+    representer! do
+      property :song, :class => RepresentingSong # supposed this class exposes #from_hash itself.
+    end
+
+    it "creates fresh instance and doesn't extend" do
+      song = representer.prepare(OpenStruct.new).from_hash({"song" => {"__name__" => "Captured"}}).song
+      song.must_be_instance_of RepresentingSong
+      song.name.must_equal "Captured"
+    end
+  end
+
+
+  describe "class: lambda, only" do
+    representer! do
+      property :song, :class => lambda { |*| RepresentingSong }
+    end
+
+    it "creates fresh instance and doesn't extend" do
+      song = representer.prepare(OpenStruct.new).from_hash({"song" => {"__name__" => "Captured"}}).song
+      song.must_be_instance_of RepresentingSong
+      song.name.must_equal "Captured"
+    end
+  end
+
+
+  describe "lambda { nil }" do # TODO: remove in 2.0.
+    representer! do
+      property :title, :class  => nil
+    end
+
+    it "skips creating new instance" do
+      object = Object.new
+      object.instance_eval do
+        def from_hash(hash, *args)
+          hash
+        end
+      end
+
+      song = OpenStruct.new.extend(representer).from_hash(hash = {"title" => object})
+      song.title.must_equal object
+    end
+  end
+
+
+  describe "lambda receiving fragment and args" do
+    let (:klass) { Class.new do
+      class << self
+        attr_accessor :args
+      end
+
+      def from_hash(*)
+        self.class.new
+      end
+    end }
+
+    representer!(:inject => :klass) do
+      _klass = klass
+      property :song, :class => lambda { |fragment, args| _klass.args=([fragment,args]); _klass }
+    end
+
+    it { representer.prepare(OpenStruct.new).from_hash({"song" => {"name" => "Captured"}}, :volume => true).song.class.args.
+      must_equal([{"name"=>"Captured"}, {:volume=>true}]) }
+  end
+
+
+  describe "collection: lambda receiving fragment and args" do
+    let (:klass) { Class.new do
+      class << self
+        attr_accessor :args
+      end
+
+      def from_hash(*)
+        self.class.new
+      end
+    end }
+
+    representer!(:inject => :klass) do
+      _klass = klass
+      collection :songs, :class => lambda { |fragment, i, args| _klass.args=([fragment,i,args]); _klass }
+    end
+
+    it { representer.prepare(OpenStruct.new).from_hash({"songs" => [{"name" => "Captured"}]}, :volume => true).songs.first.class.args.
+      must_equal([{"name"=>"Captured"}, 0, {:volume=>true}]) }
+  end
+
+
+  describe "class: implementing #from_hash" do
+    let(:parser) do
+      Class.new do
+        def from_hash(*)
+          [1,2,3,4]
+        end
+      end
+    end
+
+    representer!(:inject => :parser) do
+      property :song, :class => parser # supposed this class exposes #from_hash itself.
+    end
+
+    it "allows returning arbitrary objects in #from_hash" do
+      representer.prepare(OpenStruct.new).from_hash({"song" => 1}).song.must_equal [1,2,3,4]
+    end
+  end
+end
+
+#TODO: test fragment,
+
+# `class: Song` only, no :extend.

data/test/config_test.rb

@@ -1,5 +1,7 @@
 require 'test_helper'
 
+# tested feature: ::property
+
 class ConfigTest < MiniTest::Spec
   subject { Representable::Config.new }
   PunkRock = Class.new
@@ -8,17 +10,17 @@ class ConfigTest < MiniTest::Spec
 
   describe "wrapping" do
     it "returns false per default" do
-      assert_equal nil, subject.wrap_for("Punk")
+      assert_equal nil, subject.wrap_for("Punk", nil)
     end
 
     it "infers a printable class name if set to true" do
       subject.wrap = true
-      assert_equal "punk_rock", subject.wrap_for(PunkRock)
+      assert_equal "punk_rock", subject.wrap_for(PunkRock, nil)
     end
 
     it "can be set explicitely" do
       subject.wrap = "Descendents"
-      assert_equal "Descendents", subject.wrap_for(PunkRock)
+      assert_equal "Descendents", subject.wrap_for(PunkRock, nil)
     end
   end
 
@@ -35,6 +37,14 @@ class ConfigTest < MiniTest::Spec
     it "returns Definition" do
       (subject << definition).must_equal definition
     end
+
+    it "overwrites old property" do
+      subject << definition
+      subject << overrider = Representable::Definition.new(:title)
+
+      subject.size.must_equal 1
+      subject.first.must_equal overrider
+    end
   end
 
   describe "#[]" do

data/test/decorator_scope_test.rb

@@ -0,0 +1,28 @@
+require 'test_helper'
+
+# TODO: remove in 2.0.
+class DecoratorScopeTest < MiniTest::Spec
+  representer! do
+    property :title, :getter => lambda { |*| title_from_representer }, :decorator_scope => true
+  end
+
+  let (:representer_with_method) {
+    Module.new do
+      include Representable::Hash
+      property :title, :decorator_scope => true
+      def title; "Crystal Planet"; end
+    end
+   }
+
+  it "executes lambdas in represented context" do
+    Class.new do
+      def title_from_representer
+        "Sounds Of Silence"
+      end
+    end.new.extend(representer).to_hash.must_equal({"title"=>"Sounds Of Silence"})
+  end
+
+  it "executes method in represented context" do
+    Object.new.extend(representer_with_method).to_hash.must_equal({"title"=>"Crystal Planet"})
+  end
+end

data/test/definition_test.rb

@@ -1,16 +1,31 @@
 require 'test_helper'
 
 class DefinitionTest < MiniTest::Spec
+  Definition = Representable::Definition
+
+  describe "#merge!" do
+    let (:definition) { Definition.new(:song) }
+
+    it "runs macros" do
+      definition[:setter].must_equal nil
+      definition.merge!(:parse_strategy => :sync)
+      definition[:setter].must_respond_to :evaluate
+    end
+
+    # it "what" do
+    #   definition.merge!(:parse_strategy => :sync, :collection => true)
+    #   definition[:bullshit].must_equal true
+    # end
+  end
+
   describe "generic API" do
     before do
       @def = Representable::Definition.new(:songs)
     end
 
-    describe "DCI" do
-      it "responds to #representer_module" do
-        assert_equal nil, Representable::Definition.new(:song).representer_module
-        assert_equal Hash, Representable::Definition.new(:song, :extend => Hash).representer_module
-      end
+    it "responds to #representer_module" do
+      assert_equal nil, Representable::Definition.new(:song).representer_module
+      assert_equal Hash, Representable::Definition.new(:song, :extend => Hash).representer_module.evaluate(nil)
     end
 
     describe "#typed?" do
@@ -31,6 +46,16 @@ class DefinitionTest < MiniTest::Spec
       end
     end
 
+
+    describe "#representable?" do
+      it { assert Definition.new(:song, :representable => true).representable? }
+      it { Definition.new(:song, :representable => true, :extend => Object).representable?.must_equal true }
+      it { refute Definition.new(:song, :representable => false, :extend => Object).representable? }
+      it { assert Definition.new(:song, :extend => Object).representable? }
+      it { refute Definition.new(:song).representable? }
+    end
+
+
     it "responds to #getter and returns string" do
       assert_equal "songs", @def.getter
     end
@@ -43,18 +68,14 @@ class DefinitionTest < MiniTest::Spec
       assert_equal :"songs=", @def.setter
     end
 
-    it "responds to #deserialize_class" do
-      assert_equal nil, @def.deserialize_class
-    end
-
     describe "#clone" do
       it "clones @options" do
-        @def.options[:volume] = 9
+        @def.merge!(:volume => 9)
         cloned = @def.clone
-        cloned.options[:volume] = 8
+        cloned.merge!(:volume => 8)
 
-        assert_equal @def.options[:volume], 9
-        assert_equal cloned.options[:volume], 8
+        assert_equal @def[:volume], 9
+        assert_equal cloned[:volume], 8
       end
     end
   end
@@ -178,18 +199,18 @@ class DefinitionTest < MiniTest::Spec
 
   describe "#binding" do
     it "returns true when :binding is set" do
-      assert Representable::Definition.new(:songs, :binding => Object).binding
+      assert Representable::Definition.new(:songs, :binding => Object)[:binding]
     end
 
     it "returns false when :binding is not set" do
-      assert !Representable::Definition.new(:songs).binding
+      assert !Representable::Definition.new(:songs)[:binding]
     end
   end
 
   describe "#create_binding" do
     it "executes the block (without special context)" do
       definition = Representable::Definition.new(:title, :binding => lambda { |*args| @binding = Representable::Binding.new(*args) })
-      definition.create_binding(object=Object.new).must_equal @binding
+      definition.create_binding(object=Object.new, nil, nil).must_equal @binding
       @binding.instance_variable_get(:@represented).must_equal object
     end
   end
@@ -203,34 +224,21 @@ class DefinitionTest < MiniTest::Spec
       assert @def.array?
     end
 
-    it "responds to #deserialize_class" do
-      assert_equal nil, @def.deserialize_class
-    end
-
     it "responds to #default" do
       assert_equal nil, @def.send(:default)
     end
   end
 
-  describe ":class => Item" do
-    before do
-      @def = Representable::Definition.new(:songs, :class => Hash)
-    end
-
-    it "responds to #deserialize_class" do
-      assert_equal Hash, @def.deserialize_class
-    end
-  end
 
   describe ":default => value" do
     it "responds to #default" do
       @def = Representable::Definition.new(:song)
-      assert_equal nil, @def.send(:default)
+      assert_equal nil, @def[:default]
     end
 
     it "accepts a default value" do
       @def = Representable::Definition.new(:song, :default => "Atheist Peace")
-      assert_equal "Atheist Peace", @def.send(:default)
+      assert_equal "Atheist Peace", @def[:default]
     end
   end
 
@@ -251,12 +259,15 @@ class DefinitionTest < MiniTest::Spec
     end
 
     it "responds to #binding" do
-      assert_equal subject.binding, Object
+      assert_equal subject[:binding], Object
     end
   end
 
-  describe "#sync?" do
-    it { Representable::Definition.new(:song).sync?.must_equal false }
-    it { Representable::Definition.new(:song, :parse_strategy => :sync).sync?.must_equal true }
+  describe "#[]=" do
+    it "raises exception since it's deprecated" do
+      assert_raises NoMethodError do
+        Definition.new(:title)[:extend] = Module.new # use merge! after initialize.
+      end
+    end
   end
 end