disposable 0.0.9 → 0.1.0

data/test/twin/from_test.rb

@@ -0,0 +1,37 @@
+require 'test_helper'
+
+class FromTest < MiniTest::Spec
+  module Model
+    Album = Struct.new(:name, :composer)
+    Artist = Struct.new(:realname)
+  end
+
+
+  module Twin
+    class Album < Disposable::Twin
+      feature Sync
+      feature Save
+      feature Disposable::Twin::Expose
+
+      property :full_name, from: :name
+
+      property :artist, from: :composer do
+        property :name, from: :realname
+      end
+    end
+  end
+
+
+  let (:composer) { Model::Artist.new("AFI").extend(Disposable::Saveable) }
+  let (:album)    { Model::Album.new("Black Sails In The Sunset", composer).extend(Disposable::Saveable) }
+  let (:twin)     { Twin::Album.new(album) }
+
+  it do
+    twin.full_name.must_equal "Black Sails In The Sunset"
+    twin.artist.name.must_equal "AFI"
+
+    twin.save
+
+
+  end
+end

data/test/twin/inherit_test.rb

@@ -0,0 +1,57 @@
+require "test_helper"
+
+class InheritTest < MiniTest::Spec
+  module Model
+    Song  = Struct.new(:title, :album)
+    Album = Struct.new(:name, :songs, :artist)
+    Artist = Struct.new(:name)
+  end
+
+  module Twin
+    class Album < Disposable::Twin
+      feature Setup
+
+      property :name, fromage: :_name
+
+      collection :songs do
+        property :name
+      end
+
+      property :artist do
+        property :name
+
+        def artist_id
+          1
+        end
+      end
+    end
+
+    class EmptyCompilation < Album
+    end
+
+    class Compilation < Album
+      property :name, writeable: false, inherit: true
+
+      property :artist, inherit: true do
+
+      end
+    end
+  end
+
+  # definitions are not shared.
+  it do
+    Twin::Album.representer_class.representable_attrs.get(:name).inspect.must_equal "#<Representable::Definition ==>name @options={:fromage=>:_name, :private_name=>:name, :pass_options=>true, :parse_filter=>[], :render_filter=>[], :as=>\"name\"}>"
+    Twin::Compilation.representer_class.representable_attrs.get(:name).inspect.must_equal "#<Representable::Definition ==>name @options={:fromage=>:_name, :private_name=>:name, :pass_options=>true, :parse_filter=>[], :render_filter=>[], :as=>\"name\", :writeable=>false, :inherit=>true}>"
+  end
+
+
+  let (:album) { Model::Album.new("In The Meantime And Inbetween Time", [], Model::Artist.new) }
+
+  it { Twin::Album.new(album).artist.artist_id.must_equal 1 }
+
+  # inherit inline twins when not overriding.
+  it { Twin::EmptyCompilation.new(album).artist.artist_id.must_equal 1 }
+
+  # inherit inline twins when overriding.
+  it { Twin::Compilation.new(album).artist.artist_id.must_equal 1 }
+end

data/test/twin/option_test.rb

@@ -0,0 +1,27 @@
+# require "test_helper"
+
+# class TwinOptionTest < TwinTest
+#   class Song < Disposable::Twin
+#     property :id # DISCUSS: needed for #save.
+#     property :title
+
+#     option :preview?
+#     option :highlight?
+#   end
+
+#   let (:song) { Model::Song.new(1, "Broken") }
+#   let (:twin) { Song.new(song, :preview? => false) }
+
+
+#   # properties are read from model.
+#   it { twin.id.must_equal 1 }
+#   it { twin.title.must_equal "Broken" }
+
+#   # option is not delegated to model.
+#   it { twin.preview?.must_equal false }
+#   # not passing option means zero.
+#   it { twin.highlight?.must_equal nil }
+
+#   # passing both options.
+#   it { Song.new(song, preview?: true, highlight?: false).preview?.must_equal true }
+# end

