nina 0.1.6 → 0.2.1

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA256:
-  metadata.gz: 499160b10c559f3a32fbcb92befd4f3986ca7e6fda2af05d0b5d8cfc21a5036a
-  data.tar.gz: e21824691f8e19b9c9cfa87e3396a3d23afafe658a7824db5eb9988345c75c01
+  metadata.gz: 2552f792c064a8dc7fc6916b07f0741d696916f7b844bb0fb12db6f6db083680
+  data.tar.gz: 489c9ad648b20a0e2b48704dc87350011682b1f905354681a85cfb24e6217cbc
 SHA512:
-  metadata.gz: 6af4a721285ec85a8923cc184b84333bc45ffc5f4f2febab9bceacf43c3447c5a6bf2e069176da21f9a7b1e52315dd89dfef96b8b48dfe46cd87a56d94deaa4a
-  data.tar.gz: 72067d8447bf2cf390867882089aa9680f41c6e0a2e8ba2faf202d58433fce9da1564f4ea16bd6b36fefc584b885af06968d94f18eaa643a260323bca5f8a602
+  metadata.gz: cf06ff35a6512ed258d44e589b8015f09c28ffaa22eacca7cc162ef5cb623566f4cf72d38a13d651bb599f9407555847a0a001cf79d00235169f5664259e3060
+  data.tar.gz: 34b5f8ea7925272bcf9f4edd7b8ef4fe1221dbc27cc6e261ce283806dc87c58d290325976cfe6d059b5f334a6f27c5d5ae16bf9e6ebd3cc80e9b904ffd1bf30e

data/Gemfile.lock

@@ -1,7 +1,7 @@
 PATH
   remote: .
   specs:
-    nina (0.1.6)
+    nina (0.2.1)
       toritori (= 0.2.1)
 
 GEM

data/README.md

@@ -65,22 +65,41 @@ Lets explore what we have as a result
 ```ruby
 # Wrapping strategy
 builder = abstract_factory.main_builder
-instance = builder.wrap
+instance = builder.wrap do |build|
+  # This block controlls order of building process steps
+  # Allows you to provide initialization attributes
+  # And specify only things you need to be added
+  build.params                  # The most nested object;
+  q = build.query               # query will get a reader to params
+  build.command if i_need_this? # Top level object; command will get a reader to query
+  build.query == q              # memoization do not allow creation of objects multiple times
+  build.query(1, 2, 3)          # instead it returns first object no matter what parameters you provided later
+end
 instance # => #<Command>
 instance.query # => #<Query>
 instance.query.params # => #<Params>
 
 # Nesting strategy
 builder = abstract_factory.secondary_builder
-instance = builder.nest
+instance = builder.nest do |build|
+  build.params  # Top level object
+  build.query   # query will get a reader to params
+  build.command # The most nested object; query will get a reader to command
+end
 instance # => #<A>
 instance.query # => #<B>
 instance.query.command # => #<C>
 ```
-We may apply delegation techique from OOD to hide deeper layers of resulted object
+
+### Delegation
+We may apply delegation techique from OOD to expose methods of deeper layers
 ```ruby
 builder = abstract_factory.secondary_builder
-instance = builder.nest(delegate: true)
+instance = builder.nest(delegate: true) do |build|
+  build.params
+  build.query
+  build.command
+end
 instance.a # => nil
 instance.b # => nil
 instance.c # => nil
@@ -89,6 +108,7 @@ instance.query.c # => nil
 If you need provide an initalization parameters for the objects
 ```ruby
 instance = builder.wrap(delegate: true) do |b|
+  # b.params(1, 2) => ArgumentError
   b.params(1)
   b.query(2)
   b.command(3)
@@ -97,6 +117,21 @@ instance.a # => 1
 instance.b # => 2
 instance.c # => 3
 ```
+
+### Top level API
+If you have some objects and just want to link them you can use following methods
+```ruby
+setup = { params: params, query: query, command: command }
+Nina.link(setup, delegate: true) do |name, object| # => params.query.command
+  # optionally do something
+end
+
+Nina.reverse_link(setup, delegate: false) do |name, object| # => command.query.params
+  # optionally do something
+end
+```
+
+### Callbacks
 To do something between stages (after creation of object)
 ```ruby
 builder_with_callbacks = builder.with_callbacks do |c|

data/lib/nina/builder/callbacks.rb

@@ -3,7 +3,12 @@
 module Nina
   class Builder
     # Utility to get user defined callbacks
-    class Callbacks < Initialization
+    class Callbacks
+      def initialize(allow_list, atts = {})
+        @allow_list = allow_list
+        @atts = atts
+      end
+
       def copy
         Callbacks.new(@allow_list, to_h.dup)
       end
