nina 0.1.5 → 0.2.0

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA256:
-  metadata.gz: 6a252130b2ce26b317359fa4566edf12fba94042ddb9863fc8c71148a283c718
-  data.tar.gz: bb24fa2d53ef3ba45b921cc7a2af366b9e54cd2703681f0cd14210362fe5b473
+  metadata.gz: 3d790033be42c95566d03b89e7e39e58f877b2d17e1aa665f9a83696bdeaeed3
+  data.tar.gz: 807a021192f39f110b36fdcebfc68516d1c32ee9d3a3cffbf80bce8dbacdec1b
 SHA512:
-  metadata.gz: fb97e0c1d28b7dc902366368f770dc3ed7c6f677dd98260dac0caa0a97c16a5d89a09ece6bac74125f7f3a266f4a98baa7a14ff72d163e331b1aa2cb206b0a25
-  data.tar.gz: fb26ae5dfac451918af68b16b3f45081559e2e546338fdf8eb0a4b48dcee0f79d4314b3d670b65ac066a472c96ae8c579686ae8f562546a71c2dc81d0bd43f99
+  metadata.gz: f8cb2f5c4e4eb44b3317892d9cfecdd2b6bdacfd190996222515351d68cbccf738e173773b3c36eef8ae65091ffb2944b0ac6c9a40dc6606eb0db4c18b272246
+  data.tar.gz: 320bbb01e2fda05a36633ab5cbfbe0ae63a305e2a5de4c651adadcb41fbfb730b38c11a2508349969507d94a98c41eb9f29b4322a6775ae4b353ad4423f2ff62

data/Gemfile.lock

@@ -1,7 +1,7 @@
 PATH
   remote: .
   specs:
-    nina (0.1.5)
+    nina (0.2.0)
       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,27 @@ 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)
+      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)
+      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,13 +65,22 @@ 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)
+      @initialization = Builder::Initialization.new(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) if observer.respond_to?(:"on_#{name}_created")
+        observer.public_send(:"on_#{name}_created", object, @name) if observer.respond_to?(:"on_#{name}_created")
       end
     end
   end

data/lib/nina/version.rb

@@ -1,5 +1,5 @@
 # frozen_string_literal: true
 
 module Nina
-  VERSION = '0.1.5'
+  VERSION = '0.2.0'
 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'
@@ -45,31 +43,40 @@ module Nina
     def respond_to_missing?(method_name, _include_private = false)
       public_methods.detect { |m| m == :predecessor } || super
     end
-
-    def predecessors
-      Enumerator.new do |y|
-        obj = self
-        y << obj = obj.predecessor while obj.methods.detect { |m| m == :predecessor }
-      end
-    end
   end
 
   def self.included(receiver)
     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
+      Enumerator.new do |y|
+        obj = self
+        y << obj = obj.predecessor while obj.methods.detect { |m| m == :predecessor }
+      end
+    end
     return unless delegate
 
     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.5
+  version: 0.2.0
 platform: ruby
 authors:
 - Andrii Baran
 autorequire:
 bindir: exe
 cert_chain: []
-date: 2024-01-02 00:00:00.000000000 Z
+date: 2024-01-15 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