data/test/twin/readable_test.rb

@@ -0,0 +1,57 @@
+require 'test_helper'
+
+class ReadableTest < MiniTest::Spec
+  Credentials = Struct.new(:password, :credit_card) do
+    def password
+      raise "don't call me!"
+    end
+  end
+
+  CreditCard = Struct.new(:name, :number) do
+    def number
+      raise "don't call me!"
+    end
+  end
+
+  class PasswordForm < Disposable::Twin
+    feature Setup
+    feature Sync
+
+    property :password, readable: false
+
+    property :credit_card do
+      property :name
+      property :number, readable: false
+    end
+  end
+
+  let (:cred) { Credentials.new("secret", CreditCard.new("Jonny", "0987654321")) }
+
+  let (:twin) { PasswordForm.new(cred) }
+
+  it {
+    twin.password.must_equal nil            # not readable.
+    twin.credit_card.name.must_equal "Jonny"
+    twin.credit_card.number.must_equal nil  # not readable.
+
+    # manual setting on the twin works.
+    twin.password = "123"
+    twin.password.must_equal "123"
+
+    twin.credit_card.number = "456"
+    twin.credit_card.number.must_equal "456"
+
+    twin.sync
+
+    # it writes, but does not read.
+    cred.inspect.must_equal '#<struct ReadableTest::Credentials password="123", credit_card=#<struct ReadableTest::CreditCard name="Jonny", number="456">>'
+
+    # test sync{}.
+    hash = {}
+    twin.sync do |nested|
+      hash = nested
+    end
+
+    hash.must_equal("password"=> "123", "credit_card"=>{"name"=>"Jonny", "number"=>"456"})
+  }
+end

data/test/twin/save_test.rb

