disposable 0.0.9 → 0.1.0

data/test/twin/skip_unchanged_test.rb

@@ -0,0 +1,64 @@
+require "test_helper"
+
+class SkipUnchangedTest < 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 Sync::SkipUnchanged
+
+      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() }
+  let (:composer) { Model::Artist.new(nil) }
+  let (:song_with_composer) { Model::Song.new("American Jesus", composer) }
+  let (:artist) { Model::Artist.new("Bad Religion") }
+
+
+  let (:album) { Model::Album.new("30 Years Live", [song, song_with_composer], artist) }
+
+  it do
+    twin = Twin::Album.new(album)
+
+    twin.songs[1].composer.name = "Greg Graffin"
+    twin.songs[0].title = "Resist Stance"
+
+    # raises exceptions when setters are called.
+    album.instance_eval { def name=; end }
+    artist.instance_eval { def name=; end }
+    song_with_composer.instance_eval { def title=; end }
+
+    twin.sync
+
+    # unchanged, and no exception raised.
+    album.name.must_equal "30 Years Live"
+    song_with_composer.title.must_equal "American Jesus"
+    artist.name.must_equal "Bad Religion"
+
+    # this actually got synced.
+    song_with_composer.composer.name.must_equal "Greg Graffin" # was nil.
+    song.title.must_equal "Resist Stance" # was nil.
+  end
+end

data/test/twin/struct_test.rb

@@ -0,0 +1,168 @@
+# require 'test_helper'
+# require "representable/debug"
+
+# require 'disposable/twin/struct'
+
+
+
+# module Representable
+#   # The generic representer. Brings #to_hash and #from_hash to your object.
+#   # If you plan to write your own representer for a new media type, try to use this module (e.g., check how JSON reuses Hash's internal
+#   # architecture).
+#   module Object
+#     def self.included(base)
+#       base.class_eval do
+#         include Representable
+#         extend ClassMethods
+#         register_feature Representable::Object
+#       end
+#     end
+
+
+#     module ClassMethods
+#       def collection_representer_class
+#         Collection
+#       end
+#     end
+
+#     def from_object(data, options={}, binding_builder=Binding)
+#       update_properties_from(data, options, binding_builder)
+#     end
+
+#     # FIXME: remove me! only here to avoid AllowSymbols from Twin:Representer
+#     def update_properties_from(doc, options, format)
+#       representable_mapper(format, options).deserialize(doc, options)
+#     end
+#   end
+# end
+
+
+
+
+
+# class TwinStructTest < MiniTest::Spec
+#   class Song < Disposable::Twin
+#     include Struct
+#     property :number, default: 1 # FIXME: this should be :default_if_nil so it becomes clear with a model.
+#     option   :cool?
+#   end
+
+#   # empty hash
+#   it { Song.new({}).number.must_equal 1 }
+#   # model hash
+#   it { Song.new(number: 2).number.must_equal 2 }
+
+#   # with hash and options as one hash.
+#   it { Song.new(number: 3, cool?: true).cool?.must_equal true }
+#   it { Song.new(number: 3, cool?: true).number.must_equal 3 }
+
+#   # with model hash and options hash separated.
+#   it { Song.new({number: 3}, {cool?: true}).cool?.must_equal true }
+#   it { Song.new({number: 3}, {cool?: true}).number.must_equal 3 }
+
+
+#   describe "writing" do
+#     let (:song) { Song.new(model, {cool?: true}) }
+#     let (:model) { {number: 3} }
+
+#     # writer
+#     it do
+#       song.number = 9
+#       song.number.must_equal 9
+#       model[:number].must_equal 3
+#     end
+
+#     # writer with sync
+#     it do
+#       song.number = 9
+#       song.sync
+
+#       song.number.must_equal 9
+#       model["number"].must_equal 9
+
+#       song.send(:model).object_id.must_equal model.object_id
+#     end
+#   end
+
+# end
+
+
+# # Non-lazy initialization. This will copy all properties from the wrapped object to the twin when
+# # instantiating the twin.
+
+
+# class TwinWithNestedStructTest < MiniTest::Spec
+#   class Song < Disposable::Twin
+#     include Setup
+#     property :title
+
+#     property :options, twin: true do # don't call #to_hash, this is triggered in the twin's constructor.
+#       include Struct
+#       property :recorded
+#       property :released
+
+#       property :preferences, twin: true do
+#         include Struct
+#         property :show_image
+#         property :play_teaser
+#       end
+#     end
+#   end
+
+#   # FIXME: test with missing hash properties, e.g. without released and with released:false.
+#   let (:model) { OpenStruct.new(title: "Seed of Fear and Anger", options: {recorded: true, released: 1,
+#     preferences: {show_image: true, play_teaser: 2}}) }
+
+#   # public "hash" reader
+#   it { Song.new(model).options.recorded.must_equal true }
+
+#   # public "hash" writer
+#   it ("xxx") {
+#     song = Song.new(model)
+
+#     puts song.inspect
+
+#     # puts song.options.inspect
+#     # puts song.options.preferences.to_hash
+#     # raise
+
+#     song.options.recorded = "yo"
+#     song.options.recorded.must_equal "yo"
+
+#     song.options.preferences.show_image.must_equal true
+#     song.options.preferences.play_teaser.must_equal 2
+
+#     song.options.preferences.show_image= 9
+
+
+#     # song.extend(Disposable::Twin::Struct::Sync)
+#     song.sync # this is only called on the top model, e.g. in Reform#save.
+
+#     model.title.must_equal "Seed of Fear and Anger"
+#     model.options["recorded"].must_equal "yo"
+#     model.options["preferences"].must_equal({"show_image" => 9, "play_teaser"=>2})
+#   }
+# end
+
+
+
+# class SyncRepresenter < Representable::Decorator
+#   include Representable::Object
+
+#   property :title
+#   property :album, instance: lambda { |fragment, *| fragment } do
+#     property :name
+#   end
+# end
+
+# album = Struct.new(:name).new("Ass It Is")
+
+# SyncRepresenter.new(obj = Struct.new(:title, :album).new).from_object(Struct.new(:title, :album).new("Eternal Scream", album))
+
+# puts obj.title.inspect
+# puts obj.inspect
+# # reform
+# #   sync: twin.title = "Good Bye"
+# #         album.sync (copy attributes in nested form)
+# #           twin.name = "Matters"
+# #   save: twin.save (this will do twin.sync... does that call save on all nested twins, too, or do we still have to do that in reform?)

