representable 2.4.1 → 3.0.0

data/lib/representable/parse_strategies.rb

@@ -1,93 +0,0 @@
-module Representable
-  class Populator
-    FindOrInstantiate = ->(input, options) {
-      binding = options[:binding]
-
-      object_class = binding[:class].(input, options)
-      object       = object_class.find_by(id: input["id"]) || object_class.new
-      if options[:binding].array?
-        # represented.songs[i] = model
-        options[:represented].send(binding.getter)[options[:index]] = object
-      else
-        # represented.song = model
-        options[:represented].send(binding.setter, object)
-      end
-
-      object
-     }
-
-    # pipeline: [StopOnExcluded, AssignName, ReadFragment, StopOnNotFound, OverwriteOnNil, AssignFragment, #<Representable::Function::CreateObject:0x9805a44>, #<Representable::Function::Decorate:0x9805a1c>, Deserialize, Set]
-
-    def self.apply!(options)
-      return unless populator = options[:populator]
-
-      options[:parse_pipeline] = ->(input, options) do
-        pipeline = Pipeline[*parse_functions] # TODO: AssignFragment
-        pipeline = Pipeline::Insert.(pipeline, SetValue, delete: true) # remove the setter function.
-        pipeline = Pipeline::Insert.(pipeline, populator, replace: CreateObject::Populator) # let the actual populator do the job.
-        # puts pipeline.extend(Representable::Pipeline::Debug).inspect
-        pipeline
-      end
-    end
-  end
-
-  FindOrInstantiate = Populator::FindOrInstantiate
-
-  # Parse strategies are just a combination of representable's options. They save you from memoizing the
-  # necessary parameters.
-  #
-  # Feel free to contribute your strategy if you think it's worth sharing!
-  class ParseStrategy
-    def self.apply!(options)
-      return unless strategy = options[:parse_strategy]
-
-      warn "[Representable] :parse_strategy is deprecated. Please use a populator."
-
-      strategy = :proc if strategy.is_a?(::Proc)
-
-      parse_strategies[strategy].apply!(name, options)
-    end
-
-    def self.parse_strategies
-      {
-        :sync                 => Sync,
-        :find_or_instantiate  => FindOrInstantiate,
-        :proc                 => Proc
-      }
-    end
-
-
-    # Using a lambda as parse_strategy does not set the parsed property for you.
-    class Proc
-      def self.apply!(name, options)
-        options[:setter]       = lambda { |*| }
-        options[:pass_options] = true
-        options[:instance]     = options[:parse_strategy]
-      end
-    end
-
-
-    class Sync
-      def self.apply!(name, options)
-        options[:setter]       = lambda { |*args| }
-        options[:pass_options] = true
-        options[:instance]     = options[:collection] ?
-          lambda { |options| options[:binding].get(options)[options[:index]] } :
-          lambda { |options| options[:binding].get(options) }
-      end
-    end
-
-
-    # replaces current collection.
-    class FindOrInstantiate
-      def self.apply!(name, options)
-        options[:pass_options] = true
-        options[:instance]     = lambda { |options|
-          object_class = options[:binding][:class].evaluate(self, options)
-
-          object_class.find_by({id: options[:fragment]["id"]}) or object_class.new
-        }
-      end
-    end
-  end
-end

data/test-with-deprecations/as_test.rb

@@ -1,65 +0,0 @@
-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
-
-
-# hash: to_hash(wrap: ) is representation_wrap
-
-class AsXmlTest < MiniTest::Spec
-  Band  = Struct.new(:name, :label)
-  Album = Struct.new(:band)
-  Label = Struct.new(:name)
-
-  representer!(module: Representable::XML, decorator: true) do
-    self.representation_wrap = :album
-    property :band, as: :combo do
-      self.representation_wrap = :band
-      property :name
-    end
-  end
-
-  it do
-    skip
-    representer.new(Album.new(Band.new("Offspring"))).to_xml.must_equal ""
-  end
-end

