representable 2.4.1 → 3.0.0

data/test-with-deprecations/class_test.rb

@@ -1,119 +0,0 @@
-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
-
-
-  # this throws a DeserializationError now.
-  describe "lambda { nil }" do
-    representer! do
-      property :title, :class  => nil
-    end
-
-    it do
-      assert_raises Representable::DeserializeError do
-        OpenStruct.new.extend(representer).from_hash({"title" => {}})
-      end
-    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-with-deprecations/coercion_test.rb

@@ -1,52 +0,0 @@
-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

@@ -1,135 +0,0 @@
-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

@@ -1,122 +0,0 @@
-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

@@ -1,28 +0,0 @@
-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