data/test/twin/sync_option_test.rb

@@ -0,0 +1,228 @@
+# require 'test_helper'
+# require "disposable/twin/changed"
+
+# class SyncOptionTest < MiniTest::Spec
+#   module Model
+#     Song  = Struct.new(:title, :composer)
+#     Album = Struct.new(:id, :name, :songs, :artist)
+#     Artist = Struct.new(:name, :hidden_taste)
+#   end
+
+
+#   module Twin
+#     class Album < Disposable::Twin
+#       feature Setup
+#       feature Sync
+#       # feature Changed
+
+#       property :id,   sync: lambda { |value, options| nil }
+#       property :name, sync: lambda { |value, options| value == "Run For Cover" ? model.name= "processed+#{value}" : model.name= "#{value}+unprocessed" } # assign if album name is "Run For Cover".
+
+#       collection :songs ,
+#          sync: lambda { |value, options|  } do # FIXME: this is called before the songs items where synced?
+#         property :title, sync: lambda { |value, options| value == "Empty Rooms" ? model.title= "++#{value}" : nil }
+#       end
+
+#       property :artist, sync: lambda { |twin, options| twin.model.hidden_taste = "Ska" } do
+#         property :name
+#       end
+#     end
+#   end
+
+
+
+#   # sync does NOT call setter.
+#   describe ":sync allows you conditionals and is run in twin context" do
+#     let (:album) { Model::Album.new(1, "Corridors Of Power", [song, song_with_composer], artist) }
+#     let (:song) { Model::Song.new() }
+#     let (:song_with_composer) { Model::Song.new("American Jesus", composer) }
+#     let (:composer) { Model::Artist.new(nil) }
+#     let (:artist) { Model::Artist.new("Bad Religion") }
+
+#     let (:twin) { Twin::Album.new(album) }
+
+#     it do
+#       album.instance_exec { def id=(*);    raise "don't call me!"; end }
+#       song.instance_exec  { def title=(*); raise "don't call me!"; end }
+
+#       # triggers :sync.
+#       twin.name = "Run For Cover"
+
+#       twin.songs[1].title = "Empty Rooms" # song_with_composer. this will trigger the #title= writer.
+#       twin.artist.name = "Gary Moore"
+
+#       twin.sync # name is still "Corridors Of Power"
+
+#       # Album#id :sync was called, nothing happened.
+#       album.id.must_equal 1
+#       # Album#name :sync was called, first case.
+#       album.name.must_equal "processed+Run For Cover"
+#       # Song#title :sync called but returns nil.
+#       song.title.must_equal nil
+#       # Song#title :sync called and processed, first case.
+#       song_with_composer.title.must_equal "++Empty Rooms"
+
+#       # Artist#name :sync was called.
+#       artist.name.must_equal "Gary Moore"
+#       # Album#artist :sync was called.
+#       artist.hidden_taste.must_equal "Ska"
+#     end
+
+#     # trigger second case of Album#name to make sure conditionals work.
+#     it do
+#       twin.name = "This is not: Run For Cover" # triggers :sync, second case.
+#       twin.sync
+#       album.name.must_equal "This is not: Run For Cover+unprocessed"
+#     end
+#   end
+# end
+
+
+# class SyncWithDynamicOptionsTest < MiniTest::Spec
+#   module Model
+#     Song  = Struct.new(:title, :composer)
+#     Album = Struct.new(:id, :name, :songs, :artist)
+#     Artist = Struct.new(:name, :hidden_taste)
+#   end
+
+
+#   module Twin
+#     class Album < Disposable::Twin
+#       feature Setup
+#       feature Sync
+#       # feature Changed
+
+#       property :id,   sync: true
+#       property :name, sync: true
+
+#       collection :songs ,
+#          sync: lambda { |value, options|  } do # FIXME: this is called before the songs items where synced?
+#         property :title, sync: lambda { |value, options| value == "Empty Rooms" ? model.title= "++#{value}" : nil }
+#       end
+
+#       property :artist, sync: true do
+#         property :name
+#       end
+#     end
+#   end
+
+
+#   # sync does NOT call setter.
+#   describe ":sync allows you conditionals and is run in twin context" do
+#     let (:album) { Model::Album.new(1, "Corridors Of Power", [song, song_with_composer], artist) }
+#     let (:song) { Model::Song.new() }
+#     let (:song_with_composer) { Model::Song.new("American Jesus", composer) }
+#     let (:composer) { Model::Artist.new(nil) }
+#     let (:artist) { Model::Artist.new("Bad Religion") }
+
+#     let (:twin) { Twin::Album.new(album) }
+
+#     it do
+#       album.instance_exec { def id=(*);    raise "don't call me!"; end }
+#       song.instance_exec  { def title=(*); raise "don't call me!"; end }
+
+#       # triggers :sync.
+#       twin.name = "Run For Cover"
+
+#       twin.songs[1].title = "Empty Rooms" # song_with_composer. this will trigger the #title= writer.
+#       twin.artist.name = "Gary Moore"
+
+#       twin.sync(
+#         id:     lambda { |value, options| nil },
+#         name:   lambda { |value, options| options.user_options[:twin].model.name= "processed+#{value}" },
+
+#         artist: lambda { |twin, options| twin.model.hidden_taste = "Ska" },
+#       )
+
+#       # Album#id :sync was called, nothing happened.
+#       album.id.must_equal 1
+#       # Album#name :sync was called, first case.
+#       album.name.must_equal "processed+Run For Cover"
+#       # Song#title :sync called but returns nil.
+#       song.title.must_equal nil
+#       # Song#title :sync called and processed, first case.
+#      #### song_with_composer.title.must_equal "++Empty Rooms"
+
+#       # Artist#name :sync was called.
+#       artist.name.must_equal "Gary Moore"
+#       # Album#artist :sync was called.
+#       artist.hidden_taste.must_equal "Ska"
+#     end
+#   end
+# end
+
+
+# class SyncWithOptionsAndSkipUnchangedTest < MiniTest::Spec
+#   module Model
+#     Song  = Struct.new(:title, :composer)
+#     Album = Struct.new(:id, :name, :songs, :artist)
+#     Artist = Struct.new(:name)
+#   end
+
+
+#   module Twin
+#     class Album < Disposable::Twin
+#       feature Setup
+#       feature Sync
+#       feature Sync::SkipUnchanged
+
+#       property :id
+#       property :name
+
+#       collection :songs do # FIXME: this is called before the songs items where synced?
+#         property :title
+#       end
+
+#       # only execute this when changed.
+#       property :artist, sync: lambda { |artist_twin, options| model.artist.name = "#{artist_twin.name}+" } do
+#         property :name
+#       end
+#     end
+#   end
+
+#   let (:album) { Model::Album.new(1, "Corridors Of Power", [], artist) }
+#   # let (:song) { Model::Song.new() }
+#   # let (:song_with_composer) { Model::Song.new("American Jesus", composer) }
+#   # let (:composer) { Model::Artist.new(nil) }
+#   let (:artist) { Model::Artist.new("Bad Religion") }
+
+#   it do
+#     twin = Twin::Album.new(album)
+
+#     twin.artist.name.must_equal "Bad Religion"
+#     twin.sync
+#     twin.artist.name.must_equal "Bad Religion"
+
+#     twin.artist.name= "Greg Howe"
+#     twin.sync
+#     artist.name.must_equal "Greg Howe+"
+#   end
+# end
+
+# # :virtual wins over :sync
+# # class SyncWithVirtualTest < MiniTest::Spec
+# #   Song = Struct.new(:title, :image, :band)
+# #   Band = Struct.new(:name)
+
+# #   let (:form) { HitForm.new(song) }
+# #   let (:song) { Song.new("Injection", Object, Band.new("Rise Against")) }
+
+# #   class HitForm < Disposable::Twin
+# #     include Sync::SkipUnchanged
+# #     register_feature Sync::SkipUnchanged
+
+# #     property :image, sync: lambda { |value, *| model.image = "processed via :sync: #{value}" }
+# #     property :band do
+# #       property :name, sync: lambda { |value, *| model.name = "band, processed: #{value}" }, virtual: true
+# #     end
+# #   end
+
+# #   it "abc" do
+# #     form.validate("image" => "Funny photo of Steve Harris", "band" => {"name" => "Iron Maiden"}).must_equal true
+
+# #     form.sync
+# #     song.image.must_equal "processed via :sync: Funny photo of Steve Harris"
+# #     song.band.name.must_equal "Rise Against"
+# #   end
+# # end
+