hospodar 1.0.0

data/lib/hospodar/builder/instantiation_error.rb

@@ -0,0 +1,24 @@
+# frozen_string_literal: true
+
+module Hospodar
+  module Builder
+    # Error for signaling creating error
+    class InstantiationError < StandardError
+      attr_reader :init_attrs, :step_id
+
+      def initialize(id, init_attrs)
+        @init_attrs = init_attrs
+        @step_id = id
+        super(error_message)
+      end
+
+      private
+
+      def error_message
+        msg = "Can't create an instance of #{step_id} class"
+        msg += "with the folloving attributes: #{init_attrs}" unless init_attrs.empty?
+        msg
+      end
+    end
+  end
+end

data/lib/hospodar/builder/nested.rb

@@ -0,0 +1,18 @@
+# frozen_string_literal: true
+
+module Hospodar
+  module Builder
+    # Implements nest(&block) strategy in schemas
+    class Nested < Wrapped
+      def on_planing(receiver)
+        execution_plan(receiver, reverse: true, &dsl_block)
+      end
+
+      private
+
+      def type
+        :nested
+      end
+    end
+  end
+end

data/lib/hospodar/builder/proxy.rb

@@ -0,0 +1,34 @@
+# frozen_string_literal: true
+
+module Hospodar
+  module Builder
+    # User accessible objects for firing up building process
+    class Proxy
+      def initialize(target)
+        @target = target
+        @condition = {}
+      end
+
+      def call
+        return @target.call if @condition.empty?
+
+        type, block = @condition.to_a.first
+        @target.call(type, &block)
+      end
+
+      def do_while(&block)
+        return if @condition.one?
+
+        @condition[:do_while] = block
+        self
+      end
+
+      def do_until(&block)
+        return if @condition.one?
+
+        @condition[:do_until] = block
+        self
+      end
+    end
+  end
+end

data/lib/hospodar/builder/strategies/enumerate.rb

@@ -0,0 +1,26 @@
+# frozen_string_literal: true
+
+module Hospodar
+  module Builder
+    module Strategies
+      # Does final steps after completing building process for nested structures
+      class Enumerate < Execute
+        attr_reader :delegate
+
+        def initialize(strategy, target, factory, delegate)
+          super(strategy, target, factory)
+          @delegate = delegate
+        end
+
+        private
+
+        def prepare_top
+          return target if strategy.object.nil?
+
+          Hospodar::Builder.def_accessor(strategy.last_step, on: target, to: strategy.object, delegate: delegate)
+          target
+        end
+      end
+    end
+  end
+end

data/lib/hospodar/builder/strategies/execute.rb

@@ -0,0 +1,76 @@
+# frozen_string_literal: true
+
+module Hospodar
+  module Builder
+    module Strategies
+      # Runs building process
+      class Execute
+        attr_reader :strategy, :target, :factory
+
+        def initialize(strategy, target, factory)
+          @strategy = strategy
+          @target = target
+          @factory = factory
+        end
+
+        def call(type = nil, &block)
+          run_with_error_handling { process(type, &block) }
+          prepare_top
+        end
+
+        private
+
+        def process(type = nil, &block)
+          build_plan.take_while do |object, id|
+            next true unless block
+
+            run_build_step(object, id, type, &block)
+          end
+        end
+
+        def run_build_step(object, id, type)
+          run_with_error_handling(return_value: false) do
+            res = yield(object, id)
+            type == :do_while ? res : !res
+          end
+        end
+
+        def run_with_error_handling(return_value: nil)
+          yield
+        rescue StandardError => e
+          handle_exception(e)
+          return_value
+        end
+
+        def build_plan
+          @build_plan ||= strategy.call
+        end
+
+        def handle_exception(exc)
+          target.on_exception ||= factory.on_exception
+          target.exception = wrap_error(exc)
+          exetute_exception_strategy(target.exception, target.on_exception, target)
+        end
+
+        def wrap_error(exc)
+          return exc if exc.is_a?(Hospodar::Builder::InstantiationError)
+
+          Hospodar::Builder.create_error(exc, strategy.step_id)
+        end
+
+        def exetute_exception_strategy(exc, on_exception, target)
+          case on_exception
+          when Proc
+            on_exception.call(exc, target)
+          when :raise
+            raise(exc)
+          end
+        end
+
+        def prepare_top
+          target
+        end
+      end
+    end
+  end
+end

