representable 1.7.7 → 1.8.0

data/test/prepare_test.rb

@@ -0,0 +1,67 @@
+require 'test_helper'
+
+class PrepareTest < BaseTest
+  class PreparerClass
+    def initialize(object)
+      @object = object
+    end
+
+    def ==(b)
+      return unless b.instance_of?(PreparerClass)
+
+      object == b.object
+    end
+
+    attr_reader :object
+  end
+
+  describe "#to_hash" do # TODO: introduce :representable option?
+    representer! do
+      property :song,
+        :prepare       => lambda { |obj, args| args.binding[:arbitrary].new(obj) },
+        :arbitrary     => PreparerClass,
+        :extend => true,
+        :pass_options  => true,
+        :representable => false # don't call #to_hash.
+    end
+
+    let (:hit) { Struct.new(:song).new(song).extend(representer) }
+
+    it "calls prepare:, nothing else" do
+      # render(hit).must_equal_document(output)
+      hit.to_hash.must_equal({"song" => PreparerClass.new(song)})
+    end
+
+
+    # it "calls #from_hash on the existing song instance, nothing else" do
+    #   song_id = hit.song.object_id
+
+    #   parse(hit, input)
+
+    #   hit.song.title.must_equal "Suffer"
+    #   hit.song.object_id.must_equal song_id
+    # end
+  end
+
+
+  describe "#from_hash" do
+    representer! do
+      property :song,
+        :prepare       => lambda { |obj, args| args.binding[:arbitrary].new(obj) },
+        :arbitrary     => PreparerClass,
+        #:extend => true, # TODO: typed: true would be better.
+        :instance => String.new, # pass_fragment
+        :pass_options  => true,
+        :representable => false # don't call #to_hash.
+    end
+
+    let (:hit) { Struct.new(:song).new.extend(representer) }
+
+    it "calls prepare:, nothing else" do
+      # render(hit).must_equal_document(output)
+      hit.from_hash("song" => {})
+
+      hit.song.must_equal(PreparerClass.new(String.new))
+    end
+  end
+end

data/test/reader_writer_test.rb

@@ -0,0 +1,19 @@
+require 'test_helper'
+
+class ReaderWriterTest < BaseTest
+  representer! do
+    property :name,
+      :writer => lambda { |doc, args| doc["title"] = "#{args[:nr]}) #{name}" },
+      :reader => lambda { |doc, args| self.name = doc["title"].split(") ").last }
+  end
+
+  subject { OpenStruct.new(:name => "Disorder And Disarray").extend(representer) }
+
+  it "uses :writer when rendering" do
+    subject.to_hash(:nr => 14).must_equal({"title" => "14) Disorder And Disarray"})
+  end
+
+  it "uses :reader when parsing" do
+    subject.from_hash({"title" => "15) The Wars End"}).name.must_equal "The Wars End"
+  end
+end

data/test/representable_test.rb

@@ -90,7 +90,7 @@ class RepresentableTest < MiniTest::Spec
           include parent
         end
 
-        assert parent.representable_attrs.first != child.representable_attrs.first, "definitions shouldn't be identical"
+        assert parent.representable_attrs.first.object_id != child.representable_attrs.first.object_id, "definitions shouldn't be identical"
       end
     end
   end
@@ -138,7 +138,7 @@ class RepresentableTest < MiniTest::Spec
     it "allows extending with different representers subsequentially" do
       module SongXmlRepresenter
         include Representable::XML
-        property :name, :from => "name", :attribute => true
+        property :name, :as => "name", :attribute => true
       end
 
       module SongJsonRepresenter
@@ -154,51 +154,10 @@ class RepresentableTest < MiniTest::Spec
 
 
   describe "#property" do
-    describe "overriding" do
-      representer! do
-        property :title, :as => :name
-      end
-
-      it { representer.representable_attrs.size.must_equal 1 }
-      it { representer.representable_attrs[:title].options.must_equal({:as => :name}) }
-
-      it "overrides property when called again" do
-        representer.class_eval do
-          property :title, :representable => true
-        end
-
-        representer.representable_attrs.size.must_equal 1
-        representer.representable_attrs[:title].options.must_equal({:representable => true})
-      end
-
-      it "overrides when inheriting same property" do
-        overriding = representer! { property :title, :representable => true }
-
-        representer.class_eval do
-          include overriding
-        end
-
-        representer.representable_attrs.size.must_equal 1
-        representer.representable_attrs[:title].options.must_equal({:representable => true})
-      end
-    end
-
-    describe ":from" do
-      # TODO: do this with all options.
-      it "can be set explicitly" do
-        band = Class.new(Band) { property :friends, :from => :friend }
-        assert_equal "friend", band.representable_attrs[:friends].from
-      end
-
-      it "can be set explicitly with as" do
-        band = Class.new(Band) { property :friends, :as => :friend }
-        assert_equal "friend", band.representable_attrs[:friends].from
-      end
-
-      it "is infered from the name implicitly" do
-        band = Class.new(Band) { property :friends }
-        assert_equal "friends", band.representable_attrs[:friends].from
-      end
+    it "doesn't modify options hash" do
+      options = {}
+      representer.property(:title, options)
+      options.must_equal({})
     end
 
     representer! {}
