disposable 0.0.9 → 0.1.0

data/lib/disposable/twin/builder.rb

@@ -1,46 +1,28 @@
+require "uber/builder"
+
 module Disposable
   class Twin
-    # Allows setting a twin class for a host object (e.g. a cell, a form, or a representer) using ::twin
-    # and imports a method #build_twin to initialize this twin.
-    #
-    # Example:
+    # Allows building different twin classes.
     #
     #   class SongTwin < Disposable::Twin
-    #     properties :id, :title
-    #     option :is_released
-    #   end
-    #
-    #   class Cell
-    #     include Disposable::Twin::Builder
-    #     twin SongTwin
-    #
-    #     def initialize(model, options)
-    #       @twin = build_twin(model, options)
+    #     include Builder
+    #     builds ->(model, options) do
+    #       return Hit       if model.is_a? Model::Hit
+    #       return Evergreen if options[:evergreen]
     #     end
     #   end
     #
-    # An optional block passed to ::twin will be called per property yielding the Definition instance.
+    #   SongTwin.build(Model::Hit.new) #=> <Hit>
     module Builder
       def self.included(base)
         base.class_eval do
-          extend Uber::InheritableAttr
-          inheritable_attr :twin_class
-          extend ClassMethods
-        end
-      end
+          include Uber::Builder
 
-      module ClassMethods
-        def twin(twin_class, &block)
-          twin_class.representer_class.representable_attrs.each { |dfn| yield(dfn) } if block_given?
-          self.twin_class = twin_class
+          def self.build(model, options={}) # semi-public.
+            class_builder.call(model, options).new(model, options) # Uber::Builder::class_builder.
+          end
         end
       end
-
-    private
-
-      def build_twin(*args)
-        self.class.twin_class.new(*args)
-      end
     end
   end
 end

data/lib/disposable/twin/changed.rb

@@ -0,0 +1,50 @@
+module Disposable::Twin::Changed
+  class Changes < Hash
+    def changed?(name=nil)
+      return true if name.nil? and values.find { |val| val == true } # TODO: this could be speed-improved, of course.
+
+      !! self[name.to_s]
+    end
+  end
+
+
+  def changed?(*args) # not recommended for external use?
+    changed.changed?(*args)
+  end
+
+# FIXME: can we make #changed the only public concept? so we don't need to find twice?
+
+  # this is usually called only once in Sync::SkipUnchanged, per twin.
+  def changed
+    _find_changed_twins!(@_changes)
+
+    @_changes
+  end
+
+private
+  def initialize(model, *args)
+    super         # Setup#initialize.
+    @_changes = Changes.new # override changed from initialize.
+  end
+
+  def _changed
+    @_changes ||= Changes.new # FIXME: why do we need to re-initialize here?
+  end
+
+  def write_property(name, value, dfn)
+    old_value = send(name)
+
+    super.tap do
+      _changed[name.to_s] = old_value != value
+    end
+  end
+
+  def _find_changed_twins!(changes) # FIXME: this will change soon. don't touch.
+    schema.each(twin: true) do |dfn|
+      next unless twin = send(dfn.getter)
+      next unless twin.changed?
+
+      changes[dfn.name] = true
+    end
+  end
+end

data/lib/disposable/twin/collection.rb

@@ -0,0 +1,95 @@
+module Disposable
+  class Twin
+    # Provides collection semantics like add, delete, and more for twin collections.
+    # Tracks additions and deletions in #added and #deleted.
+    class Collection < Array
+      def self.for_models(twinner, models)
+        new(twinner, models.collect { |model| twinner.(model) })
+      end
+
+      def initialize(twinner, items)
+        super(items)
+        @twinner  = twinner # DISCUSS: twin items here?
+        @original = items
+      end
+      attr_reader :original # TODO: test me and rethink me.
+
+      # Note that this expects a model, untwinned.
+      def <<(model)
+        super(twin = @twinner.(model))
+        added << twin
+        # this will return the model, anyway.
+      end
+
+      # Note that this expects a model, untwinned.
+      def insert(index, model)
+        super(index, twin = @twinner.(model))
+        added << twin
+        twin
+      end
+
+      # Remove an item from a collection. This will not destroy the model.
+      def delete(twin)
+        super(twin).tap do |res|
+          deleted << twin if res
+        end
+      end
+
+      # Deletes twin from collection and destroys it in #save.
+      def destroy(twin)
+        delete(twin)
+        to_destroy << twin
+      end
+
+      def save # only gets called when Collection::Semantics mixed in.
+        destroy!
+      end
+
+      module Changed
+        # FIXME: this should not be included automatically, as Changed is a feature.
+        def changed?
+          find { |twin| twin.changed? }
+        end
+      end
+      include Changed
+
+      # DISCUSS: am i a public concept, hard-wired into Collection?
+      def added
+        @added ||= []
+      end
+
+      # DISCUSS: am i a public concept, hard-wired into Collection?
+      def deleted
+        @deleted ||= []
+      end
+
+      # DISCUSS: am i a public concept, hard-wired into Collection?
+      def destroyed
+        @destroyed ||= []
+      end
+
+    private
+      def to_destroy
+        @to_destroy ||= []
+      end
+
+      def destroy!
+        to_destroy.each do |twin|
+          twin.send(:model).destroy
+          destroyed << twin
+        end
+      end
+
+
+      module Semantics
+        def save
+          super.tap do
+            schema.each(collection: true) do |dfn| # save on every collection.
+              send(dfn.getter).save
+            end
+          end
+        end
+      end # Semantics.
+    end
+  end
+end

