nina 0.1.4 → 0.1.5

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA256:
-  metadata.gz: 2fa283d983d2df265fc4d74813c9abefb8f351c2582245d359a497514f4a61a5
-  data.tar.gz: 0e6ee2d867415efdec03f53d35be33a99ad202b4e2aa9f76ab9683b9657af999
+  metadata.gz: 6a252130b2ce26b317359fa4566edf12fba94042ddb9863fc8c71148a283c718
+  data.tar.gz: bb24fa2d53ef3ba45b921cc7a2af366b9e54cd2703681f0cd14210362fe5b473
 SHA512:
-  metadata.gz: 822d7360687494fefea19be97898eefa121c3aff71ba579d1030730b9a3b97e5409d6fe53990f43f2b175e132ff78a7184c79956e2545647aeaccd1c0a8c8c2a
-  data.tar.gz: fc42924b259b4c68ceca3e14b951ae45aadd61214b8ac7944294a283d183cd5bfedc6b4248287b55364e175ef9bfcb7fbfaad8e5c564a33fcbbc0acd9b851aaf
+  metadata.gz: fb97e0c1d28b7dc902366368f770dc3ed7c6f677dd98260dac0caa0a97c16a5d89a09ece6bac74125f7f3a266f4a98baa7a14ff72d163e331b1aa2cb206b0a25
+  data.tar.gz: fb26ae5dfac451918af68b16b3f45081559e2e546338fdf8eb0a4b48dcee0f79d4314b3d670b65ac066a472c96ae8c579686ae8f562546a71c2dc81d0bd43f99

data/Gemfile.lock

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

data/lib/nina/assembler.rb

@@ -1,28 +1,43 @@
 # frozen_string_literal: true
 
+require 'nina/builder/initialization'
+require 'nina/builder/callbacks'
+
 module Nina
   # Generates module that adds support for objects creation
   class Assembler
-    def initialize(abstract_factory)
+    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, initialization = {}, callbacks: nil, delegate: false)
+    def inject(build_order, delegate: false)
       build_order.each.with_index(-1).inject(nil) do |prev, (name, idx)|
         object = create_object(name, initialization)
-        Nina.def_accessor(build_order[idx], on: object, to: prev, delegate: delegate) if prev
-        callbacks[name].each { |c| c.call(object) } if callbacks&.key?(name)
+        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.factories[name].create if initialization[name].nil?
+      return @abstract_factory.create(name) if initialization.to_h[name].nil?
 
-      args, kwargs, block = initialization[name]
-      @abstract_factory.factories[name].create(*args, **kwargs, &block)
+      args, kwargs, block = initialization.to_h[name]
+      @abstract_factory.create(name, *args, **kwargs, &block)
     end
   end
 end

data/lib/nina/builder.rb

@@ -1,8 +1,5 @@
 # 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
@@ -42,42 +39,37 @@ module Nina
       @abstract_factory = abstract_factory.include(Toritori).extend(ClassMethods)
       @abstract_factory.class_eval(&def_block) if def_block
       @abstract_factory.build_order_list.freeze
-      @initialization = Initialization.new(@abstract_factory.factories.keys)
-      @assembler = Assembler.new(@abstract_factory)
-      @callbacks = callbacks
+      @assembler = Assembler.new(@abstract_factory, callbacks)
+      @assembler.add_observer(self)
+      @observers = []
+    end
+
+    def add_observer(observer)
+      @observers << observer
     end
 
     def copy
-      self.class.new(name, abstract_factory: abstract_factory)
+      new_builder = self.class.new(name, abstract_factory: abstract_factory, callbacks: @assembler.callbacks)
+      @observers.each { |observer| new_builder.add_observer(observer) }
+      new_builder
     end
 
     def with_callbacks(&block)
-      c = callbacks&.copy || Callbacks.new(abstract_factory.factories.keys)
-      yield c if block
+      yield @assembler.callbacks if block
 
-      self.class.new(name, abstract_factory: abstract_factory, callbacks: c)
+      copy
     end
 
     def wrap(delegate: false, &block)
-      yield @initialization if block
-
-      @assembler.inject(
-        @abstract_factory.build_order_list,
-        @initialization.to_h,
-        callbacks: callbacks.to_h,
-        delegate: delegate
-      )
+      yield @assembler.initialization if block
+
+      @assembler.inject(@abstract_factory.build_order_list, delegate: delegate)
     end
 
     def nest(delegate: false, &block)
-      yield @initialization if block
-
-      @assembler.inject(
-        @abstract_factory.build_order_list.reverse,
-        @initialization.to_h,
-        callbacks: callbacks.to_h,
-        delegate: delegate
-      )
+      yield @assembler.initialization if block
+
+      @assembler.inject(@abstract_factory.build_order_list.reverse, delegate: delegate)
     end
 
     def subclass(&def_block)
@@ -86,8 +78,13 @@ module Nina
       @abstract_factory = Class.new(abstract_factory)
       @abstract_factory.class_eval(&def_block)
       @abstract_factory.build_order_list.freeze
-      @initialization = Initialization.new(@abstract_factory.factories.keys)
-      @assembler = Assembler.new(@abstract_factory)
+      @assembler = Assembler.new(@abstract_factory, @assembler.callbacks)
+    end
+
+    def update(name, object)
+      @observers.each do |observer|
+        observer.public_send(:"on_#{name}_created", object) if observer.respond_to?(:"on_#{name}_created")
+      end
     end
   end
 end

data/lib/nina/version.rb

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

data/lib/nina.rb

@@ -1,6 +1,7 @@
 # frozen_string_literal: true
 
 require 'toritori'
+require 'observer'
 require 'nina/assembler'
 require 'nina/builder'
 
@@ -34,7 +35,7 @@ module Nina
   # Adds ability to delegeate methods via method_missing
   module MethodMissingDelegation
     def method_missing(name, *attrs, **kwargs, &block)
-      if (prev = predecessors.detect { |o| o.public_methods.include?(name) })
+      if (prev = predecessors.lazy.detect { |o| o.public_methods.include?(name) })
         prev.public_send(name, *attrs, **kwargs, &block)
       else
         super
@@ -42,15 +43,13 @@ module Nina
     end
 
     def respond_to_missing?(method_name, _include_private = false)
-      public_methods.detect { |m| m == :predecessor_name } || super
+      public_methods.detect { |m| m == :predecessor } || super
     end
 
     def predecessors
-      @predecessors ||= begin
+      Enumerator.new do |y|
         obj = self
-        [].tap do |list|
-          list << obj = obj.public_send(obj.predecessor_name) while obj.methods.detect { |m| m == :predecessor_name }
-        end
+        y << obj = obj.predecessor while obj.methods.detect { |m| m == :predecessor }
       end
     end
   end
@@ -61,9 +60,9 @@ module Nina
 
   def self.def_accessor(accessor, on:, to:, delegate: false)
     on.define_singleton_method(accessor) { to }
+    on.define_singleton_method(:predecessor) { to }
     return unless delegate
 
-    on.define_singleton_method(:predecessor_name) { accessor }
     on.extend(MethodMissingDelegation)
   end
 

metadata

@@ -1,14 +1,14 @@
 --- !ruby/object:Gem::Specification
 name: nina
 version: !ruby/object:Gem::Version
-  version: 0.1.4
+  version: 0.1.5
 platform: ruby
 authors:
 - Andrii Baran
 autorequire:
 bindir: exe
 cert_chain: []
-date: 2024-01-01 00:00:00.000000000 Z
+date: 2024-01-02 00:00:00.000000000 Z
 dependencies:
 - !ruby/object:Gem::Dependency
   name: toritori