@@ -226,35 +185,6 @@ class RepresentableTest < MiniTest::Spec
   end
 
 
-  describe "#representation_wrap" do
-    class HardcoreBand
-      include Representable
-    end
-
-    class SoftcoreBand < HardcoreBand
-    end
-
-    before do
-      @band = HardcoreBand.new
-    end
-
-
-    it "returns false per default" do
-      assert_equal nil, SoftcoreBand.new.send(:representation_wrap)
-    end
-
-    it "infers a printable class name if set to true" do
-      HardcoreBand.representation_wrap = true
-      assert_equal "hardcore_band", @band.send(:representation_wrap)
-    end
-
-    it "can be set explicitely" do
-      HardcoreBand.representation_wrap = "breach"
-      assert_equal "breach", @band.send(:representation_wrap)
-    end
-  end
-
-
   describe "#definition_class" do
     it "returns Definition class" do
       assert_equal Representable::Definition, Band.send(:definition_class)
@@ -457,125 +387,6 @@ class RepresentableTest < MiniTest::Spec
     end
   end
 
-  describe ":if" do
-    before do
-      @pop = Class.new(PopBand) { attr_accessor :fame }
-    end
-
-    it "respects property when condition true" do
-      @pop.class_eval { property :fame, :if => lambda { true } }
-      band = @pop.new
-      band.from_hash({"fame"=>"oh yes"})
-      assert_equal "oh yes", band.fame
-    end
-
-    it "ignores property when condition false" do
-      @pop.class_eval { property :fame, :if => lambda { false } }
-      band = @pop.new
-      band.from_hash({"fame"=>"oh yes"})
-      assert_equal nil, band.fame
-    end
-
-    it "ignores property when :exclude'ed even when condition is true" do
-      @pop.class_eval { property :fame, :if => lambda { true } }
-      band = @pop.new
-      band.from_hash({"fame"=>"oh yes"}, {:exclude => [:fame]})
-      assert_equal nil, band.fame
-    end
-
-    it "executes block in instance context" do
-      @pop.class_eval { property :fame, :if => lambda { groupies } }
-      band = @pop.new
-      band.groupies = true
-      band.from_hash({"fame"=>"oh yes"})
-      assert_equal "oh yes", band.fame
-    end
-
-    describe "executing :if lambda in represented instance context" do
-      representer! do
-        property :label, :if => lambda { signed_contract }
-      end
-
-      subject { OpenStruct.new(:signed_contract => false, :label => "Fat") }
-
-      it "skips when false" do
-        subject.extend(representer).to_hash.must_equal({})
-      end
-
-      it "represents when true" do
-        subject.signed_contract= true
-        subject.extend(representer).to_hash.must_equal({"label"=>"Fat"})
-      end
-
-      it "works with decorator" do
-        rpr = representer
-        Class.new(Representable::Decorator) do
-          include rpr
-        end.new(subject).to_hash.must_equal({})
-      end
-    end
-
-
-    describe "propagating user options to the block" do
-      representer! do
-        property :name, :if => lambda { |opts| opts[:include_name] }
-      end
-      subject { OpenStruct.new(:name => "Outbound").extend(representer) }
-
-      it "works without specifying options" do
-        subject.to_hash.must_equal({})
-      end
-
-      it "passes user options to block" do
-        subject.to_hash(:include_name => true).must_equal({"name" => "Outbound"})
-      end
-    end
-  end
-
-  describe ":getter and :setter" do
-    representer! do
-      property :name, # key under :name.
-        :getter => lambda { |args| "#{args[:welcome]} #{song_name}" },
-        :setter => lambda { |val, args| self.song_name = "#{args[:welcome]} #{val}" }
-    end
-
-    subject { OpenStruct.new(:song_name => "Mony Mony").extend(representer) }
-
-    it "uses :getter when rendering" do
-      subject.instance_eval { def name; raise; end }
-      subject.to_hash(:welcome => "Hi").must_equal({"name" => "Hi Mony Mony"})
-    end
-
-    it "does not call original reader when rendering" do
-      subject.instance_eval { def name; raise; end; self }.to_hash
-    end
-
-    it "uses :setter when parsing" do
-      subject.from_hash({"name" => "Eyes Without A Face"}, :welcome => "Hello").song_name.must_equal "Hello Eyes Without A Face"
-    end
-
-    it "does not call original writer when parsing" do
-      subject.instance_eval { def name=(*); raise; end; self }.from_hash({"name"=>"Dana D And Talle T"})
-    end
-  end
-
-  describe ":reader and :writer" do
-    representer! do
-      property :name,
-        :writer => lambda { |doc, args| doc["title"] = "#{args[:nr]}) #{name}" },
-        :reader => lambda { |doc, args| self.name = doc["title"].split(") ").last }
-    end
-
-    subject { OpenStruct.new(:name => "Disorder And Disarray").extend(representer) }
-
-    it "uses :writer when rendering" do
-      subject.to_hash(:nr => 14).must_equal({"title" => "14) Disorder And Disarray"})
-    end
-
-    it "uses :reader when parsing" do
-      subject.from_hash({"title" => "15) The Wars End"}).name.must_equal "The Wars End"
-    end
-  end
 
   describe ":extend and :class" do
     module UpcaseRepresenter
