disposable 0.0.9 → 0.1.0

data/lib/disposable/twin/schema.rb

@@ -0,0 +1,31 @@
+# TODO: this needs tests and should probably go to Representable. we can move tests from Reform for that.
+class Disposable::Twin::Schema
+  def self.from(source_class, options) # TODO: can we re-use this for all the decorator logic in #validate, etc?
+    representer = Class.new(options[:superclass])
+    representer.send :include, *options[:include]
+
+    source_representer = options[:representer_from].call(source_class)
+
+    source_representer.representable_attrs.each do |dfn|
+      local_options = dfn[options[:options_from]] || {} # e.g. deserializer: {..}.
+      new_options   = dfn.instance_variable_get(:@options).merge(local_options)
+
+      from_scalar!(options, dfn, new_options, representer) && next unless dfn[:extend]
+      from_inline!(options, dfn, new_options, representer)
+    end
+
+    representer
+  end
+
+private
+  def self.from_scalar!(options, dfn, new_options, representer)
+    representer.property(dfn.name, new_options)
+  end
+
+  def self.from_inline!(options, dfn, new_options, representer)
+    nested      = dfn[:extend].evaluate(nil) # nested now can be a Decorator, a representer module, a Form, a Twin.
+    dfn_options = new_options.merge(extend: from(nested, options))
+
+    representer.property(dfn.name, dfn_options)
+  end
+end

data/lib/disposable/twin/setup.rb

@@ -0,0 +1,38 @@
+module Disposable
+  class Twin
+    # Read all properties at twin initialization time from model.
+    # Simply pass through all properties from the model to the respective twin writer method.
+    # This will result in all twin properties/collection items being twinned, and collections
+    # being Collection to expose the desired public API.
+    module Setup
+      # test is in incoming hash? is nil on incoming model?
+
+      def initialize(model, options={})
+        @fields = {}
+        @model  = model
+        @mapper = mapper_for(model) # mapper for model.
+
+        setup_properties!(model, options)
+      end
+
+    private
+      def mapper_for(model)
+        model
+      end
+
+      def setup_properties!(model, options)
+        schema.each do |dfn|
+          next if dfn[:readable] == false
+
+          name  = dfn.name
+          value = options[name.to_sym] || mapper.send(name) # model.title.
+
+          send(dfn.setter, value)
+        end
+
+        @fields.merge!(options) # FIXME: hash/string. # FIXME: call writer!!!!!!!!!!
+        # from_hash(options) # assigns known properties from options.
+      end
+    end # Setup
+  end
+end

data/lib/disposable/twin/sync.rb

