representable 2.4.0.rc3 → 2.4.0.rc4

data/test-with-deprecations/coercion_test.rb

@@ -0,0 +1,52 @@
+require 'test_helper'
+require 'representable/coercion'
+
+class VirtusCoercionTest < MiniTest::Spec
+  representer! do
+    include Representable::Coercion
+
+    property :title # no coercion.
+    property :length, :type => Float
+
+    property :band, :class => OpenStruct do
+      property :founded, :type => Integer
+    end
+
+    collection :songs, :class => OpenStruct do
+      property :ok, :type => Virtus::Attribute::Boolean
+    end
+  end
+
+  let (:album) { OpenStruct.new(:title => "Dire Straits", :length => 41.34,
+    :band  => OpenStruct.new(:founded => "1977"),
+    :songs => [OpenStruct.new(:ok => 1), OpenStruct.new(:ok => 0)]) }
+
+  it { album.extend(representer).to_hash.must_equal({"title"=>"Dire Straits", "length"=>41.34, "band"=>{"founded"=>1977}, "songs"=>[{"ok"=>true}, {"ok"=>false}]}) }
+
+  it {
+    album = OpenStruct.new
+    album.extend(representer)
+    album.from_hash({"title"=>"Dire Straits", "length"=>"41.34", "band"=>{"founded"=>"1977"}, "songs"=>[{"ok"=>1}, {"ok"=>0}]})
+
+    # it
+    album.length.must_equal 41.34
+    album.band.founded.must_equal 1977
+    album.songs[0].ok.must_equal true
+  }
+
+
+  describe "with user :parse_filter and :render_filter" do
+    representer! do
+      include Representable::Coercion
+
+      property :length, :type => Float,
+      :parse_filter  => lambda { |input, options| "#{input}.1" }, # happens BEFORE coercer.
+      :render_filter => lambda { |fragment,*| "#{fragment}.1" }
+    end
+
+    # user's :parse_filter(s) are run before coercion.
+    it { OpenStruct.new.extend(representer).from_hash("length"=>"1").length.must_equal 1.1 }
+    # user's :render_filter(s) are run before coercion.
+    it { OpenStruct.new(:length=>1).extend(representer).to_hash.must_equal({"length" => 1.1}) }
+  end
+end

data/test-with-deprecations/config/inherit_test.rb

@@ -0,0 +1,135 @@
+require 'test_helper'
+
+# tests defining representers in modules, decorators and classes and the inheritance when combined.
+
+class ConfigInheritTest < MiniTest::Spec
+  def assert_cloned(child, parent, property)
+    child_def  = child.representable_attrs.get(property)
+    parent_def = parent.representable_attrs.get(property)
+
+    child_def.merge!(:alias => property)
+
+    child_def[:alias].wont_equal parent_def[:alias]
+    child_def.object_id.wont_equal parent_def.object_id
+  end
+  # class Object
+
+  # end
+  module GenreModule
+    include Representable::Hash
+    property :genre
+  end
+
+
+  # in Decorator ------------------------------------------------
+  class Decorator < Representable::Decorator
+    include Representable::Hash
+    property :title
+    property :artist do
+      property :id
+    end
+  end
+
+  it { Decorator.definitions.keys.must_equal ["title", "artist"] }
+
+  # in inheriting Decorator
+
+  class InheritingDecorator < Decorator
+    property :location
+  end
+
+  it { InheritingDecorator.definitions.keys.must_equal ["title", "artist", "location"] }
+  it { assert_cloned(InheritingDecorator, Decorator, "title") }
+  it do
+    InheritingDecorator.representable_attrs.get(:artist).representer_module.object_id.wont_equal Decorator.representable_attrs.get(:artist).representer_module.object_id
+  end
+
+  # in inheriting and including Decorator
+
+  class InheritingAndIncludingDecorator < Decorator
+    include GenreModule
+    property :location
+  end
+
+  it { InheritingAndIncludingDecorator.definitions.keys.must_equal ["title", "artist", "genre", "location"] }
+  it { assert_cloned(InheritingAndIncludingDecorator, GenreModule, :genre) }
+
+
+  # in module ---------------------------------------------------
+  module Module
+    include Representable
+    property :title
+  end
+
+  it { Module.definitions.keys.must_equal ["title"] }
+
+
+  # in module including module
+  module SubModule
+    include Representable
+    include Module
+
+    property :location
+  end
+
+  it { SubModule.definitions.keys.must_equal ["title", "location"] }
+  it { assert_cloned(SubModule, Module, :title) }
+
+  # including preserves order
+  module IncludingModule
+    include Representable
+    property :genre
+    include Module
+
+    property :location
+  end
+
+  it { IncludingModule.definitions.keys.must_equal ["genre", "title", "location"] }
+
+
+  # included in class -------------------------------------------
+  class Class
+    include Representable
+    include IncludingModule
+  end
+
+  it { Class.definitions.keys.must_equal ["genre", "title", "location"] }
+  it { assert_cloned(Class, IncludingModule, :title) }
+  it { assert_cloned(Class, IncludingModule, :location) }
+  it { assert_cloned(Class, IncludingModule, :genre) }
+
+  # included in class with order
+  class DefiningClass
+    include Representable
+    property :street_cred
+    include IncludingModule
+  end
+
+  it { DefiningClass.definitions.keys.must_equal ["street_cred", "genre", "title", "location"] }
+
+  # in class
+  class RepresenterClass
+    include Representable
+    property :title
+  end
+
+  it { RepresenterClass.definitions.keys.must_equal ["title"] }
+
+
+  # in inheriting class
+  class InheritingClass < RepresenterClass
+    include Representable
+    property :location
+  end
+
+  it { InheritingClass.definitions.keys.must_equal ["title", "location"] }
+  it { assert_cloned(InheritingClass, RepresenterClass, :title) }
+
+  # in inheriting class and including
+  class InheritingAndIncludingClass < RepresenterClass
+    property :location
+    include GenreModule
+  end
+
+  it { InheritingAndIncludingClass.definitions.keys.must_equal ["title", "location", "genre"] }
+end

