representable 2.4.1 → 3.0.0

data/test-with-deprecations/decorator_test.rb

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

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

data/test-with-deprecations/defaults_options_test.rb

@@ -1,93 +0,0 @@
-require 'test_helper'
-
-class DefaultsOptionsTest < BaseTest
-  let (:format) { :hash }
-  let (:song) { Struct.new(:title, :author_name, :song_volume, :description).new("Revolution", "Some author", 20, nil) }
-  let (:prepared) { representer.prepare song }
-
-  describe "hash options combined with dynamic options" do
-    representer! do
-      defaults render_nil: true do |name|
-        { as: name.to_s.upcase }
-      end
-
-      property :title
-      property :author_name
-      property :description
-      property :song_volume
-    end
-
-    it { render(prepared).must_equal_document({"TITLE" => "Revolution", "AUTHOR_NAME" => "Some author", "DESCRIPTION" => nil, "SONG_VOLUME" => 20}) }
-  end
-
-  describe "with only dynamic property options" do
-    representer! do
-      defaults do |name|
-        { as: name.to_s.upcase }
-      end
-
-      property :title
-      property :author_name
-      property :description
-      property :song_volume
-    end
-
-    it { render(prepared).must_equal_document({"TITLE" => "Revolution", "AUTHOR_NAME" => "Some author", "SONG_VOLUME" => 20}) }
-  end
-
-  describe "with only hashes" do
-    representer! do
-      defaults render_nil: true
-
-      property :title
-      property :author_name
-      property :description
-      property :song_volume
-    end
-
-    it { render(prepared).must_equal_document({"title" => "Revolution", "author_name" => "Some author", "description" => nil, "song_volume" => 20}) }
-  end
-
-  describe "direct defaults hash" do
-    representer! do
-      defaults render_nil: true
-
-      property :title
-      property :author_name
-      property :description
-      property :song_volume
-    end
-
-    it { render(prepared).must_equal_document({"title" => "Revolution", "author_name" => "Some author", "description" => nil, "song_volume" => 20}) }
-  end
-
-  describe "direct defaults hash with dynamic options" do
-    representer! do
-      defaults render_nil: true do |name|
-        { as: name.to_s.upcase }
-      end
-
-      property :title
-      property :author_name
-      property :description
-      property :song_volume
-    end
-
-    it { render(prepared).must_equal_document({"TITLE" => "Revolution", "AUTHOR_NAME" => "Some author", "DESCRIPTION" => nil, "SONG_VOLUME" => 20}) }
-  end
-
-  describe "prioritizes specific options" do
-    representer! do
-      defaults render_nil: true do |name|
-        { as: name.to_s.upcase }
-      end
-
-      property :title
-      property :author_name
-      property :description, render_nil: false
-      property :song_volume, as: :volume
-    end
-
-    it { render(prepared).must_equal_document({"TITLE" => "Revolution", "AUTHOR_NAME" => "Some author", "volume" => 20}) }
-  end
-end

data/test-with-deprecations/definition_test.rb