data/test-with-deprecations/benchmarking.rb

@@ -1,83 +0,0 @@
-require 'test_helper'
-require 'benchmark'
-
-SONG_PROPERTIES = 1000.times.collect do |i|
-  "property_#{i}"
-end
-
-
-module SongRepresenter
-  include Representable::JSON
-
-  SONG_PROPERTIES.each { |p| property p }
-end
-
-class SongDecorator < Representable::Decorator
-  include Representable::JSON
-
-  SONG_PROPERTIES.each { |p| property p }
-end
-
-module AlbumRepresenter
-  include Representable::JSON
-
-  # collection :songs, extend: SongRepresenter
-  collection :songs, extend: SongDecorator
-end
-
-def random_song
-  attrs = Hash[SONG_PROPERTIES.collect { |n| [n,n] }]
-  OpenStruct.new(attrs)
-end
-
-times = []
-
-3.times.each do
-  album = OpenStruct.new(songs: 100.times.collect { random_song })
-
-  times << Benchmark.measure do
-    puts "================ next!"
-    album.extend(AlbumRepresenter).to_json
-  end
-end
-
-puts times.join("")
-
-# 100 songs, 100 attrs
-#  0.050000   0.000000   0.050000 (  0.093157)
-
-## 100 songs, 1000 attrs
-#  0.470000   0.010000   0.480000 (  0.483708)
-
-
-### without binding cache:
-  # 2.790000   0.030000   2.820000 (  2.820190)
-
-
-
-### with extend: on Song, with binding cache>
-  # 2.490000   0.030000   2.520000 (  2.517433) 2.4-3.0
-  ### without skip?
-  # 2.030000   0.020000   2.050000 (  2.050796) 2.1-2.3
-
-    ### without :writer
-    # 2.270000   0.010000   2.280000 (  2.284530 1.9-2.2
-      ### without :render_filter
-      #   2.020000   0.000000   2.020000 (  2.030234) 1.5-2.0
-        ###without default_for and skipable?
-        #   1.730000   0.010000   1.740000 (  1.735597 1.4-1.7
-          ### without :serialize
-          #   1.780000   0.010000   1.790000 (  1.786791) 1.4-1.7
-          ### using decorator
-          # 1.400000   0.030000   1.430000 (  1.434206) 1.4-1.6
-            ### with prepare AFTER  representable?
-            # 1.330000   0.010000   1.340000 (  1.335900) 1.1-1.3
-
-
-# representable 2.0
-# 3.000000   0.020000   3.020000 (  3.013031) 2.7-3.0
-
-# no method missing
-# 2.280000   0.030000   2.310000 (  2.313522) 2.2-2.5
-# no def_delegator in Definition
-# 2.130000   0.010000   2.140000 (  2.136115) 1.7-2.1

data/test-with-deprecations/binding_test.rb

@@ -1,46 +0,0 @@
-require 'test_helper'
-
-class BindingTest < MiniTest::Spec
-  Binding = Representable::Binding
-  let (:render_nil_definition) { Representable::Definition.new(:song, :render_nil => true) }
-
-  describe "#skipable_empty_value?" do
-    let (:binding) { Binding.new(render_nil_definition) }
-
-    # don't skip when present.
-    it { binding.skipable_empty_value?("Disconnect, Disconnect").must_equal false }
-
-    # don't skip when it's nil and render_nil: true
-    it { binding.skipable_empty_value?(nil).must_equal false }
-
-    # skip when nil and :render_nil undefined.
-    it { Binding.new(Representable::Definition.new(:song)).skipable_empty_value?(nil).must_equal true }
-
-    # don't skip when nil and :render_nil undefined.
-    it { Binding.new(Representable::Definition.new(:song)).skipable_empty_value?("Fatal Flu").must_equal false }
-  end
-
-
-  describe "#default_for" do
-    let (:definition) { Representable::Definition.new(:song, :default => "Insider") }
-    let (:binding) { Binding.new(definition) }
-
-    # return value when value present.
-    it { binding.default_for("Black And Blue").must_equal "Black And Blue" }
-
-    # return false when value false.
-    it { binding.default_for(false).must_equal false }
-
-    # return default when value nil.
-    it { binding.default_for(nil).must_equal "Insider" }
-
-    # return nil when value nil and render_nil: true.
-    it { Binding.new(render_nil_definition).default_for(nil).must_equal nil }
-
-    # return nil when value nil and render_nil: true, even when :default is set" do
-    it { Binding.new(Representable::Definition.new(:song, :render_nil => true, :default => "The Quest")).default_for(nil).must_equal nil }
-
-    # return nil if no :default
-    it { Binding.new(Representable::Definition.new(:song)).default_for(nil).must_equal nil }
-  end
-end