data/test-with-deprecations/config_test.rb

@@ -0,0 +1,122 @@
+require 'test_helper'
+
+class ConfigTest < MiniTest::Spec
+  subject { Representable::Config.new(Representable::Definition) }
+  PunkRock = Class.new
+  Definition = Representable::Definition
+
+  describe "wrapping" do
+    it "returns false per default" do
+      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, nil)
+    # end
+
+    # it "can be set explicitely" do
+    #   subject.wrap = "Descendents"
+    #   assert_equal "Descendents", subject.wrap_for(PunkRock, nil)
+    # end
+  end
+
+  describe "#[]" do
+    # does return nil for non-existent
+    it { subject[:hello].must_equal nil }
+  end
+
+  # describe "#[]" do
+  #   before { subject.add(:title, {:me => true}) }
+
+  #   it { subject[:unknown].must_equal     nil }
+  #   it { subject.get(:title)[:me].must_equal  true }
+  #   it { subject["title"][:me].must_equal true }
+  # end
+
+  # []=
+  # []=(... inherit: true)
+  # forwarded to Config#definitions
+  # that goes to ConfigDefinitionsTest
+  describe "#add" do
+    describe "returns" do
+      it do
+        # #add returns Definition.`
+        subject = Representable::Config.new(Representable::Definition).add(:title, {:me => true})
+
+        subject.must_be_kind_of Representable::Definition
+        subject[:me].must_equal true
+      end
+    end
+
+    before { subject.add(:title, {:me => true}) }
+
+    # must be kind of Definition
+    it { subject.size.must_equal 1 }
+    it { subject.get(:title).name.must_equal "title" }
+    it { subject.get(:title)[:me].must_equal true }
+
+    # this is actually tested in context in inherit_test.
+    it "overrides former definition" do
+      subject.add(:title, {:peer => Module})
+      subject.get(:title)[:me].must_equal nil
+      subject.get(:title)[:peer].must_equal Module
+    end
+
+    describe "inherit: true" do
+      before {
+        subject.add(:title, {:me => true})
+        subject.add(:title, {:peer => Module, :inherit => true})
+      }
+
+      it { subject.get(:title)[:me].must_equal true }
+      it { subject.get(:title)[:peer].must_equal Module }
+    end
+  end
+
+
+  describe "#remove" do
+    subject { Representable::Config.new(Representable::Definition) }
+
+    it do
+      subject.add(:title, {:me => true})
+      subject.add(:genre, {})
+      subject.get(:genre).must_be_kind_of Representable::Definition
+
+      subject.remove(:genre)
+      subject.get(:genre).must_equal nil
+    end
+  end
+
+
+  describe "#each" do
+    before { subject.add(:title, {:me => true}) }
+
+    it "what" do
+      definitions = []
+      subject.each { |dfn| definitions << dfn }
+      definitions.size.must_equal 1
+      definitions[0][:me].must_equal true
+    end
+  end
+
+  describe "#options" do
+    it { subject.options.must_equal({}) }
+    it do
+      subject.options[:namespacing] = true
+      subject.options[:namespacing].must_equal true
+    end
+  end
+
+  describe "#get" do
+    subject       { Representable::Config.new(Representable::Definition) }
+
+    it do
+      title  = subject.add(:title, {})
+      length = subject.add(:length, {})
+
+      subject.get(:title).must_equal title
+      subject.get(:length).must_equal length
+    end
+  end
+end