data/lib/hospodar/builder/strategies/init.rb

@@ -0,0 +1,55 @@
+# frozen_string_literal: true
+
+module Hospodar
+  module Builder
+    module Strategies
+      # Creates objects for nest and wrap strategies
+      class Init
+        attr_reader :strategy, :pipe, :target
+
+        def initialize(strategy, pipe, target)
+          @strategy = strategy
+          @pipe = pipe
+          @target = target
+        end
+
+        def call
+          Enumerator.new do |yielder|
+            instantiate_objects(yielder)
+          end.lazy
+        end
+
+        private
+
+        def instantiate_objects(yielder)
+          pipe.each do |title, init_proc, id|
+            object = create_object(init_proc, id)
+            next if object.nil? && target.ignore_exceptions?
+
+            yielder << [title, create_object(init_proc, id), id]
+          end
+        end
+
+        def create_object(init_proc, id)
+          init_proc.call(*init_attrs_for(id))
+        rescue StandardError => e
+          handle_exception(e, id, init_attrs_for(id))
+        end
+
+        def init_attrs_for(id)
+          Array(init_params[id.to_sym])
+        end
+
+        def init_params
+          @init_params ||= strategy.call
+        end
+
+        def handle_exception(exc, id, init_attrs)
+          exception = Hospodar::Builder.create_init_error(exc, id, init_attrs)
+          target.exception = exception
+          raise exception unless target.ignore_exceptions?
+        end
+      end
+    end
+  end
+end

data/lib/hospodar/builder/strategies/inject.rb

@@ -0,0 +1,35 @@
+# frozen_string_literal: true
+
+module Hospodar
+  module Builder
+    module Strategies
+      # Allows user to pass parameters for creating new objects via method calls
+      class Inject
+        # User use it as configuration DSL for builder
+        class Builder
+          attr_reader :__result__, :__methods_allowlist__
+
+          def initialize(list)
+            @__result__ = {}
+            @__methods_allowlist__ = list
+            list.each do |method_name|
+              define_singleton_method(method_name) do |*attrs|
+                @__result__[method_name] = attrs
+              end
+            end
+          end
+        end
+
+        def initialize(list, &block)
+          @builder = Builder.new(list.map(&:to_sym))
+          @block = block
+        end
+
+        def call
+          @block&.call(@builder)
+          @builder.__result__
+        end
+      end
+    end
+  end
+end

data/lib/hospodar/builder/strategies/link.rb

@@ -0,0 +1,31 @@
+# frozen_string_literal: true
+
+module Hospodar
+  module Builder
+    module Strategies
+      Link = Struct.new(:strategy, :delegate) do
+        attr_reader :object, :step_id
+
+        def call
+          Enumerator.new do |yielder|
+            strategy.call.inject(nil) do |object, (title, layer_object, id)|
+              @object = layer_object
+              @step_id = id
+              if title.nil?
+                yielder << [layer_object, id]
+                next layer_object
+              end
+              Hospodar::Builder.def_accessor(title, on: layer_object, to: object, delegate: delegate)
+              yielder << [layer_object, id]
+              layer_object
+            end
+          end
+        end
+
+        def last_step
+          step_id.title
+        end
+      end
+    end
+  end
+end

data/lib/hospodar/builder/strategies/mount.rb