@@ -0,0 +1,192 @@
+require 'test_helper'
+
+class SaveTest < MiniTest::Spec
+  module Model
+    Song  = Struct.new(:title, :composer)
+    Album = Struct.new(:name, :songs, :artist)
+    Artist = Struct.new(:name)
+  end
+
+
+  module Twin
+    class Album < Disposable::Twin
+      feature Setup
+      feature Sync
+      feature Save
+
+      property :name
+
+      collection :songs do
+        property :title
+
+        property :composer do
+          property :name
+        end
+      end
+
+      property :artist do
+        property :name
+      end
+    end
+  end
+
+
+  let (:song) { Model::Song.new().extend(Disposable::Saveable) }
+  let (:composer) { Model::Artist.new(nil).extend(Disposable::Saveable) }
+  let (:song_with_composer) { Model::Song.new(nil, composer).extend(Disposable::Saveable) }
+  let (:artist) { Model::Artist.new(nil).extend(Disposable::Saveable) }
+
+
+  let (:album) { Model::Album.new(nil, [song, song_with_composer], artist).extend(Disposable::Saveable) }
+
+  let (:twin) { Twin::Album.new(album) }
+
+  # with populated model.
+  it do
+    fill_out!(twin)
+
+    twin.save
+
+    # sync happened.
+    album.name.must_equal "Live And Dangerous"
+    album.songs[0].must_be_instance_of Model::Song
+    album.songs[1].must_be_instance_of Model::Song
+    album.songs[0].title.must_equal "Southbound"
+    album.songs[1].title.must_equal "The Boys Are Back In Town"
+    album.songs[1].composer.must_be_instance_of Model::Artist
+    album.songs[1].composer.name.must_equal "Lynott"
+    album.artist.must_be_instance_of Model::Artist
+    album.artist.name.must_equal "Thin Lizzy"
+
+    # saved?
+    album.saved?.must_equal true
+    album.songs[0].saved?.must_equal true
+    album.songs[1].saved?.must_equal true
+    album.songs[1].composer.saved?.must_equal true
+    album.artist.saved?.must_equal true
+  end
+
+  #save returns result.
+  it { twin.save.must_equal true }
+  it do
+    album.instance_eval { def save; false; end }
+    twin.save.must_equal false
+  end
+
+  # with save{}.
+  it do
+    twin = Twin::Album.new(album)
+
+    # this usually happens in Contract::Validate or in from_* in a representer
+    fill_out!(twin)
+
+    nested_hash = nil
+    twin.save do |hash|
+      nested_hash = hash
+    end
+
+    nested_hash.must_equal({"name"=>"Live And Dangerous", "songs"=>[{"title"=>"Southbound"}, {"title"=>"The Boys Are Back In Town", "composer"=>{"name"=>"Lynott"}}], "artist"=>{"name"=>"Thin Lizzy"}})
+
+    # nothing written to model.
+    album.name.must_equal nil
+    album.songs[0].title.must_equal nil
+    album.songs[1].title.must_equal nil
+    album.songs[1].composer.name.must_equal nil
+    album.artist.name.must_equal nil
+
+    # nothing saved.
+    # saved?
+    album.saved?.must_equal nil
+    album.songs[0].saved?.must_equal nil
+    album.songs[1].saved?.must_equal nil
+    album.songs[1].composer.saved?.must_equal nil
+    album.artist.saved?.must_equal nil
+  end
+
+
+  # save: false
+  module Twin
+    class AlbumWithSaveFalse < Disposable::Twin
+      feature Setup
+      feature Sync
+      feature Save
+
+      property :name
+
+      collection :songs, save: false do
+        property :title
+
+        property :composer do
+          property :name
+        end
+      end
+
+      property :artist do
+        property :name
+      end
+    end
+  end
+
+  # with save: false.
+  it do
+    twin = Twin::AlbumWithSaveFalse.new(album)
+
+    fill_out!(twin)
+
+    twin.save
+
+    # sync happened.
+    album.name.must_equal "Live And Dangerous"
+    album.songs[0].must_be_instance_of Model::Song
+    album.songs[1].must_be_instance_of Model::Song
+    album.songs[0].title.must_equal "Southbound"
+    album.songs[1].title.must_equal "The Boys Are Back In Town"
+    album.songs[1].composer.must_be_instance_of Model::Artist
+    album.songs[1].composer.name.must_equal "Lynott"
+    album.artist.must_be_instance_of Model::Artist
+    album.artist.name.must_equal "Thin Lizzy"
+
+    # saved?
+    album.saved?.must_equal true
+    album.songs[0].saved?.must_equal nil
+    album.songs[1].saved?.must_equal nil
+    album.songs[1].composer.saved?.must_equal nil # doesn't get saved.
+    album.artist.saved?.must_equal true
+  end
+
+  def fill_out!(twin)
+    twin.name = "Live And Dangerous"
+    twin.songs[0].title = "Southbound"
+    twin.songs[1].title = "The Boys Are Back In Town"
+    twin.songs[1].composer.name = "Lynott"
+    twin.artist.name = "Thin Lizzy"
+  end
+end
+
+
+# TODO: with block
+
+# class SaveWithDynamicOptionsTest < MiniTest::Spec
+#   Song = Struct.new(:id, :title, :length) do
+#     include Disposable::Saveable
+#   end
+
+#   class SongForm < Reform::Form
+#     property :title#, save: false
+#     property :length, virtual: true
+#   end
+
+#   let (:song) { Song.new }
+#   let (:form) { SongForm.new(song) }
+
+#   # we have access to original input value and outside parameters.
+#   it "xxx" do
+#     form.validate("title" => "A Poor Man's Memory", "length" => 10)
+#     length_seconds = 120
+#     form.save(length: lambda { |value, options| form.model.id = "#{value}: #{length_seconds}" })
+
+#     song.title.must_equal "A Poor Man's Memory"
+#     song.length.must_equal nil
+#     song.id.must_equal "10: 120"
+#   end
+# end

data/test/twin/schema_test.rb

