disposable 0.1.9 → 0.1.11

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA1:
-  metadata.gz: 8921eb326e4ef806db082f3a43372b32b2e76fc8
-  data.tar.gz: 98ae84211f0b25a33ee0035237683d647d50a579
+  metadata.gz: 458a517ee02a889864487c957c7ca81d44b443d8
+  data.tar.gz: 3b491fa53805ca4f1c4540526d671310e0f34996
 SHA512:
-  metadata.gz: daad1b6f0cd51e44c4d57fad2960070bb14cf33bf13028f378151648b421b72c9c29c2dd57d3f9d47b5641b337b8dcbd22d599f35a264082f1de5a68a86035d2
-  data.tar.gz: 154096ab8f26fcacc523eb8569a7c0d73213b931a658e91492a51c947febc0282d114926ae32d892d2611b24dcedd1aafa039b9cf490abc75867adeb1a251edc
+  metadata.gz: 16d6c5a1231d4f85e5f42ab7d2ccac03ae9f2f3bc46a75ddb3f4b49260a7fff3814c2ab3e337a61d06e7733fd5c9d42f263c5f21b010457091864c3e1f8c2e03
+  data.tar.gz: 3b840942d484cff296d4495bda82eeb9268aff52565e8e385acf675152ffddc47b95d23b6ce6bc1da7015133a748de0654c4e50569ffc91a489d5e714c784ac4

data/CHANGES.md

@@ -1,3 +1,11 @@
+# 0.1.11
+
+* `:default` now accepts lambdas, too. Thanks to @johndagostino for implementing this.
+
+# 0.1.10
+
+* yanked.
+
 # 0.1.9
 
 * The `:twin` option is no longer evaluated at compile time, only inline twins are run through `::process_inline!`. This allows specifying twin classes in lambdas for lazy-loading, and recursive twins.

data/Gemfile

@@ -4,3 +4,4 @@ source 'https://rubygems.org'
 gemspec
 
  # gem 'representable', path: '../representable'
+# gem "uber", path: "../uber"

data/README.md

@@ -217,15 +217,14 @@ class AlbumTwin < Disposable::Twin
 
   property :title, default: "The Greatest Songs Ever Written"
   property :composer, default: Composer.new do