@@ -0,0 +1,56 @@
+# frozen_string_literal: true
+
+module Hospodar
+  module Builder
+    module Strategies
+      # Creates objects and provides readers on target objects
+      class Mount
+        attr_reader :strategy, :pipe, :target, :step, :object, :step_id
+
+        def initialize(strategy, pipe, target, step)
+          @strategy = strategy
+          @pipe = pipe
+          @target = target
+          @step = step
+        end
+
+        def call
+          Enumerator.new do |yielder|
+            instantiate_objects(yielder)
+          end
+        end
+
+        def instantiate_objects(yielder)
+          pipe.each do |id, init_proc|
+            @step_id = id
+            object = create_object(init_proc, id)
+            next if object.nil? && target.ignore_exceptions?
+
+            target.define_singleton_method(id.title.to_sym) { object }
+            yielder << [object, id]
+          end
+        end
+
+        def create_object(init_proc, id)
+          init_proc.call(*init_attrs_for(id))
+        rescue StandardError => e
+          handle_exception(e, id, init_attrs_for(id))
+        end
+
+        def init_attrs_for(id)
+          Array(init_params[id.to_sym])
+        end
+
+        def init_params
+          @init_params ||= strategy.call
+        end
+
+        def handle_exception(exc, id, init_attrs)
+          exception = Hospodar::Builder.create_init_error(exc, id, init_attrs)
+          target.exception = exception
+          raise exception unless target.ignore_exceptions?
+        end
+      end
+    end
+  end
+end

data/lib/hospodar/builder/strategies/translate.rb

@@ -0,0 +1,60 @@
+# frozen_string_literal: true
+
+module Hospodar
+  module Builder
+    module Strategies
+      # Singleton for parsing schemas
+      module Translate
+        # Collects method calls in a given block
+        Tracer = Struct.new(:yielder) do
+          def method_missing(method_name, *attrs)
+            yielder << [method_name, attrs.first]
+          end
+
+          def respond_to_missing?
+            true
+          end
+        end
+
+        ID_CLASS = Hospodar::Builder::Id
+
+        ExecutionPlanMatrix = Struct.new(:collection) do
+          def with_creation_procs(factory)
+            self.collection = collection.map do |group, title|
+              [group, title, factory.mother_ship_assembler_new_instance(group, title)]
+            end
+            self
+          end
+
+          def to_nested_form(builder_params)
+            data = collection
+            data.unshift(builder_params.to_a) unless builder_params.object.nil?
+            intermediate_form = data.transpose
+            tobe_assembled = intermediate_form[1..-1]
+            keys = intermediate_form[0..1].transpose.map { |g, e| ID_CLASS.new(g, e) }
+            tobe_assembled.first.pop
+            tobe_assembled.first.unshift(nil)
+            tobe_assembled << keys
+            self.collection = tobe_assembled.transpose
+            self
+          end
+        end
+
+        class << self
+          def call(reverse: false, &block)
+            enum = trace(&block)
+            return ExecutionPlanMatrix.new(enum) unless reverse
+
+            ExecutionPlanMatrix.new(enum.reverse)
+          end
+
+          private
+
+          def trace(&block)
+            Tracer.new([]).tap { |tracer| tracer.instance_eval(&block) }.yielder
+          end
+        end
+      end
+    end
+  end
+end

data/lib/hospodar/builder/wrapped.rb

@@ -0,0 +1,40 @@
+# frozen_string_literal: true
+
+module Hospodar
+  module Builder
+    # Implements wrap(&block) strategy in schemas
+    class Wrapped < Assembler
+      def initialize(factory, on_exception, delegate)
+        super(factory, on_exception)
+        @delegate = delegate
+      end
+
+      def on_planing(receiver)
+        execution_plan(receiver, &dsl_block)
+      end
+
+      def on_building(receiver, plan, &on_create)
+        building_steps(receiver, plan, &on_create)
+      end
+
+      private
+
+      attr_reader :delegate
+
+      def type
+        :wrapped
+      end
+
+      def execution_plan(receiver, reverse: false)
+        creation_matrix_from_dsl(receiver, reverse: reverse, &dsl_block).to_nested_form(builder_params).collection
+      end
+
+      def building_steps(receiver, plan, &on_create)
+        inject = Strategies::Inject.new(plan.map(&:last), &on_create)
+        init = Strategies::Init.new(inject, plan, target)
+        link = Strategies::Link.new(init, delegate)
+        Strategies::Enumerate.new(link, target, receiver, delegate)
+      end
+    end
+  end
+end