@@ -19,6 +24,10 @@ module Nina
       def respond_to_missing?(method, include_private = false)
         super
       end
+
+      def to_h
+        @atts
+      end
     end
   end
 end

data/lib/nina/builder/initialization.rb

@@ -4,25 +4,26 @@ module Nina
   class Builder
     # A way to call methods from initalization proc on base_class
     class Initialization < BasicObject
-      attr_reader :allow_list
-
-      def initialize(allow_list, atts = {})
-        @allow_list = allow_list
-        @atts = atts
+      def initialize(builder)
+        @builder = builder
+        @abstract_factory = builder.abstract_factory
+        @allow_list = @abstract_factory.factories.keys
+        @atts = {}
       end
 
       def method_missing(method, *args, **kwargs, &block)
         return super unless @allow_list.include?(method)
 
-        @atts[method] = [args, kwargs, block]
+        @atts[method] ||= @abstract_factory.create(method, *args, **kwargs, &block)
+                                           .tap { |o| @builder.send(:update, method, o) }
       end
 
-      def respond_to_missing?(method, include_private = false)
-        @allow_list.include?(method) || super
+      def respond_to_missing?(method, _include_private = false)
+        @allow_list.include?(method)
       end
 
       def to_h
-        @atts
+        @atts.dup
       end
     end
   end

data/lib/nina/builder.rb

@@ -1,5 +1,8 @@
 # frozen_string_literal: true
 
+require 'nina/builder/initialization'
+require 'nina/builder/callbacks'
+
 # This should be a kind of factory that creates complex objects
 # from simple ones. It should use torirori to create objects.
 # It also enriches objects with some methods that make them more
@@ -11,21 +14,7 @@ module Nina
 
     # Definaes support methods and variables for concrete builder
     module ClassMethods
-      def build_order_list
-        @build_order_list ||= []
-      end
-
-      def build_order_list=(other)
-        @build_order_list = other.dup.freeze
-      end
-
-      def inherited(subclass)
-        super
-        subclass.build_order_list = build_order_list.dup.freeze
-      end
-
       def factory(name, *args, **kwargs, &block)
-        build_order_list << name
         super
         define_singleton_method(name) do |klass = nil, &definition|
           factories[__method__].subclass(produces: klass, &definition)
@@ -38,9 +27,8 @@ module Nina
       @def_block = def_block
       @abstract_factory = abstract_factory.include(Toritori).extend(ClassMethods)
       @abstract_factory.class_eval(&def_block) if def_block
-      @abstract_factory.build_order_list.freeze
-      @assembler = Assembler.new(@abstract_factory, callbacks)
-      @assembler.add_observer(self)
+      @initialization = Builder::Initialization.new(self)
+      @callbacks = callbacks&.copy || Callbacks.new(@abstract_factory.factories.keys)
       @observers = []
     end
 
@@ -49,27 +37,29 @@ module Nina
     end
 
     def copy
-      new_builder = self.class.new(name, abstract_factory: abstract_factory, callbacks: @assembler.callbacks)
+      new_builder = self.class.new(name, abstract_factory: abstract_factory, callbacks: @callbacks)
       @observers.each { |observer| new_builder.add_observer(observer) }
       new_builder
     end
 
     def with_callbacks(&block)
-      yield @assembler.callbacks if block
+      yield @callbacks if block
 
       copy
     end
 
-    def wrap(delegate: false, &block)
-      yield @assembler.initialization if block
+    def nest(delegate: false, &block)
+      initialization = Builder::Initialization.new(self)
+      yield initialization if block
 
-      @assembler.inject(@abstract_factory.build_order_list, delegate: delegate)
+      Nina.link(initialization.to_h, delegate: delegate)
     end
 
-    def nest(delegate: false, &block)
-      yield @assembler.initialization if block
+    def wrap(delegate: false, &block)
+      initialization = Builder::Initialization.new(self)
+      yield initialization if block
 
-      @assembler.inject(@abstract_factory.build_order_list.reverse, delegate: delegate)
+      Nina.reverse_link(initialization.to_h, delegate: delegate)
     end
 
     def subclass(&def_block)
@@ -77,12 +67,19 @@ module Nina
 
       @abstract_factory = Class.new(abstract_factory)
       @abstract_factory.class_eval(&def_block)
-      @abstract_factory.build_order_list.freeze
-      @assembler = Assembler.new(@abstract_factory, @assembler.callbacks)
-      @assembler.add_observer(self)
+      @callbacks = callbacks&.copy || Callbacks.new(@abstract_factory.build_order_list)
+    end
+
+    private
+
+    def callbacks_for(name)
+      return [] unless @callbacks
+
+      @callbacks.to_h.fetch(name, [])
     end
 
     def update(name, object)