@@ -0,0 +1,114 @@
+# #sync!
+#   1. assign scalars to model (respecting virtual, excluded attributes)
+#   2. call sync! on nested
+#
+# Note: #sync currently implicitly saves AR objects with collections
+class Disposable::Twin
+  module Sync
+    def sync_models(options={})
+      return yield to_nested_hash if block_given?
+
+      sync!(options)
+    end
+    alias_method :sync, :sync_models
+
+    # reading from fields allows using readers in form for presentation
+    # and writers still pass to fields in #validate????
+
+    # Sync all scalar attributes, call sync! on nested and return model.
+    def sync!(options) # semi-public.
+      options_for_sync = sync_options(Decorator::Options[options])
+
+      schema.each(options_for_sync) do |dfn|
+        unless dfn[:twin]
+          mapper.send(dfn.setter, send(dfn.getter)) # always sync the property
+          next
+        end
+
+        nested_model = PropertyProcessor.new(dfn, self).() { |twin| twin.sync!({}) }
+
+        next if nested_model.nil?
+
+        mapper.send(dfn.setter, nested_model) # @model.artist = <Artist>
+      end
+
+      model
+    end
+
+    def self.included(includer)
+      includer.extend ToNestedHash::ClassMethods
+    end
+
+  private
+
+    module ToNestedHash
+      def to_nested_hash(*)
+        self.class.nested_hash_representer.new(self).to_hash
+      end
+
+      module ClassMethods
+        # Create a hash representer on-the-fly to serialize the form to a hash.
+        def nested_hash_representer
+          @nested_hash_representer ||= Class.new(representer_class) do
+            include Representable::Hash
+
+            representable_attrs.each do |dfn|
+              dfn.merge!(readable: true) # the nested hash contains all fields.
+              dfn.merge!(as: dfn[:private_name]) # nested hash keys by model property names.
+
+              dfn.merge!(
+                prepare:       lambda { |model, *| model }, # TODO: why do we need that here?
+                serialize:     lambda { |form, args| form.to_nested_hash },
+              ) if dfn[:twin]
+
+              self
+            end
+          end
+        end
+      end
+    end
+    include ToNestedHash
+
+
+    module SyncOptions
+      def sync_options(options)
+        options
+      end
+    end
+    include SyncOptions
+
+
+    # Excludes :virtual and :writeable: false properties from #sync in this twin.
+    module Writeable
+      def sync_options(options)
+        options = super
+
+        protected_fields = schema.each.find_all { |d| d[:writeable] == false }.collect { |d| d.name }
+        options.exclude!(protected_fields)
+      end
+    end
+    include Writeable
+
+
+    # This will skip unchanged properties in #sync. To use this for all nested form do as follows.
+    #
+    #   class SongForm < Reform::Form
+    #     feature Sync::SkipUnchanged
+    module SkipUnchanged
+      def self.included(base)
+        base.send :include, Disposable::Twin::Changed
+      end
+
+      def sync_options(options)
+        # DISCUSS: we currently don't track if nested forms have changed (only their attributes). that's why i include them all here, which
+        # is additional sync work/slightly wrong. solution: allow forms to form.changed? not sure how to do that with collections.
+        scalars   = schema.each(scalar: true).collect { |dfn| dfn.name }
+        unchanged = scalars - changed.keys
+
+        # exclude unchanged scalars, nested forms and changed scalars still go in here!
+        options.exclude!(unchanged)
+        super
+      end
+    end
+  end
+end

data/lib/disposable/version.rb

@@ -1,3 +1,3 @@
 module Disposable
-  VERSION = "0.0.9"
+  VERSION = "0.1.0"
 end

data/test/api_semantics_test.rb