@@ -0,0 +1,69 @@
+require "test_helper"
+
+require "disposable/twin/schema"
+
+class SchemaTest < MiniTest::Spec
+  module Representer
+    include Representable
+
+    property :id
+    property :title, writeable: false, deserializer: {skip_parse: "skip lambda"}
+    property :songs, readable: false, deserializer: {skip_parse: "another lambda", music: true, writeable: false} do
+      property :name, as: "Name", deserializer: {skip_parse: "a crazy cool instance method"}
+    end
+  end
+
+  module Hello
+    def hello
+      "hello"
+    end
+  end
+
+  module Ciao
+    def ciao
+      "ciao"
+    end
+  end
+
+  module Gday
+    def hello
+      "G'day"
+    end
+  end
+
+  it do
+    decorator = Disposable::Twin::Schema.from(Representer, superclass: Representable::Decorator,
+      include: [Hello, Gday, Ciao], # Hello will win over Gday.
+      options_from: :deserializer,
+      representer_from: lambda { |nested| nested }
+    )
+
+    # include: works.
+    decorator.new(nil).hello.must_equal "hello"
+    decorator.new(nil).ciao.must_equal "ciao"
+
+    decorator.representable_attrs.get(:id).inspect.must_equal "#<Representable::Definition ==>id @options={:parse_filter=>[], :render_filter=>[], :as=>\"id\"}>"
+    decorator.representable_attrs.get(:title).inspect.must_equal "#<Representable::Definition ==>title @options={:writeable=>false, :deserializer=>{:skip_parse=>\"skip lambda\"}, :parse_filter=>[], :render_filter=>[], :as=>\"title\", :skip_parse=>\"skip lambda\"}>"
+
+    songs = decorator.representable_attrs.get(:songs)
+    options = songs.instance_variable_get(:@options)
+    nested_extend = options.delete(:extend)
+    options.inspect.must_equal "{:readable=>false, :deserializer=>{:skip_parse=>\"another lambda\", :music=>true, :writeable=>false}, :parse_filter=>[], :render_filter=>[], :as=>\"songs\", :_inline=>true, :skip_parse=>\"another lambda\", :music=>true, :writeable=>false}"
+
+    # nested works.
+    nested_extend.new(nil).hello.must_equal "hello"
+    nested_extend.new(nil).ciao.must_equal "ciao"
+
+    nested_extend.representable_attrs.get(:name).inspect.must_equal "#<Representable::Definition ==>name @options={:as=>\"Name\", :deserializer=>{:skip_parse=>\"a crazy cool instance method\"}, :parse_filter=>[], :render_filter=>[], :skip_parse=>\"a crazy cool instance method\"}>"
+  end
+
+  # :options_from and :include is optional
+  it do
+    decorator = Disposable::Twin::Schema.from(Representer, superclass: Representable::Decorator,
+      representer_from: lambda { |nested| nested }
+    )
+
+    decorator.representable_attrs.get(:id).inspect.must_equal "#<Representable::Definition ==>id @options={:parse_filter=>[], :render_filter=>[], :as=>\"id\"}>"
+    decorator.representable_attrs.get(:title).inspect.must_equal "#<Representable::Definition ==>title @options={:writeable=>false, :deserializer=>{:skip_parse=>\"skip lambda\"}, :parse_filter=>[], :render_filter=>[], :as=>\"title\"}>"
+  end
+end

data/test/twin/setup_test.rb