@@ -642,26 +453,14 @@ class RepresentableTest < MiniTest::Spec
         end
 
         it "creates instance from :class lambda when parsing" do
-          song = Song.new.extend(representer).from_hash({"name" => "Quitters Never Win"})
+          song = OpenStruct.new.extend(representer).from_hash({"name" => "Quitters Never Win"})
           song.name.must_be_kind_of UpcaseString
           song.name.must_equal "QUITTERS NEVER WIN"
 
-          song = Song.new.extend(representer).from_hash({"name" => "Still Failing?"})
+          song = OpenStruct.new.extend(representer).from_hash({"name" => "Still Failing?"})
           song.name.must_be_kind_of String
           song.name.must_equal "still failing?"
         end
-
-        describe "when :class lambda returns nil" do
-          representer! do
-            property :name, :extend => lambda { |*| Module.new { include Representable; def from_hash(data, *args); data; end } },
-                            :class  => nil
-          end
-
-          it "skips creating new instance" do
-            song = Song.new.extend(representer).from_hash({"name" => string = "Satellite"})
-            song.name.object_id.must_equal string.object_id
-          end
-        end
       end
     end
 
@@ -718,62 +517,6 @@ class RepresentableTest < MiniTest::Spec
       end
     end
 
-    describe ":decorator_scope" do
-      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
-
-      describe "with decorator" do
-        it "executes lambdas in representer context" do
-          rpr = representer
-          Class.new(Representable::Decorator) do
-            include rpr
-
-            def title_from_representer
-              "Sounds Of Silence"
-            end
-          end.new(Object.new).to_hash.must_equal({"title"=>"Sounds Of Silence"})
-        end
-
-        it "executes method in representer context" do
-          rpr = representer_with_method
-          Class.new(Representable::Decorator) do
-            include rpr # mixes in #title.
-          end.new(Object.new).to_hash.must_equal({"title"=>"Crystal Planet"})
-        end
-
-        it "still allows accessing the represented object" do
-          Class.new(Representable::Decorator) do
-            include Representable::Hash
-            property :title, :getter => lambda { |*| represented.title }, :decorator_scope => true
-
-            def title
-              "Sounds Of Silence"
-            end
-          end.new(OpenStruct.new(:title => "Secret")).to_hash.must_equal({"title"=>"Secret"})
-        end
-      end
-    end
 
     # TODO: Move to global place since it's used twice.
     class SongRepresentation < Representable::Decorator
@@ -807,4 +550,21 @@ class RepresentableTest < MiniTest::Spec
       end
     end
   end
+
+
+  describe "#use_decorator" do
+    representer! do
+      property :title, :use_decorator => true do
+        property :lower
+      end
+    end
+
+    it "uses a Decorator for inline representer" do
+      outer = Struct.new(:title, :lower, :band, :bla).new(inner = Struct.new(:lower).new("paper wings"))
+
+      outer.extend(representer).to_hash.must_equal({"title"=>{"lower"=>"paper wings"}})
+      outer.must_be_kind_of Representable::Hash
+      inner.wont_be_kind_of Representable::Hash
+    end
+  end
 end

data/test/stringify_hash_test.rb

@@ -0,0 +1,41 @@
+require 'test_helper'
+
+class StringifyHashTest < MiniTest::Spec
+describe "#from_hash" do
+  representer!(:name => :song_representer) do
+
+    include Representable::Hash
+    include Representable::Hash::AllowSymbols
+
+    property :title
+  end
+
+  representer!(:inject => :song_representer) do
+    include Representable::Hash::AllowSymbols
+
+    property :song, :extend => song_representer, :class => OpenStruct
+   end
+
+   it "parses symbols, too" do
+     OpenStruct.new.extend(representer).from_hash({:song => {:title => "Der Optimist"}}).song.title.must_equal "Der Optimist"
+   end
+
+   it "still parses strings" do
+     OpenStruct.new.extend(representer).from_hash({"song" => {"title" => "Der Optimist"}}).song.title.must_equal "Der Optimist"
+   end
+
+   describe "with :wrap" do
+    representer!(:inject => :song_representer) do
+      include Representable::Hash::AllowSymbols
+
+      self.representation_wrap = :album
+      property :song, :extend => song_representer, :class => OpenStruct
+    end
+
+     it "parses symbols, too" do
+       OpenStruct.new.extend(representer).from_hash({:album => {:song => {:title => "Der Optimist"}}}).song.title.must_equal "Der Optimist"
+     end
+   end
+ end
+
+end