+      callbacks_for(name).each { |c| c.call(object) }
       @observers.each do |observer|
         observer.public_send(:"on_#{name}_created", object, @name) if observer.respond_to?(:"on_#{name}_created")
       end

data/lib/nina/version.rb

@@ -1,5 +1,5 @@
 # frozen_string_literal: true
 
 module Nina
-  VERSION = '0.1.6'
+  VERSION = '0.2.1'
 end

data/lib/nina.rb

@@ -1,8 +1,6 @@
 # frozen_string_literal: true
 
 require 'toritori'
-require 'observer'
-require 'nina/assembler'
 require 'nina/builder'
 
 require_relative 'nina/version'
@@ -51,7 +49,7 @@ module Nina
     receiver.extend ClassMethods
   end
 
-  def self.def_accessor(accessor, on:, to:, delegate: false)
+  def self.def_reader(accessor, on:, to:, delegate: false)
     on.define_singleton_method(accessor) { to }
     on.define_singleton_method(:predecessor) { to }
     def on.predecessors
@@ -65,10 +63,20 @@ module Nina
     on.extend(MethodMissingDelegation)
   end
 
-  def self.linked_list(build_config, delegate: false)
-    build_order = build_config.keys
-    build_config.each.with_index(-1).inject(nil) do |prev, ((_, object), idx)|
-      Nina.def_accessor(build_order[idx], on: object, to: prev, delegate: delegate) if prev
+  def self.link(build, delegate: false, &block)
+    result = nil
+    build.each.inject(nil) do |prev, (name, object)|
+      Nina.def_reader(name, on: prev, to: object, delegate: delegate) if prev
+      yield(name, object) if block
+      object.tap { |o| result ||= o }
+    end
+    result
+  end
+
+  def self.reverse_link(build, delegate: false, &block)
+    build.each.with_index(-1).inject(nil) do |prev, ((name, object), idx)|
+      Nina.def_reader(build.keys[idx], on: object, to: prev, delegate: delegate) if prev
+      yield(name, object) if block
       object
     end
   end

metadata

@@ -1,14 +1,14 @@
 --- !ruby/object:Gem::Specification
 name: nina
 version: !ruby/object:Gem::Version
-  version: 0.1.6
+  version: 0.2.1
 platform: ruby
 authors:
 - Andrii Baran
 autorequire:
 bindir: exe
 cert_chain: []
-date: 2024-01-03 00:00:00.000000000 Z
+date: 2024-02-01 00:00:00.000000000 Z
 dependencies:
 - !ruby/object:Gem::Dependency
   name: toritori
@@ -41,7 +41,6 @@ files:
 - README.md
 - Rakefile
 - lib/nina.rb
-- lib/nina/assembler.rb
 - lib/nina/builder.rb
 - lib/nina/builder/callbacks.rb
 - lib/nina/builder/initialization.rb

data/lib/nina/assembler.rb

@@ -1,43 +0,0 @@
-# frozen_string_literal: true
-
-require 'nina/builder/initialization'
-require 'nina/builder/callbacks'
-
-module Nina
-  # Generates module that adds support for objects creation
-  class Assembler
-    include Observable
-
-    attr_reader :initialization, :callbacks
-
-    def initialize(abstract_factory, callbacks = nil)
-      @abstract_factory = abstract_factory
-      @initialization = Builder::Initialization.new(@abstract_factory.build_order_list)
-      @callbacks = callbacks&.copy || Builder::Callbacks.new(@abstract_factory.build_order_list)
-    end
-
-    def inject(build_order, delegate: false)
-      build_order.each.with_index(-1).inject(nil) do |prev, (name, idx)|
-        object = create_object(name, initialization)
-        setup_relation(object, prev, name, build_order[idx], delegate)
-        changed
-        notify_observers(name, object)
-        object
-      end
-    end
-
-    private
-
-    def setup_relation(object, prev, name, accessor, delegate)
-      Nina.def_accessor(accessor, on: object, to: prev, delegate: delegate) if prev
-      callbacks.to_h[name].each { |c| c.call(object) } if callbacks&.to_h&.key?(name)
-    end
-
-    def create_object(name, initialization = {})
-      return @abstract_factory.create(name) if initialization.to_h[name].nil?
-
-      args, kwargs, block = initialization.to_h[name]
-      @abstract_factory.create(name, *args, **kwargs, &block)
-    end
-  end
-end