@@ -0,0 +1,139 @@
+require "test_helper"
+
+class TwinSetupTest < MiniTest::Spec
+  module Model
+    Song  = Struct.new(:id, :title, :album, :composer)
+    Album = Struct.new(:id, :name, :songs, :artist)
+    Artist = Struct.new(:id)
+  end
+
+
+  module Twin
+    class Album < Disposable::Twin
+      property :id
+      property :name
+      collection :songs, twin: lambda { |*| Song }
+      property :artist, twin: lambda { |*| Artist }
+
+      include Setup
+    end
+
+    class Song < Disposable::Twin
+      property :id
+      property :composer, twin: lambda { |*| Artist }
+
+      include Setup
+    end
+
+    class Artist < Disposable::Twin
+      property :id
+
+      include Setup
+    end
+  end
+
+
+  let (:song) { Model::Song.new(1, "Broken", nil) }
+  let (:composer) { Model::Artist.new(2) }
+  let (:song_with_composer) { Model::Song.new(1, "Broken", nil, composer) }
+  let (:artist) { Model::Artist.new(9) }
+
+  describe "with songs: [song, song{composer}]" do
+    let (:album) { Model::Album.new(1, "The Rest Is Silence", [song, song_with_composer], artist) }
+
+    it do
+      twin = Twin::Album.new(album)
+
+      twin.songs.size.must_equal 2
+      twin.songs.must_be_instance_of Disposable::Twin::Collection
+
+      twin.songs[0].must_be_instance_of Twin::Song
+      twin.songs[0].id.must_equal 1
+
+      twin.songs[1].must_be_instance_of Twin::Song
+      twin.songs[1].id.must_equal 1
+      twin.songs[1].composer.must_be_instance_of Twin::Artist
+      twin.songs[1].composer.id.must_equal 2
+    end
+  end
+
+  describe "with songs: [] and artist: nil" do
+    let (:album) { Model::Album.new(1, "The Rest Is Silence", [], nil) }
+
+    it do
+      twin = Twin::Album.new(album)
+
+      twin.songs.size.must_equal 0
+      twin.songs.must_be_instance_of Disposable::Twin::Collection
+    end
+  end
+
+  # DISCUSS: do we need to cover that (songs: nil in model)?
+  # describe "with non-existent :songs" do
+  #   let (:album) { Model::Album.new(1, "The Rest Is Silence", nil) }
+
+  #   it do
+  #     twin = Twin::Album.new(album)
+
+  #     twin.songs.size.must_equal 0
+  #     twin.songs.must_be_instance_of Disposable::Twin::Collection
+  #   end
+  # end
+end
+
+# test inline twin building and setup.
+class TwinSetupWithInlineTwinsTest < MiniTest::Spec
+  module Model
+    Song  = Struct.new(:id, :composer)
+    Album = Struct.new(:id, :name, :songs, :artist)
+    Artist = Struct.new(:id)
+  end
+
+  class AlbumForm < Disposable::Twin
+    feature Setup
+
+    property :id
+    property :name
+
+    collection :songs do # default_inline_class: Disposable::Twin
+      property :id
+
+      property :composer do
+        property :id
+      end
+    end
+
+    property :artist do
+      property :id
+    end
+  end
+
+  let (:song) { Model::Song.new(1) }
+  let (:composer) { Model::Artist.new(2) }
+  let (:song_with_composer) { Model::Song.new(3, composer) }
+  let (:artist) { Model::Artist.new(9) }
+  let (:album) { Model::Album.new(0, "Toto Live", [song, song_with_composer], artist) }
+
+  it do
+    twin = AlbumForm.new(album)
+    # pp twin
+
+    twin.id.must_equal 0
+    twin.name.must_equal "Toto Live"
+
+    twin.artist.must_be_kind_of Disposable::Twin
+    twin.artist.id.must_equal 9
+
+    twin.songs.must_be_instance_of Disposable::Twin::Collection
+
+    # nil nested objects work (no composer)
+    twin.songs[0].must_be_kind_of Disposable::Twin
+    twin.songs[0].id.must_equal 1
+
+    twin.songs[1].must_be_kind_of Disposable::Twin
+    twin.songs[1].id.must_equal 3
+
+    twin.songs[1].composer.must_be_kind_of Disposable::Twin
+    twin.songs[1].composer.id.must_equal 2
+  end
+end