@@ -1,264 +0,0 @@
-require 'test_helper'
-
-class DefinitionTest < MiniTest::Spec
-  Definition = Representable::Definition
-
-  # TODO: test that we DON'T clone options, that must happen in
-  describe "#initialize" do
-    it do
-      opts = nil
-
-      # new yields the defaultized options HASH.
-      definition = Definition.new(:song, :extend => Module) do |options|
-        options[:awesome] = true
-        options[:parse_filter] << 1
-
-        # default variables
-        options[:as].must_equal nil
-        options[:extend].must_equal Module
-      end
-      definition.name.must_equal "song"
-
-      #
-      definition[:awesome].must_equal true
-      definition[:parse_filter].must_equal Representable::Pipeline[1]
-      definition[:render_filter].must_equal Representable::Pipeline[]
-    end
-  end
-
-  describe "#[]" do
-    let (:definition) { Definition.new(:song) }
-    # default is nil.
-    it { definition[:bla].must_equal nil }
-  end
-
-  # merge!
-  describe "#merge!" do
-    let (:definition) { Definition.new(:song, :whatever => true) }
-
-    # merges new options.
-    it { definition.merge!(:something => true)[:something].must_equal true }
-    # doesn't override original options.
-    it { definition.merge!({:something => true})[:whatever].must_equal true }
-    # override original when passed in #merge!.
-    it { definition.merge!({:whatever => false})[:whatever].must_equal false }
-
-
-    it "runs macros" do
-      definition[:setter].must_equal nil
-      definition.merge!(:parse_strategy => :sync)
-      definition[:setter].must_respond_to :evaluate
-    end
-
-    # with block
-    it do
-      definition = Definition.new(:song, :extend => Module).merge!({:something => true}) do |options|
-        options[:awesome] = true
-        options[:render_filter] << 1
-
-        # default variables
-        # options[:as].must_equal "song"
-        # options[:extend].must_equal Module
-      end
-
-      definition[:awesome].must_equal true
-      definition[:something].must_equal true
-      definition[:render_filter].must_equal Representable::Pipeline[1]
-      definition[:parse_filter].must_equal Representable::Pipeline[]
-    end
-
-    describe "with :parse_filter" do
-      let (:definition) { Definition.new(:title, :parse_filter => 1) }
-
-      # merges :parse_filter and :render_filter.
-      it do
-        merged = definition.merge!(:parse_filter => 2)[:parse_filter]
-
-        merged.must_be_kind_of Representable::Pipeline
-        merged.size.must_equal 2
-      end
-
-      # :parse_filter can also be array.
-      it { definition.merge!(:parse_filter => [2, 3])[:parse_filter].size.must_equal 3 }
-    end
-
-    # does not change arguments
-    it do
-      Definition.new(:title).merge!(options = {:whatever => 1})
-      options.must_equal(:whatever => 1)
-    end
-  end
-
-
-  # delete!
-  describe "#delete!" do
-    let (:definition) { Definition.new(:song, serialize: "remove me!") }
-
-    before { definition[:serialize].evaluate(nil).must_equal "remove me!" }
-
-    it { definition.delete!(:serialize)[:serialize].must_equal nil }
-  end
-
-  # #inspect
-  describe "#inspect" do
-    it { Definition.new(:songs).inspect.must_equal "#<Representable::Definition ==>songs @options={:name=>\"songs\", :parse_filter=>[], :render_filter=>[]}>" }
-  end
-
-
-  describe "generic API" do
-    before do
-      @def = Representable::Definition.new(:songs)
-    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
-    end
-
-    describe "#typed?" do
-      it "is false per default" do
-        assert ! @def.typed?
-      end
-
-      it "is true when :class is present" do
-        assert Representable::Definition.new(:songs, :class => Hash).typed?
-      end
-
-      it "is true when :extend is present, only" do
-        assert Representable::Definition.new(:songs, :extend => Hash).typed?
-      end
-
-      it "is true when :instance is present, only" do
-        assert Representable::Definition.new(:songs, :instance => Object.new).typed?
-      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
-
-    it "responds to #name" do
-      assert_equal "songs", @def.name
-    end
-
-    it "responds to #setter" do
-      assert_equal :"songs=", @def.setter
-    end
-
-    describe "nested: FIXME" do
-      it do
-        dfn = Representable::Definition.new(:songs, nested: Module)
-        assert dfn.typed?
-        dfn[:extend].(nil).must_equal Module
-      end
-    end
-
-
-    describe "#clone" do
-      subject { Representable::Definition.new(:title, :volume => 9, :clonable => Uber::Options::Value.new(1)) }
-
-      it { subject.clone.must_be_kind_of Representable::Definition }
-      it { subject.clone[:clonable].evaluate(nil).must_equal 1 }
-
-      it "clones @options" do
-        @def.merge!(:volume => 9)
-
-        cloned = @def.clone
-        cloned.merge!(:volume => 8)
-
-        assert_equal @def[:volume], 9
-        assert_equal cloned[:volume], 8
-      end
-    end
-  end
-
-  describe "#has_default?" do
-    it "returns false if no :default set" do
-      assert_equal false, Representable::Definition.new(:song).has_default?
-    end
-
-    it "returns true if :default set" do
-      assert_equal true, Representable::Definition.new(:song, :default => nil).has_default?
-    end
-  end
-
-
-  describe "#binding" do
-    it "returns true when :binding is set" do
-      assert Representable::Definition.new(:songs, :binding => Object)[:binding]
-    end
-
-    it "returns false when :binding is not set" do
-      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.must_equal @binding
-    end
-  end
-
-  describe ":collection => true" do
-    before do
-      @def = Representable::Definition.new(:songs, :collection => true, :tag => :song)
-    end
-
-    it "responds to #array?" do
-      assert @def.array?
-    end
-  end
-
-
-  describe ":default => value" do
-    it "responds to #default" do
-      @def = Representable::Definition.new(:song)
-      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[:default]
-    end
-  end
-
-  describe ":hash => true" do
-    before do
-      @def = Representable::Definition.new(:songs, :hash => true)
-    end
-
-    it "responds to #hash?" do
-      assert @def.hash?
-      assert ! Representable::Definition.new(:songs).hash?
-    end
-  end
-
-  describe ":binding => Object" do
-    subject do
-      Representable::Definition.new(:songs, :binding => Object)
-    end
-
-    it "responds to #binding" do
-      assert_equal subject[:binding], Object
-    end
-  end
-
-  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