data/test-with-deprecations/blaaaaaaaa_test.rb

@@ -1,69 +0,0 @@
-require 'test_helper'
-
-
-
-
-# Include Inherit Module And Decorator Test
-class SchemaTest < MiniTest::Spec
-  module Genre
-    include Representable
-    property :genre
-  end
-
-  module LinkFeature
-    def self.included(base)
-      base.extend(Link)
-    end
-
-    module Link
-      def link
-      end
-    end
-  end
-
-
-  module Module
-    include Representable::Hash
-    feature LinkFeature
-
-    property :title
-    property :label do # extend: LabelModule
-      property :name
-      link # feature
-
-      property :location do
-        property :city
-        link # feature.
-      end
-    end
-
-    property :album, :extend => lambda { raise "don't manifest me!" } # this is not an inline decorator, don't manifest it.
-
-
-    include Genre # Schema::Included::included is called!
-  end
-
-
-  class InheritDecorator < Representable::Decorator
-    include Representable::Hash
-
-    include Module
-
-    property :label, inherit: true do # decorator.rb:27:in `initialize': superclass must be a Class (Module given)
-      property :city
-
-      property :location, :inherit => true do
-        property :city
-      end
-    end
-  end
-
-
-  class InheritFromDecorator < InheritDecorator
-    property :label, inherit: true do
-      collection :employees do
-        property :name
-      end
-    end
-  end
-end

data/test-with-deprecations/cached_test.rb