data/lib/disposable/twin/composition.rb

@@ -1,26 +1,54 @@
+require "disposable/expose"
+require "disposable/composition"
+
 module Disposable
   class Twin
-    class Composition
-      include Disposable::Composition
+    module Expose
+      module ClassMethods
+        def expose_class
+          @expose_class ||= Class.new(Disposable::Expose).from(representer_class)
+        end
+      end # ClassMethods.
+
+      def self.included(base)
+        base.extend(ClassMethods)
+      end
+
+      module Initialize
+        def mapper_for(*args)
+          self.class.expose_class.new(*args)
+        end
+      end
+      include Initialize
+    end
 
-      extend Uber::InheritableAttr
-      inheritable_attr :twin_classes
-      self.twin_classes = {}
 
-      # this creates one Twin per composed.
-      def self.property(name, options, &block)
-        twin_classes[options[:on]] ||= Class.new(Twin)
-        twin_classes[options[:on]].property(name, options, &block)
+    module Composition
+      module ClassMethods
+        def expose_class
+          @expose_class ||= Class.new(Disposable::Composition).from(representer_class)
+        end
+      end
 
-        map options[:on] => [[name]] # why is Composition::map so awkward?
+      def self.included(base)
+        base.send(:include, Expose::Initialize)
+        base.extend(ClassMethods)
       end
-      # TODO: test and implement ::collection
 
-      def initialize(composed)
-        twins = {}
-        composed.each { |name, model| twins[name] = self.class.twin_classes[name].new(model) }
+      def to_nested_hash(*)
+        hash = {}
+
+        @model.each do |name, model| # TODO: provide list of composee attributes in Composition.
+          part_properties = self.class.representer_class.representable_attrs.find_all { |dfn| dfn[:on] == name }.collect(&:name).collect(&:to_sym)
+          hash[name] = self.class.nested_hash_representer.new(self).to_hash(include: part_properties)
+        end
+
+        hash
+      end
 
-        super(twins)
+    private
+      def save_model
+        mapper.each(&:save) # goes through all models in Composition.
       end
     end
   end

data/lib/disposable/twin/option.rb

@@ -6,7 +6,7 @@ module Disposable::Twin::Option
   module ClassMethods
     def option(name, options={})
       # default: nil will always set an option in the, even when not in the incoming options.
-      property(name, options.merge(:readable => false, :default => nil))
+      property(name, options.merge(readable: false, writeable: false, default: nil))
     end
   end
 end

data/lib/disposable/twin/persisted.rb

@@ -0,0 +1,20 @@
+# Keeps the #persisted? property synced with the model's.
+module Disposable::Twin::Persisted
+  def self.included(includer)
+    includer.send(:property, :persisted?, writeable: false)
+  end
+
+  def save!(*)
+    super.tap do
+      send "persisted?=", model.persisted?
+    end
+  end
+
+  def created?
+    # when the persisted field got flipped, this means creation!
+    changed?(:persisted?)
+  end
+
+  # DISCUSS: i did not add #updated? on purpose. while #created's semantic is clear, #updated is confusing.
+  # does it include change, etc. i leave this up to the user until we have a clear definition.
+end

data/lib/disposable/twin/property_processor.rb