-    property :name
+    property :name, default: -> { "Object-#{id}" }
   end
 end
 ```
 
-Default value is applied when the model's getter returns `nil`.
-
-Note that `:default` also works with `:virtual` and `readable: false`.
+Default value is applied when the model's getter returns `nil` when _initializing_ the twin.
 
+Note that `:default` also works with `:virtual` and `readable: false`. `:default` can also be a lambda which is then executed in twin context.
 
 ## Collections
 

data/lib/disposable/twin/default.rb

@@ -7,6 +7,20 @@ module Disposable::Twin::Default
   end
 
   def default_for(dfn, options)
-    dfn[:default]
+    # TODO: introduce Null object in Declarative::Definition#[].
+    # dfn[:default].(self) # dfn#[] should return a Null object here if empty.
+    return unless dfn[:default]
+    dfn[:default].evaluate(self) # TODO: use .()
+  end
+
+  module ClassMethods
+    def property(name, options={}, &block)
+      options[:default] = Uber::Options::Value.new(options[:default]) if options[:default]
+      super
+    end
+  end
+
+  def self.included(includer)
+    includer.extend ClassMethods
   end
 end

data/lib/disposable/twin/schema.rb

@@ -1,31 +1,69 @@
-# TODO: this needs tests and should probably go to Representable. we can move tests from Reform for that.
+# Schema::from allows to copy a representer structure. This will create "fresh" inline representers instead
+# of inheriting/copying the original classes, making it a replication of the structure, only.
+#
+# Options allow to customize the copied representer.
+#
+# +:exclude+: ignore options from original Definition when copying.
+#
+# Provided block is run per newly created Definition.
+#   Schema.from(...) { |dfn| dfn[:readable] = true }
 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]
+  def self.from(*args, &block)
+    new.from(*args, &block)
+  end
+
+  # Builds a new representer (structure only) from source_class.
+  def from(source_class, options, &block) # TODO: can we re-use this for all the decorator logic in #validate, etc?
+    representer = build_representer(options)
 
     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)
+      dfn = build_definition!(options, dfn, representer, &block)
+      evaluate_block!(options, dfn, &block)
     end
 
     representer
   end
 
 private
-  def self.from_scalar!(options, dfn, new_options, representer)
+  def build_representer(options)
+    Class.new(options[:superclass]) do
+      include *options[:include]
+    end
+  end
+
+  def build_definition!(options, source_dfn, representer, &block)
+    local_options = source_dfn[options[:options_from]] || {} # e.g. deserializer: {..}.
+
+    new_options   = source_dfn.instance_variable_get(:@options).dup # copy original options.
+    exclude!(options, new_options)
+    new_options.merge!(local_options)
+
+    return from_scalar!(options, source_dfn, new_options, representer) if options[:recursive]==false
+    return from_scalar!(options, source_dfn, new_options, representer) unless source_dfn[:extend]
+    from_inline!(options, source_dfn, new_options, representer, &block)
+  end
+
+  def exclude!(options, dfn_options)
+    (options[:exclude_options] || []).each do |excluded|
+      dfn_options.delete(excluded)
+    end
+  end
+
+  def from_scalar!(options, dfn, new_options, representer)
     representer.property(dfn.name, new_options)
   end
 
-  def self.from_inline!(options, dfn, new_options, representer)
+  def from_inline!(options, dfn, new_options, representer, &block)
     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))
+    dfn_options = new_options.merge(extend: from(nested, options, &block))
 
     representer.property(dfn.name, dfn_options)
   end
+
+  def evaluate_block!(options, definition)
+    return unless block_given?
+    yield definition
+  end
 end

data/lib/disposable/twin/struct.rb

@@ -4,33 +4,18 @@
     #
     #   Twin.new(id: 1)
     module Struct
-      def setup_properties!(options={})
-        hash_representer.new(self).from_hash(@model.merge(options))
+      def read_value_for(dfn, options)
+        name = dfn.name
+        @model[name.to_s] || @model[name.to_sym] # TODO: test sym vs. str.
       end
 
-      def hash_representer
-        Class.new(schema) do
-          include Representable::Hash
-          include Representable::Hash::AllowSymbols
-
-          representable_attrs.each do |dfn|
-            dfn.merge!(
-              prepare:       lambda { |model, *| model },
-              instance:      lambda { |model, *| model }, # FIXME: this is because Representable thinks this is typed? in Deserializer.
-              representable: false,
-            ) if dfn[:twin]
-          end
-        end
-      end
-
-      def sync_hash_representer
-        hash_representer.clone.tap do |rpr|
-          rpr.representable_attrs.each do |dfn|
-            dfn.merge!(
-              serialize: lambda { |model, *| model.sync! },
-              representable: true
-            ) if dfn[:twin]
-          end
+      def sync_hash_representer # TODO: make this without representable, please.
+        Sync.hash_representer(self.class) do |dfn|
+          dfn.merge!(
+            prepare:       lambda { |model, *| model },
+            serialize: lambda { |model, *| model.sync! },
+            representable: true
+          ) if dfn[:twin]
         end
       end
 

data/lib/disposable/twin/sync.rb

@@ -5,6 +5,19 @@
 # Note: #sync currently implicitly saves AR objects with collections
 class Disposable::Twin
   module Sync
+    # Creates a fresh copy of the internal representer and adds Representable::Hash.
+    # This is used wherever a hash transformation is needed.
+    def self.hash_representer(twin_class, &block)
+      Schema.from(twin_class,
+        recursive: false,
+        representer_from: lambda { |twin_class| twin_class.representer_class },
+        superclass: Representable::Decorator,
+        include: Representable::Hash,
+        exclude_options: [:default], # TODO: TEST IN default_test.
+        &block
+      )
+    end
+
     def sync_models(options={})
       return yield to_nested_hash if block_given?
 
@@ -17,6 +30,8 @@ class Disposable::Twin
 
     # Sync all scalar attributes, call sync! on nested and return model.
     def sync!(options) # semi-public.
+      # TODO: merge this into Sync::Run or something and use in Struct, too, so we don't
+      # need the representer anymore?
       options_for_sync = sync_options(Decorator::Options[options])
 
       schema.each(options_for_sync) do |dfn|
@@ -58,24 +73,22 @@ class Disposable::Twin
       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.
-                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
+          @nested_hash_representer ||= build_nested_hash_representer
         end
+
+        def build_nested_hash_representer
+          Sync.hash_representer(self) do |dfn|
+            dfn.merge!(
+              readable: true, # the nested hash contains all fields.
+              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]
+          end
+        end # #build_nested_hash_representer
       end
     end
     include ToNestedHash

data/lib/disposable/version.rb

@@ -1,3 +1,3 @@
 module Disposable
-  VERSION = "0.1.9"
+  VERSION = "0.1.11"
 end

data/test/twin/default_test.rb

@@ -1,13 +1,14 @@
 require "test_helper"
 
 class DefaultTest < Minitest::Spec
-  Song     = Struct.new(:title, :composer)
+  Song     = Struct.new(:title, :genre, :composer)
   Composer = Struct.new(:name)
 
   class Twin < Disposable::Twin
     feature Default
 
-    property :title, default: "Mediocore"
+    property :title, default: "Medio-Core"
+    property :genre, default: -> { "Punk Rock #{model.class}" }
     property :composer, default: Composer.new do
       property :name, default: "NOFX"
     end
@@ -15,16 +16,18 @@ class DefaultTest < Minitest::Spec
 
   # all given.
   it do
-    twin = Twin.new(Song.new("Anarchy Camp", Composer.new("Nofx")))
+    twin = Twin.new(Song.new("Anarchy Camp", "Punk", Composer.new("Nofx")))
     twin.title.must_equal "Anarchy Camp"
+    twin.genre.must_equal "Punk"
     twin.composer.name.must_equal "Nofx"
   end
 
   # defaults, please.
   it do
     twin = Twin.new(Song.new)
-    twin.title.must_equal "Mediocore"
+    twin.title.must_equal "Medio-Core"
     twin.composer.name.must_equal "NOFX"
+    twin.genre.must_equal "Punk Rock DefaultTest::Song"
   end
 
   # false value is not defaulted.
@@ -87,4 +90,4 @@ class DefaultWithStructTest < Minitest::Spec
 
     song.settings.must_equal({"enabled"=>"yes", "roles"=>{"admin"=>"maybe"}})
   end
-end
+end

data/test/twin/process_inline_test.rb

@@ -27,9 +27,11 @@ class ProcessInlineTest < MiniTest::Spec
   end
 
   it do
-    twin = AlbumTwin.new(Album.new(Object, Object))
+    twin = AlbumTwin.new(Album.new(Object, Object, OpenStruct.new(composer: OpenStruct.new(composer: nil))))
     assert ! (twin.class < InlineTwin)
     assert   (twin.artist.class < InlineTwin)
     assert ! (twin.composer.class < InlineTwin)
+
+    twin.recursive_composer.composer.composer.must_equal nil
   end
 end

data/test/twin/schema_test.rb

@@ -66,6 +66,42 @@ class SchemaTest < MiniTest::Spec
     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
+
+
+  # :exclude_options allows skipping particular options when copying.
+  it do
+    decorator = Disposable::Twin::Schema.from(Representer, superclass: Representable::Decorator,
+      representer_from: lambda { |nested| nested },
+      exclude_options: [:deserializer]
+    )
+
+    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, :parse_filter=>[], :render_filter=>[], :as=>\"title\"}>"
+    decorator.representable_attrs.get(:songs).representer_module.representable_attrs.get(:name).inspect.must_equal "#<Representable::Definition ==>name @options={:as=>\"Name\", :parse_filter=>[], :render_filter=>[]}>"
+  end
+
+
+  it "::from with block allows customizing every definition and returns representer" do
+    decorator = Disposable::Twin::Schema.from(Representer,
+      superclass:       Representable::Decorator,
+      representer_from: lambda { |nested| nested },
+    ) { |dfn| dfn.merge!(amazing: true) }
+
+    decorator.representable_attrs.get(:id).inspect.must_equal "#<Representable::Definition ==>id @options={:parse_filter=>[], :render_filter=>[], :as=>\"id\", :amazing=>true}>"
+    decorator.representable_attrs.get(:songs).representer_module.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=>[], :amazing=>true}>"
+  end
+
+  it "recursive: false only copies first level" do
+    decorator = Disposable::Twin::Schema.from(Representer,
+      superclass:       Representable::Decorator,
+      representer_from: lambda { |nested| nested },
+      recursive: false,
+      exclude_options: [:deserializer]
+    )
+
+    decorator.representable_attrs.get(:title).inspect.must_equal "#<Representable::Definition ==>title @options={:writeable=>false, :parse_filter=>[], :render_filter=>[], :as=>\"title\"}>"
+    decorator.representable_attrs.get(:songs).representer_module.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=>[]}>"
+  end
 end
 
 

metadata

@@ -1,14 +1,14 @@
 --- !ruby/object:Gem::Specification
 name: disposable
 version: !ruby/object:Gem::Version
-  version: 0.1.9
+  version: 0.1.11
 platform: ruby
 authors:
 - Nick Sutterer
 autorequire: 
 bindir: bin
 cert_chain: []
-date: 2015-07-21 00:00:00.000000000 Z
+date: 2015-08-27 00:00:00.000000000 Z
 dependencies:
 - !ruby/object:Gem::Dependency
   name: uber
@@ -265,3 +265,4 @@ test_files:
 - test/twin/twin_test.rb
 - test/twin/virtual_test.rb
 - test/twin/writeable_test.rb
+has_rdoc: