representable 2.4.1 → 3.0.0

data/test-with-deprecations/yaml_test.rb

@@ -1,162 +0,0 @@
-require 'test_helper'
-
-class YamlTest < MiniTest::Spec
-  def self.yaml_representer(&block)
-    Module.new do
-      include Representable::YAML
-      instance_exec &block
-    end
-  end
-
-  def yaml_representer(&block)
-    self.class.yaml_representer(&block)
-  end
-
-
-  describe "property" do
-    let (:yaml) { yaml_representer do property :best_song end }
-
-    let (:album) { Album.new.tap do |album|
-      album.best_song = "Liar"
-    end }
-
-    describe "#to_yaml" do
-      it "renders plain property" do
-        album.extend(yaml).to_yaml.must_equal(
-"---
-best_song: Liar
-")
-      end
-
-      it "always renders values into strings" do
-        Album.new.tap { |a| a.best_song = 8675309 }.extend(yaml).to_yaml.must_equal(
-"---
-best_song: 8675309
-"
-)
-      end
-    end
-
-
-    describe "#from_yaml" do
-      it "parses plain property" do
-        album.extend(yaml).from_yaml(
-"---
-best_song: This Song Is Recycled
-").best_song.must_equal "This Song Is Recycled"
-      end
-    end
-
-
-    describe "with :class and :extend" do
-      yaml_song = yaml_representer do property :name end
-      let (:yaml_album) { Module.new do
-        include Representable::YAML
-        property :best_song, :extend => yaml_song, :class => Song
-      end }
-
-      let (:album) { Album.new.tap do |album|
-        album.best_song = Song.new("Liar")
-      end }
-
-
-      describe "#to_yaml" do
-        it "renders embedded typed property" do
-          album.extend(yaml_album).to_yaml.must_equal "---
-best_song:
-  name: Liar
-"
-        end
-      end
-
-      describe "#from_yaml" do
-        it "parses embedded typed property" do
-          album.extend(yaml_album).from_yaml("---
-best_song:
-  name: Go With Me
-").must_equal Album.new(nil,Song.new("Go With Me"))
-        end
-      end
-    end
-  end
-
-
-  describe "collection" do
-    let (:yaml) { yaml_representer do collection :songs end }
-
-    let (:album) { Album.new.tap do |album|
-      album.songs = ["Jackhammer", "Terrible Man"]
-    end }
-
-
-    describe "#to_yaml" do
-      it "renders a block style list per default" do
-        album.extend(yaml).to_yaml.must_equal "---
-songs:
-- Jackhammer
-- Terrible Man
-"
-      end
-
-      it "renders a flow style list when :style => :flow set" do
-        yaml = yaml_representer { collection :songs, :style => :flow }
-        album.extend(yaml).to_yaml.must_equal "---
-songs: [Jackhammer, Terrible Man]
-"
-      end
-    end
-
-
-    describe "#from_yaml" do
-      it "parses a block style list" do
-        album.extend(yaml).from_yaml("---
-songs:
-- Off Key Melody
-- Sinking").must_equal Album.new(["Off Key Melody", "Sinking"])
-
-      end
-
-      it "parses a flow style list" do
-        album.extend(yaml).from_yaml("---
-songs: [Off Key Melody, Sinking]").must_equal Album.new(["Off Key Melody", "Sinking"])
-      end
-    end
-
-
-    describe "with :class and :extend" do
-      let (:yaml_album) { Module.new do
-        include Representable::YAML
-        collection :songs, :class => Song do
-          property :name
-          property :track
-        end
-      end }
-
-      let (:album) { Album.new([Song.new("Liar", 1), Song.new("What I Know", 2)]) }
-
-
-      describe "#to_yaml" do
-        it "renders collection of typed property" do
-          album.extend(yaml_album).to_yaml.must_equal "---
-songs:
-- name: Liar
-  track: 1
-- name: What I Know
-  track: 2
-"
-        end
-      end
-
-      describe "#from_yaml" do
-        it "parses collection of typed property" do
-          album.extend(yaml_album).from_yaml("---
-songs:
-- name: One Shot Deal
-  track: 4
-- name: Three Way Dance
-  track: 5").must_equal Album.new([Song.new("One Shot Deal", 4), Song.new("Three Way Dance", 5)])
-        end
-      end
-    end
-  end
-end

data/test/parse_strategy_test.rb

@@ -1,279 +0,0 @@
-require 'test_helper'
-
-# parse_strategy: :sync
-# parse_strategy: :replace
-# parse_strategy: :find_or_instantiate ("expand" since we don't delete existing unmatched in target)
-
-
-class ParseStrategySyncTest < BaseTest
-  for_formats(
-    :hash => [Representable::Hash, {"song"=>{"title"=>"Resist Stance"}}, {"song"=>{"title"=>"Suffer"}}],
-    :xml  => [Representable::XML, "<open_struct><song><title>Resist Stance</title></song></open_struct>", "<open_struct><song><title>Suffer</title></song></open_struct>",],
-    :yaml => [Representable::YAML, "---\nsong:\n  title: Resist Stance\n", "---\nsong:\n  title: Suffer\n"],
-  ) do |format, mod, output, input|
-
-    describe "[#{format}] property with parse_strategy: :sync" do # TODO: introduce :representable option?
-      let (:format) { format }
-
-      representer!(:module => mod, :name => :song_representer) do
-        property :title
-        self.representation_wrap = :song if format == :xml
-      end
-
-      representer!(:inject => :song_representer, :module => mod) do
-        property :song, :parse_strategy => :sync, :extend => song_representer
-      end
-
-      let (:hit) { hit = OpenStruct.new(:song => song).extend(representer) }
-
-      it "calls #to_hash on song instance, nothing else" do
-        render(hit).must_equal_document(output)
-      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
-  end
-
-  # FIXME: there's a bug with XML and the collection name!
-  for_formats(
-    :hash => [Representable::Hash, {"songs"=>[{"title"=>"Resist Stance"}]}, {"songs"=>[{"title"=>"Suffer"}]}],
-    #:json => [Representable::JSON, "{\"song\":{\"name\":\"Alive\"}}", "{\"song\":{\"name\":\"You've Taken Everything\"}}"],
-    :xml  => [Representable::XML, "<open_struct><song><title>Resist Stance</title></song></open_struct>", "<open_struct><songs><title>Suffer</title></songs></open_struct>"],
-    :yaml => [Representable::YAML, "---\nsongs:\n- title: Resist Stance\n", "---\nsongs:\n- title: Suffer\n"],
-  ) do |format, mod, output, input|
-
-    describe "[#{format}] collection with :parse_strategy: :sync" do # TODO: introduce :representable option?
-      let (:format) { format }
-      representer!(:module => mod, :name => :song_representer) do
-        property :title
-        self.representation_wrap = :song if format == :xml
-      end
-
-      representer!(:inject => :song_representer, :module => mod) do
-        collection :songs, :parse_strategy => :sync, :extend => song_representer
-      end
-
-      let (:album) { OpenStruct.new(:songs => [song]).extend(representer) }
-
-      it "calls #to_hash on song instances, nothing else" do
-        render(album).must_equal_document(output)
-      end
-
-      it "calls #from_hash on the existing song instance, nothing else" do
-        collection_id = album.songs.object_id
-        song          = album.songs.first
-        song_id       = song.object_id
-
-        parse(album, input)
-
-        album.songs.first.title.must_equal "Suffer"
-        song.title.must_equal "Suffer"
-        #album.songs.object_id.must_equal collection_id # TODO: don't replace!
-        song.object_id.must_equal song_id
-      end
-    end
-  end
-
-
-  # Sync errors, when model and incoming are not in sync.
-  describe ":sync with error" do
-    representer! do
-      property :song, :parse_strategy => :sync do
-        property :title
-      end
-    end
-
-    # object.song is nil whereas the document contains one.
-    it do
-      assert_raises Representable::DeserializeError do
-        OpenStruct.new.extend(representer).from_hash({"song" => {"title" => "Perpetual"}})
-      end
-    end
-  end
-
-
-
-  # Lonely Collection
-  for_formats(
-    :hash => [Representable::Hash::Collection, [{"title"=>"Resist Stance"}], [{"title"=>"Suffer"}]],
-    # :xml  => [Representable::XML, "<open_struct><song><title>Resist Stance</title></song></open_struct>", "<open_struct><songs><title>Suffer</title></songs></open_struct>"],
-  ) do |format, mod, output, input|
-
-    describe "[#{format}] lonely collection with :parse_strategy: :sync" do # TODO: introduce :representable option?
-      let (:format) { format }
-      representer!(:module => Representable::Hash, :name => :song_representer) do
-        property :title
-        self.representation_wrap = :song if format == :xml
-      end
-
-      representer!(:inject => :song_representer, :module => mod) do
-        items :parse_strategy => :sync, :extend => song_representer
-      end
-
-      let (:album) { [song].extend(representer) }
-
-      it "calls #to_hash on song instances, nothing else" do
-        render(album).must_equal_document(output)
-      end
-
-      it "calls #from_hash on the existing song instance, nothing else" do
-        #collection_id = album.object_id
-        song          = album.first
-        song_id       = song.object_id
-
-        parse(album, input)
-
-        album.first.title.must_equal "Suffer"
-        song.title.must_equal "Suffer"
-        song.object_id.must_equal song_id
-      end
-    end
-  end
-end
-
-
-class ParseStrategyFindOrInstantiateTest < BaseTest
-  # parse_strategy: :find_or_instantiate
-
-  Song = Struct.new(:id, :title)
-  Song.class_eval do
-    def self.find_by(attributes={})
-      return new(1, "Resist Stan") if attributes[:id]==1# we should return the same object here
-      new
-    end
-  end
-
-  representer!(:name => :song_representer) do
-    property :title
-  end
-
-
-  describe "collection" do
-    representer!(:inject => :song_representer) do
-      collection :songs, :parse_strategy => :find_or_instantiate, :extend => song_representer, :class => Song
-    end
-
-    let (:album) { Struct.new(:songs).new([]).extend(representer) }
-
-
-    it "replaces the existing collection with a new consisting of existing items or new items" do
-      songs_id = album.songs.object_id
-
-      album.from_hash({"songs"=>[{"id" => 1, "title"=>"Resist Stance"}, {"title"=>"Suffer"}]})
-
-      album.songs[0].title.must_equal "Resist Stance" # note how title is updated from "Resist Stan"
-      album.songs[0].id.must_equal 1
-      album.songs[1].title.must_equal "Suffer"
-      album.songs[1].id.must_equal nil
-
-      album.songs.object_id.wont_equal songs_id
-    end
-
-    # TODO: test with existing collection
-  end
-
-
-  describe "property" do
-    representer!(:inject => :song_representer) do
-      property :song, :parse_strategy => :find_or_instantiate, :extend => song_representer, :class => Song
-    end
-
-    let (:album) { Struct.new(:song).new.extend(representer) }
-
-
-    it "finds song by id" do
-      album.from_hash({"song"=>{"id" => 1, "title"=>"Resist Stance"}})
-
-      album.song.title.must_equal "Resist Stance" # note how title is updated from "Resist Stan"
-      album.song.id.must_equal 1
-    end
-
-    it "creates song" do
-      album.from_hash({"song"=>{"title"=>"Off The Track"}})
-
-      album.song.title.must_equal "Off The Track"
-      album.song.id.must_equal nil
-    end
-  end
-
-
-  describe "property with dynamic :class" do
-    representer!(:inject => :song_representer) do
-      property :song, :parse_strategy => :find_or_instantiate, :extend => song_representer,
-        :class => lambda { |options| options[:fragment]["class"] }
-    end
-
-    let (:album) { Struct.new(:song).new.extend(representer) }
-
-
-    it "finds song by id" do
-      album.from_hash({"song"=>{"id" => 1, "title"=>"Resist Stance", "class"=>Song}})
-
-      album.song.title.must_equal "Resist Stance" # note how title is updated from "Resist Stan"
-      album.song.id.must_equal 1
-    end
-  end
-end
-
-
-class ParseStrategyLambdaTest < MiniTest::Spec
-  Song = Struct.new(:id, :title)
-  Song.class_eval do
-    def self.find_by(attributes={})
-      return new(1, "Resist Stan") if attributes[:id]==1# we should return the same object here
-      new
-    end
-  end
-
-  representer!(:name => :song_representer) do
-    property :title
-  end
-
-  # property with instance: lambda, using representable's setter. # TODO: that should be handled better via my api.
-  describe "property parse_strategy: lambda, representable: false" do
-    representer! do
-      property :title,
-        :instance      => lambda { |options| options[:fragment].to_s },  # this will still call song.title= "8675309".
-        :representable => false # don't call object.from_hash
-    end
-
-    let (:song) { Song.new(nil, nil) }
-    it { song.extend(representer).from_hash("title" => 8675309).title.must_equal "8675309" }
-  end
-
-
-  describe "collection" do
-    representer!(:inject => :song_representer) do
-      collection :songs, :parse_strategy => lambda { |options|
-        songs << song = Song.new
-        song
-      }, :extend => song_representer
-    end
-
-    let (:album) { Struct.new(:songs).new([Song.new(1, "A Walk")]).extend(representer) }
-
-
-    it "adds to existing collection" do
-      songs_id = album.songs.object_id
-
-      album.from_hash({"songs"=>[{"title"=>"Resist Stance"}]})
-
-      album.songs[0].title.must_equal "A Walk" # note how title is updated from "Resist Stan"
-      album.songs[0].id.must_equal 1
-      album.songs[1].title.must_equal "Resist Stance"
-      album.songs[1].id.must_equal nil
-
-      album.songs.object_id.must_equal songs_id
-    end
-
-    # TODO: test with existing collection
-  end
-end