data/lib/hospodar/builder.rb

@@ -0,0 +1,113 @@
+# frozen_string_literal: true
+
+require 'hospodar/builder/id'
+require 'hospodar/builder/proxy'
+require 'hospodar/builder/assembler'
+require 'hospodar/builder/flatten'
+require 'hospodar/builder/wrapped'
+require 'hospodar/builder/nested'
+require 'hospodar/builder/helpers'
+require 'hospodar/builder/instantiation_error'
+require 'hospodar/builder/error'
+require 'hospodar/builder/exeptional'
+
+module Hospodar
+  # Introduces possibilty to build complex objects by schema
+  module Builder
+    # Handles method delegation
+    module MethodMissingDelegation
+      def method_missing(name, *attrs, &block)
+        return super unless methods.detect { |m| m == :ms_predecessor }
+
+        public_send(ms_predecessor).public_send(name, *attrs, &block)
+      end
+
+      def respond_to_missing?(method_name, _include_private = false)
+        return super unless methods.detect { |m| m == :ms_predecessor }
+
+        public_send(ms_predecessor).respond_to?(method_name)
+      end
+    end
+
+    private_constant :Assembler
+    private_constant :Proxy
+    private_constant :Helpers
+    private_constant :Exceptional
+    private_constant :Strategies
+    private_constant :MethodMissingDelegation
+
+    class Error < StandardError; end
+
+    def self.create_init_error(exc, id, init_attrs)
+      new_error = InstantiationError.new(id, init_attrs)
+      new_error.set_backtrace(exc.backtrace)
+      new_error
+    end
+
+    def self.create_error(exc, id)
+      new_error = Error.new(exc.message, id)
+      new_error.set_backtrace(exc.backtrace)
+      new_error
+    end
+
+    def self.def_accessor(accessor, on:, to:, delegate: false)
+      on.define_singleton_method(:ms_predecessor) { accessor }
+      on.define_singleton_method(accessor) { to }
+      on.extend(MethodMissingDelegation) if delegate
+    end
+
+    # DSL for describing objects schemas
+    module ClassMethods
+      class << self
+        attr_accessor :__mf_assembler_name__
+      end
+
+      def self.included(receiver)
+        receiver.extend self
+      end
+
+      def self.extended(receiver)
+        receiver.produces :flatten_structs, :wrapped_structs, :nested_structs
+        receiver.extend Helpers
+      end
+
+      def wrap(title, base_class: Class.new(Object), init: nil, delegate: false, on_exception: nil, &block)
+        wrapped_struct(title, base_class: base_class.include(Exceptional), init: init)
+        class_eval(&block)
+        Wrapped.new(self, on_exception, delegate).for(title, &block).inject_method
+      end
+
+      def nest(title, base_class: Class.new(Object), init: nil, delegate: false, on_exception: nil, &block)
+        nested_struct(title, base_class: base_class.include(Exceptional), init: init)
+        class_eval(&block)
+        Nested.new(self, on_exception, delegate).for(title, &block).inject_method
+      end
+
+      def flat(title, base_class: Class.new(Object), init: nil, on_exception: nil, &block)
+        flatten_struct(title, base_class: base_class.include(Exceptional), init: init)
+        class_eval(&block)
+        Flatten.new(self, on_exception).for(title, &block).inject_method
+      end
+
+      def on_exception(&block)
+        block ? @on_exception = block : @on_exception
+      end
+    end
+
+    # Copies on_exception callback definition to subclass
+    module InheritanceHelpers
+      def inherited(subclass)
+        super
+        subclass.on_exception(&on_exception)
+      end
+    end
+
+    def self.included(receiver)
+      receiver.extend ClassMethods
+      receiver.extend InheritanceHelpers
+      receiver.on_exception do |e, _result|
+        raise e
+      end
+    end
+  end
+end