data/test-with-deprecations/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-with-deprecations/decorator_test.rb

@@ -0,0 +1,96 @@
+require 'test_helper'
+
+class DecoratorTest < MiniTest::Spec
+  class SongRepresentation < Representable::Decorator
+    include Representable::JSON
+    property :name
+  end
+
+  class AlbumRepresentation < Representable::Decorator
+    include Representable::JSON
+
+    collection :songs, :class => Song, :extend => SongRepresentation
+  end
+
+  let (:song) { Song.new("Mama, I'm Coming Home") }
+  let (:album) { Album.new([song]) }
+
+  describe "inheritance" do
+    let (:inherited_decorator) do
+      Class.new(AlbumRepresentation) do
+        property :best_song
+      end.new(Album.new([song], "Stand Up"))
+    end
+
+    it { inherited_decorator.to_hash.must_equal({"songs"=>[{"name"=>"Mama, I'm Coming Home"}], "best_song"=>"Stand Up"}) }
+  end
+
+  let (:decorator) { AlbumRepresentation.new(album) }
+
+  it "renders" do
+    decorator.to_hash.must_equal({"songs"=>[{"name"=>"Mama, I'm Coming Home"}]})
+    album.wont_respond_to :to_hash
+    song.wont_respond_to :to_hash # DISCUSS: weak test, how to assert blank slate?
+    # no @representable_attrs in decorated objects
+    song.instance_variable_get(:@representable_attrs).must_equal nil
+  end
+
+  describe "#from_hash" do
+    it "returns represented" do
+      decorator.from_hash({"songs"=>[{"name"=>"Mama, I'm Coming Home"}]}).must_equal album
+    end
+
+    it "parses" do
+      decorator.from_hash({"songs"=>[{"name"=>"Atomic Garden"}]})
+      album.songs.first.must_be_kind_of Song
+      album.songs.must_equal [Song.new("Atomic Garden")]
+      album.wont_respond_to :to_hash
+      song.wont_respond_to :to_hash # DISCUSS: weak test, how to assert blank slate?
+    end
+  end
+
+  describe "#decorated" do
+    it "is aliased to #represented" do
+      AlbumRepresentation.prepare(album).decorated.must_equal album
+    end
+  end
+
+
+  describe "inline decorators" do
+    representer!(decorator: true) do
+      collection :songs, :class => Song do
+        property :name
+      end
+    end
+
+    it "does not pollute represented" do
+      representer.new(album).from_hash({"songs"=>[{"name"=>"Atomic Garden"}]})
+
+      # no @representable_attrs in decorated objects
+      song.instance_variable_get(:@representable_attrs).must_equal nil
+      album.instance_variable_get(:@representable_attrs).must_equal nil
+    end
+  end
+end
+
+require "uber/inheritable_attr"
+class InheritanceWithDecoratorTest < MiniTest::Spec
+  class Twin
+    extend Uber::InheritableAttr
+    inheritable_attr :representer_class
+    self.representer_class = Class.new(Representable::Decorator){ include Representable::Hash }
+  end
+
+  class Album < Twin
+    representer_class.property :title # Twin.representer_class.clone
+  end
+
+  class Song < Twin # Twin.representer_class.clone
+  end
+
+  it do
+    Twin.representer_class.definitions.size.must_equal 0
+    Album.representer_class.definitions.size.must_equal 1
+    Song.representer_class.definitions.size.must_equal 0
+  end
+end

data/test-with-deprecations/default_test.rb

@@ -0,0 +1,34 @@
+require "test_helper"
+
+class DefaultTest < MiniTest::Spec
+  Song = Struct.new(:id, :title)
+
+  representer! do
+    property :id
+    property :title, default: "Huber Breeze" #->(options) { options[:default] }
+  end
+
+  describe "#from_hash" do
+    let (:song) { Song.new.extend(representer) }
+
+    it { song.from_hash({}).must_equal Song.new(nil, "Huber Breeze") }
+    # default doesn't apply when empty string.
+    it { song.from_hash({"title"=>""}).must_equal Song.new(nil, "") }
+    it { song.from_hash({"title"=>nil}).must_equal Song.new(nil, nil) }
+    it { song.from_hash({"title"=>"Blindfold"}).must_equal Song.new(nil, "Blindfold") }
+  end
+
+  describe "#to_json" do
+    it "uses :default when not available from object" do
+      Song.new.extend(representer).to_hash.must_equal({"title"=>"Huber Breeze"})
+    end
+
+    it "uses value from represented object when present" do
+      Song.new(nil, "After The War").extend(representer).to_hash.must_equal({"title"=>"After The War"})
+    end
+
+    it "uses value from represented object when emtpy string" do
+      Song.new(nil, "").extend(representer).to_hash.must_equal({"title"=>""})
+    end
+  end
+end