@@ -0,0 +1,263 @@
+require "test_helper"
+require "disposable/twin"
+require "ostruct"
+
+module Model
+  Song  = Struct.new(:id, :title)
+  Album = Struct.new(:id, :name, :songs)
+end
+
+# thoughts:
+# a twin should be a proxy between the incoming API instructions (form hash) and the models to write to.
+# e.g. when deleting certain items in a collection, this could be held in memory before written to DB.
+# reason: a twin can be validated (e.g. is current user allowed to remove item 1 from collection abc?)
+#         before the application state is actually altered in the DB.
+# that would open a clean workflow: API calls --> twin state change --> validation --> "rollback" / save
+
+module Representable
+  class Semantics
+    class Semantic
+      def self.existing_item_for(fragment, options)
+        # return unless model.songs.collect { |s| s.id.to_s }.include?(fragment["id"].to_s)
+        options.binding.get.find { |s| s.id.to_s == fragment["id"].to_s }
+      end
+    end
+
+    class SkipExisting < Semantic
+      def self.call(model, fragment, index, options)
+        return unless existing_item_for(fragment, options)
+
+        Skip.new(fragment)
+      end
+    end
+
+    class Add < Semantic # old representable behavior.
+      def self.call(model, fragment, index, options)
+        binding = options.binding.clone
+        binding.instance_variable_get(:@definition).delete!(:instance) # FIXME: sucks!
+        Representable::Deserializer.new(binding).(fragment, options.user_options) # Song.new
+      end
+    end
+
+    class UpdateExisting < Semantic
+      def self.call(model, fragment, index, options)
+        return unless res = existing_item_for(fragment, options)
+
+         Update.new(res)
+      end
+    end
+
+
+    class Skip < OpenStruct
+    end
+
+    class Remove < Skip
+      def self.call(model, fragment, index, options)
+        return unless fragment["_action"] == "remove" # TODO: check if feature enabled.
+
+        Remove.new(fragment)
+      end
+    end
+
+    require 'delegate'
+    class Update < SimpleDelegator
+    end
+
+    # Per parsed collection item, mark the to-be-populated model for removal, skipping or adding.
+    # This code is called right before #from_format is called on the model.
+    # Semantical behavior is inferred from the fragment making this code document- and format-specific.
+
+    # remove: unlink from association
+    # skip_existing
+    # update_existing
+    # add
+    # [destroy]
+    # callable
+
+    # default behavior: - add_new
+
+    class Instance
+      include Uber::Callable
+
+      def call(model, fragment, index, options)
+        semantics = options.binding[:semantics]
+
+        # loop through semantics, the first that returns something wins.
+        semantics.each do |semantic|
+          res = semantic.(model, fragment, index, options) and return res
+        end
+      end
+    end
+
+    class Setter
+      include Uber::Callable
+
+      def call(model, values, options)
+        remove_items  = values.find_all { |i| i.instance_of?(Representable::Semantics::Remove) }
+        # add_items     = values.find_all { |i| i.instance_of?(Add) }.collect(&:model)
+        add_items     = values - remove_items
+
+        skip_items  = values.find_all { |i| i.instance_of?(Representable::Semantics::Skip) }
+        skip_items  += values.find_all { |i| i.instance_of?(Representable::Semantics::Update) } # TODO: merge with above!
+
+        # add_items     = values.find_all { |i| i.instance_of?(Add) }.collect(&:model)
+        add_items     = add_items - skip_items
+
+        # DISCUSS: collection#[]= will call save
+        #  what does #+= and #-= do?
+        #  how do we prevent adding already existing items twice?
+
+        model.songs += add_items
+        model.songs -= remove_items.collect { |i| model.songs.find { |s| s.id.to_s == i.id.to_s } }
+      end
+    end
+  end
+end
+
+class AlbumDecorator < Representable::Decorator
+  include Representable::Hash
+
+  collection :songs,
+
+    # semantics: [:skip_existing, :add, :remove],
+    semantics: [Representable::Semantics::Remove, Representable::Semantics::SkipExisting, Representable::Semantics::Add],
+
+    instance: Representable::Semantics::Instance.new,
+    pass_options: true,
+    setter: Representable::Semantics::Setter.new,
+
+
+    class: Model::Song do # add new to existing collection.
+
+      # only add new songs
+      property :title
+  end
+end
+
+
+
+class ApiSemanticsTest < MiniTest::Spec
+  it "xxx" do
+    album = Model::Album.new(1, "And So I Watch You From Afar", [Model::Song.new(2, "Solidarity"), Model::Song.new(0, "Tale That Wasn't Right")])
+
+    decorator = AlbumDecorator.new(album)
+    decorator.from_hash({"songs" => [
+      {"id" => 2, "title" => "Solidarity, but wrong title"}, # skip
+      {"id" => 0, "title" => "Tale That Wasn't Right, but wrong title", "_action" => "remove"}, # delete
+      {"id" => 4, "title" => "Capture Castles"} # add, default.
+    ]})
+    # missing: allow updating specific/all items in collection.
+
+    decorator.represented.songs.inspect.must_equal %{[#<struct Model::Song id=2, title="Solidarity">, #<struct Model::Song id=nil, title="Capture Castles">]}
+  end
+
+end
+
+class RemoveFlagSetButNotEnabled < MiniTest::Spec
+  class AlbumDecorator < Representable::Decorator
+    include Representable::Hash
+
+    collection :songs,
+      # semantics: [:skip_existing, :add, :remove],
+      semantics: [Representable::Semantics::SkipExisting, Representable::Semantics::Add],
+
+      instance: Representable::Semantics::Instance.new,
+      pass_options: true,
+      setter: Representable::Semantics::Setter.new,
+      class: Model::Song do
+        property :title
+      end
+  end
+
+  it "doesn't remove when semantic is not enabled" do
+    album = Model::Album.new(1, "And So I Watch You From Afar", [Model::Song.new(2, "Solidarity"), Model::Song.new(0, "Tale That Wasn't Right")])
+
+    decorator = AlbumDecorator.new(album)
+    decorator.from_hash({"songs" => [
+      {"id" => 2, "title" => "Solidarity, updated!"}, # update
+      {"id" => 0, "title" => "Tale That Wasn't Right, but wrong title", "_action" => "remove"}, # delete, but don't!
+      {"title" => "Rise And Fall"}
+    ]})
+
+    decorator.represented.songs.inspect.must_equal %{[#<struct Model::Song id=2, title=\"Solidarity\">, #<struct Model::Song id=0, title=\"Tale That Wasn't Right\">, #<struct Model::Song id=nil, title=\"Rise And Fall\">]}
+  end
+end
+
+class UserCallableTest < MiniTest::Spec
+  class MyOwnSemantic < Representable::Semantics::Semantic
+    def self.call(model, fragment, index, options)
+      if fragment["title"] =~ /Solidarity/
+        return Representable::Semantics::Skip.new(fragment)
+      end
+    end
+  end
+
+  class AlbumDecorator < Representable::Decorator
+    include Representable::Hash
+
+    collection :songs,
+      semantics: [MyOwnSemantic, Representable::Semantics::Add],
+
+      instance: Representable::Semantics::Instance.new,
+      pass_options: true,
+      setter: Representable::Semantics::Setter.new,
+      class: Model::Song do
+        property :title
+      end
+  end
+
+  it do
+    album = Model::Album.new(1, "And So I Watch You From Afar", [Model::Song.new(2, "Solidarity"), Model::Song.new(0, "Tale That Wasn't Right")])
+
+    decorator = AlbumDecorator.new(album)
+    decorator.from_hash({"songs" => [
+      {"id" => 2, "title" => "Solidarity, updated!"}, # update
+      {"title" => "Rise And Fall"}
+    ]})
+
+    decorator.represented.songs.inspect.must_equal %{[#<struct Model::Song id=2, title=\"Solidarity\">, #<struct Model::Song id=0, title=\"Tale That Wasn't Right\">, #<struct Model::Song id=nil, title=\"Rise And Fall\">]}
+  end
+end
+
+
+class ApiSemanticsWithUpdate < MiniTest::Spec
+  class AlbumDecorator < Representable::Decorator
+    include Representable::Hash
+
+    collection :songs,
+
+      semantics: [Representable::Semantics::Remove, Representable::Semantics::UpdateExisting, Representable::Semantics::Add],
+
+      instance: Representable::Semantics::Instance.new,
+      pass_options: true,
+      class: Model::Song,
+
+      setter: Representable::Semantics::Setter.new do # add new to existing collection.
+
+        # only add new songs
+        property :title
+    end
+  end
+
+  it do
+    album = Model::Album.new(1, "And So I Watch You From Afar", [Model::Song.new(2, "Solidarity"), Model::Song.new(0, "Tale That Wasn't Right")])
+
+    decorator = AlbumDecorator.new(album)
+    decorator.from_hash({"songs" => [
+      {"id" => 2, "title" => "Solidarity, updated!"}, # update
+      {"id" => 0, "title" => "Tale That Wasn't Right, but wrong title", "_action" => "remove"}, # delete
+      {"id" => 4, "title" => "Capture Castles"}, # add, default. # FIXME: this tests adding with id, keep this.
+      {"title" => "Rise And Fall"}
+    ]})
+    # missing: allow updating specific/all items in collection.
+
+    puts decorator.represented.songs.inspect
+
+
+    decorator.represented.songs.inspect.must_equal %{[#<struct Model::Song id=2, title="Solidarity, updated!">, #<struct Model::Song id=nil, title="Capture Castles">, #<struct Model::Song id=nil, title=\"Rise And Fall\">]}
+  end
+end
+# [
+#   {"_action": "add"},
+#   {"id": 2, "_action": "remove"}
+# ]