data/lib/hospodar/dsl.rb

@@ -0,0 +1,84 @@
+# frozen_string_literal: true
+
+module Hospodar
+  # Core logic for creating objects
+  module DSL
+    def define_component_store_method(receiver, title)
+      mod = self
+      receiver.define_singleton_method(mod.store_method_name(title)) do |klass|
+        base_class = public_send(:"#{mod.components_storage_name}")[title]
+        mother_ship_check_inheritance!(klass, base_class)
+        send(mod.simple_store_method_name(title), klass)
+      end
+    end
+
+    def define_component_simple_store_method(receiver, title)
+      mod = self
+      receiver.define_singleton_method(mod.simple_store_method_name(title)) do |klass|
+        send(:"write_#{mod.component_class_reader(title)}", klass)
+        public_send(:"#{mod.components_storage_name}")[title] = klass
+      end
+      receiver.private_class_method mod.simple_store_method_name(title)
+    end
+
+    def define_component_activation_method
+      mod = self
+      define_method(mod.activation_method_name) do |title, base_class, klass, init = nil, &block|
+        raise(ArgumentError, 'please provide a block or class') if klass.nil? && block.nil?
+
+        mother_ship_check_inheritance!(klass, base_class)
+
+        target_class = klass || base_class
+
+        patched_class = mother_ship_patch_class(target_class, &block)
+        mother_ship_define_init(patched_class, &init)
+        public_send(mod.store_method_name(title), patched_class)
+      end
+    end
+
+    def define_component_new_instance_method(title)
+      mod = self
+      define_method mod.new_instance_method_name(title) do |*args|
+        klass = public_send(mod.component_class_reader(title))
+        klass.__ms_init__(klass, *args)
+      end
+    end
+
+    def define_component_configure_method(title)
+      mod = self
+      define_method mod.configure_component_method_name(title) do |klass = nil, init: nil, &block|
+        base_class = public_send(:"#{mod.component_class_reader(title)}")
+        public_send(mod.activation_method_name, title, base_class, klass, init, &block)
+      end
+      private mod.configure_component_method_name(title)
+    end
+
+    def define_component_adding_method
+      mod = self
+      define_method(component_name) do |title, base_class: nil, init: nil|
+        singleton_class.class_eval do
+          reader_name = mod.component_class_reader(title)
+          attr_accessor reader_name
+          alias_method :"write_#{reader_name}", :"#{reader_name}="
+          private :"write_#{reader_name}"
+        end
+        klass = base_class || mod.default_base_class || Class.new(Object)
+        mother_ship_define_init(klass, &(init || mod.default_init))
+        mod.define_component_store_method(self, title)
+        mod.define_component_simple_store_method(self, title)
+        send(mod.simple_store_method_name(title), klass)
+        mod.define_component_configure_method(title)
+        mod.define_component_new_instance_method(title)
+      end
+    end
+
+    def define_components_registry
+      mod = self
+      module_eval <<-METHOD, __FILE__, __LINE__ + 1
+	      def #{mod.components_storage_name}       # def parts
+	        @#{mod.components_storage_name} ||= {} #   @parts ||= {}
+	      end                                      # end
+      METHOD
+    end
+  end
+end

data/lib/hospodar/factories.rb

@@ -0,0 +1,28 @@
+# frozen_string_literal: true
+
+module Hospodar
+  # Singleton that collects generted modudes
+  module Factories
+    class << self
+      def add_module(components_name, **attrs)
+        registry.resolve(components_name, **attrs)
+      end
+
+      def memoized_modules
+        registry.registered_modules
+      end
+
+      private
+
+      def build_module
+        lambda do |components_name, **attrs|
+          ModuleBuilder.call(components_name, **attrs)
+        end
+      end
+
+      def registry
+        @registry ||= Registry.new(on_missing_key: build_module)
+      end
+    end
+  end
+end