@@ -1,147 +0,0 @@
-require "test_helper"
-require 'ruby-prof'
-
-class CachedTest < MiniTest::Spec
-  # TODO: also test with feature(Cached)
-
-  module Model
-    Song  = Struct.new(:title, :composer)
-    Album = Struct.new(:name, :songs, :artist)
-    Artist = Struct.new(:name, :hidden_taste)
-  end
-
-  class SongRepresenter < Representable::Decorator
-    include Representable::Hash
-    feature Representable::Cached
-
-    property :title, render_filter: lambda { |input, options| "#{input}:#{options[:options][:user_options]}" }
-    property :composer, class: Model::Artist do
-      property :name
-    end
-  end
-
-  class AlbumRepresenter < Representable::Decorator
-    include Representable::Hash
-    include Representable::Cached
-
-    property :name
-    collection :songs, decorator: SongRepresenter, class: Model::Song
-  end
-
-
-  describe "serialization" do
-    let (:album_hash) { {"name"=>"Louder And Even More Dangerous", "songs"=>[{"title"=>"Southbound:{:volume=>10}"}, {"title"=>"Jailbreak:{:volume=>10}"}]} }
-
-    let (:song) { Model::Song.new("Jailbreak") }
-    let (:song2) { Model::Song.new("Southbound") }
-    let (:album) { Model::Album.new("Live And Dangerous", [song, song2, Model::Song.new("Emerald")]) }
-    let (:representer) { AlbumRepresenter.new(album) }
-
-    it do
-      album2 = Model::Album.new("Louder And Even More Dangerous", [song2, song])
-
-      # makes sure options are passed correctly.
-      representer.to_hash(volume: 9).must_equal({"name"=>"Live And Dangerous",
-        "songs"=>[{"title"=>"Jailbreak:{:volume=>9}"}, {"title"=>"Southbound:{:volume=>9}"}, {"title"=>"Emerald:{:volume=>9}"}]}) # called in Deserializer/Serializer
-
-      # representer becomes reusable as it is stateless.
-      # representer.update!(album2)
-
-      # makes sure options are passed correctly.
-      # representer.to_hash(volume:10).must_equal(album_hash)
-    end
-
-    # profiling
-    it do
-      representer.to_hash
-
-     RubyProf.start
-        representer.to_hash
-      res = RubyProf.stop
-
-      printer = RubyProf::FlatPrinter.new(res)
-
-      data = StringIO.new
-      printer.print(data)
-      data = data.string
-
-      printer.print(STDOUT)
-
-      # 3 songs get decorated.
-      data.must_match "3   Representable::Function::Decorate#call"
-      # 3 nested decorator is instantiated for 3 Songs, though.
-      data.must_match "3   <Class::Representable::Decorator>#prepare"
-      # no Binding is instantiated at runtime.
-      data.wont_match "Representable::Binding#initialize"
-      # 2 mappers for Album, Song
-      # data.must_match "2   Representable::Mapper::Methods#initialize"
-      # title, songs, 3x title, composer
-      data.must_match "8   Representable::Binding#render_pipeline"
-      data.wont_match "render_functions"
-      data.wont_match "Representable::Binding::Factories#render_functions"
-    end
-  end
-
-
-  describe "deserialization" do
-    let (:album_hash) {
-      {
-        "name"=>"Louder And Even More Dangerous",
-        "songs"=>[
-          {"title"=>"Southbound", "composer"=>{"name"=>"Lynott"}},
-          {"title"=>"Jailbreak", "composer"=>{"name"=>"Phil Lynott"}},
-          {"title"=>"Emerald"}
-        ]
-      }
-    }
-
-    it do
-      album = Model::Album.new
-
-      AlbumRepresenter.new(album).from_hash(album_hash)
-
-      album.songs.size.must_equal 3
-      album.name.must_equal "Louder And Even More Dangerous"
-      album.songs[0].title.must_equal "Southbound"
-      album.songs[0].composer.name.must_equal "Lynott"
-      album.songs[1].title.must_equal "Jailbreak"
-      album.songs[1].composer.name.must_equal "Phil Lynott"
-      album.songs[2].title.must_equal "Emerald"
-      album.songs[2].composer.must_equal nil
-
-      # TODO: test options.
-    end
-
-    it "xxx" do
-      representer = AlbumRepresenter.new(Model::Album.new)
-      representer.from_hash(album_hash)
-
-      RubyProf.start
-        # puts "#{representer.class.representable_attrs.get(:songs).representer_module.representable_attrs.inspect}"
-        representer.from_hash(album_hash)
-      res = RubyProf.stop
-
-      printer = RubyProf::FlatPrinter.new(res)
-
-      data = StringIO.new
-      printer.print(data)
-      data = data.string
-
-      # only 2 nested decorators are instantiated, Song, and Artist.
-      data.must_match "5   <Class::Representable::Decorator>#prepare"
-      # a total of 5 properties in the object graph.
-      data.wont_match "Representable::Binding#initialize"
-
-
-      data.wont_match "parse_functions" # no pipeline creation.
-      data.must_match "10   Representable::Binding#parse_pipeline"
-      # three mappers for Album, Song, composer
-      # data.must_match "3   Representable::Mapper::Methods#initialize"
-      # # 6 deserializers as the songs collection uses 2.
-      # data.must_match "6   Representable::Deserializer#initialize"
-      # # one populater for every property.
-      # data.must_match "5   Representable::Populator#initialize"
-      # printer.print(STDOUT)
-    end
-  end
-end