@@ -0,0 +1,29 @@
+# This is similar to Representable::Serializer and allows to apply a piece of logic (the
+# block passed to #call) to every twin for this property.
+#
+# For a scalar property, this will be run once and yield the property's value.
+# For a collection, this is run per item and yields the item.
+class Disposable::Twin::PropertyProcessor
+  def initialize(definition, twin)
+    @definition, @twin = definition, twin
+  end
+
+  def call(&block)
+    if @definition[:collection]
+      collection!(&block)
+    else
+      property!(&block)
+    end
+  end
+
+private
+  def collection!
+    # FIXME: the nil collection is not tested, yet!
+    (@twin.send(@definition.getter) || []).collect { |nested_twin| yield(nested_twin) }
+  end
+
+  def property!
+    twin = @twin.send(@definition.getter) or return nil
+    nested_model = yield(twin)
+  end
+end

data/lib/disposable/twin/representer.rb

@@ -1,29 +1,57 @@
+require "representable/decorator"
+# require "representable/hash"
+
 module Disposable
   class Twin
     class Decorator < Representable::Decorator
-      include Representable::Hash
-      include AllowSymbols
+      # Overrides representable's Definition class so we can add semantics in our representers.
+      class Definition < Representable::Definition
+        def dynamic_options
+          super + [:twin]
+        end
 
-      # DISCUSS: same in reform, is that a bug in represntable?
-      def self.clone # called in inheritable_attr :representer_class.
-        Class.new(self) # By subclassing, representable_attrs.clone is called.
+        def twin_class
+          self[:twin].evaluate(nil) # FIXME: do we support the :twin option, and should it be wrapped?
+        end
       end
 
+      # FIXME: this is not properly used when inheriting - fix that in representable.
       def self.build_config
         Config.new(Definition)
       end
 
-      def twin_names
-        representable_attrs.
-          find_all { |attr| attr[:twin] }.
-          collect { |attr| attr.name.to_sym }
+      def self.each(options={})
+        return representable_attrs[:definitions].values unless block_given?
+
+        definitions = representable_attrs
+
+        definitions.each do |dfn|
+          next if options[:exclude]    and options[:exclude].include?(dfn.name)
+          next if options[:scalar]     and dfn[:collection]
+          next if options[:collection] and ! dfn[:collection]
+          next if options[:twin]       and ! dfn[:twin]
+
+          yield dfn
+        end
+
+        definitions
       end
-    end
 
-    class Definition < Representable::Definition
-      def dynamic_options
-        super + [:twin]
+      def self.default_inline_class
+        Twin
+      end
+
+
+      class Options < ::Hash
+        def exclude!(names)
+          excludes.push(*names)
+          self
+        end
+
+        def excludes
+          self[:exclude] ||= []
+        end
       end
-    end
+    end # Decorator.
   end
 end

data/lib/disposable/twin/save.rb

@@ -1,43 +1,28 @@
-module Disposable
-  class Twin
-        # call save on all nested twins.
-    def self.pre_save_representer
-      representer = Class.new(write_representer)
-      representer.representable_attrs.
-        each { |attr| attr.merge!(
-          :representable => true,
-          :serialize => lambda do |twin, args|
-            processed = args.user_options[:processed_map]
-
-            twin.save(processed) unless processed[twin] # don't call save if it is already scheduled.
-          end
-        )}
-
-      representer
+class Disposable::Twin
+  module Save
+    # Returns the result of that save invocation on the model.
+    def save(options={}, &block)
+      res = sync(&block)
+      return res if block_given?
+
+      save!(options)
     end
 
+    def save!(options={})
+      result = save_model
 
-    # it's important to stress that #save is the only entry point where we hit the database after initialize.
-    def save(processed_map=ObjectMap.new) # use that in Reform::AR.
-      processed_map[self] = true
-
-      pre_save = self.class.pre_save_representer.new(self)
-      pre_save.to_hash(:include => pre_save.twin_names, :processed_map => processed_map) # #save on nested Twins.
+      schema.each(twin: true) do |dfn|
+        next if dfn[:save] == false
 
+        # call #save! on all nested twins.
+        PropertyProcessor.new(dfn, self).() { |twin| twin.save! }
+      end
 
+      result
+    end
 
-      # what we do right now
-      # call save on all nested twins - how does that work with dependencies (eg Album needs Song id)?
-      # extract all ORM attributes
-      # write to model
-
-      sync_attrs    = self.class.save_representer.new(self).to_hash
-      # puts "sync> #{sync_attrs.inspect}"
-      # this is ORM-specific:
-      model.update_attributes(sync_attrs) # this also does `album: #<Album>`
-
-      # FIXME: sync again, here, or just id?
-      self.id = model.id
+    def save_model
+      model.save
     end
   end
 end