servactory 1.5.2 → 1.6.1

data/lib/servactory/internals/dsl.rb

@@ -0,0 +1,33 @@
+# frozen_string_literal: true
+
+module Servactory
+  module Internals
+    module DSL
+      def self.included(base)
+        base.extend(ClassMethods)
+      end
+
+      module ClassMethods
+        def inherited(child)
+          super
+
+          child.send(:collection_of_internals).merge(collection_of_internals)
+        end
+
+        private
+
+        def internal(name, **options)
+          collection_of_internals << Internal.new(name, **options)
+        end
+
+        def collection_of_internals
+          @collection_of_internals ||= Collection.new
+        end
+
+        def internals_workbench
+          @internals_workbench ||= Workbench.work_with(collection_of_internals)
+        end
+      end
+    end
+  end
+end

data/lib/servactory/{internal_arguments/internal_argument.rb → internals/internal.rb}

@@ -1,8 +1,8 @@
 # frozen_string_literal: true
 
 module Servactory
-  module InternalArguments
-    class InternalArgument
+  module Internals
+    class Internal
       attr_reader :name,
                   :types,
                   :required

data/lib/servactory/internals/tools/prepare.rb

@@ -0,0 +1,60 @@
+# frozen_string_literal: true
+
+module Servactory
+  module Internals
+    module Tools
+      class Prepare
+        def self.prepare(...)
+          new(...).prepare
+        end
+
+        def initialize(context, collection_of_internals)
+          @context = context
+          @collection_of_internals = collection_of_internals
+        end
+
+        def prepare
+          @collection_of_internals.each do |internal|
+            create_instance_variable_for(internal)
+          end
+        end
+
+        private
+
+        def create_instance_variable_for(internal)
+          @context.instance_variable_set(:"@#{internal.name}", nil)
+
+          @context.class.class_eval(context_internal_template_for(internal))
+        end
+
+        # EXAMPLE:
+        #
+        #   define_method(:user=) do |value|
+        #     Servactory::Internals::Checks::Type.check!( context: self, internal:, value: )
+        #
+        #     instance_variable_set(:@user, value)
+        #   end
+        #
+        #   private attr_reader :user
+        #
+        def context_internal_template_for(internal)
+          <<-RUBY
+            define_method(:#{internal.name}=) do |value|
+              Servactory::Internals::Checks::Type.check!(
+                context: self,
+                internal: internal,
+                value: value
+              )
+
+              instance_variable_set(:@#{internal.name}, value)
+            end
+
+            private
+
+            attr_reader :#{internal.name}
+          RUBY
+        end
+      end
+    end
+  end
+end

data/lib/servactory/{internal_arguments → internals}/workbench.rb

@@ -1,14 +1,14 @@
 # frozen_string_literal: true
 
 module Servactory
-  module InternalArguments
+  module Internals
     class Workbench
       def self.work_with(...)
         new(...)
       end
 
-      def initialize(collection_of_internal_arguments)
-        @collection_of_internal_arguments = collection_of_internal_arguments
+      def initialize(collection_of_internals)
+        @collection_of_internals = collection_of_internals
       end
 
       def assign(context:)
@@ -16,13 +16,13 @@ module Servactory
       end
 
       def prepare
-        Tools::Prepare.prepare(context, collection_of_internal_arguments)
+        Tools::Prepare.prepare(context, collection_of_internals)
       end
 
       private
 
       attr_reader :context,
-                  :collection_of_internal_arguments
+                  :collection_of_internals
     end
   end
 end

data/lib/servactory/{make_methods → methods}/collection.rb

@@ -1,7 +1,7 @@
 # frozen_string_literal: true
 
 module Servactory
-  module MakeMethods
+  module Methods
     class Collection
       # NOTE: http://words.steveklabnik.com/beware-subclassing-ruby-core-classes
       extend Forwardable

data/lib/servactory/methods/dsl.rb

@@ -0,0 +1,47 @@
+# frozen_string_literal: true
+
+module Servactory
+  module Methods
+    module DSL
+      def self.included(base)
+        base.extend(ClassMethods)
+      end
+
+      module ClassMethods
+        def inherited(child)
+          super
+
+          child.send(:collection_of_methods).merge(collection_of_methods)
+        end
+
+        private
+
+        def make(name, **options)
+          collection_of_methods << Method.new(name, **options)
+        end
+
+        def method_missing(shortcut_name, *args, &block)
+          return super unless Servactory.configuration.method_shortcuts.include?(shortcut_name)
+
+          method_options = args.last.is_a?(Hash) ? args.pop : {}
+
+          args.each do |method_name|
+            make(:"#{shortcut_name}_#{method_name}", **method_options)
+          end
+        end
+
+        def respond_to_missing?(shortcut_name, *)
+          Servactory.configuration.method_shortcuts.include?(shortcut_name) || super
+        end
+
+        def collection_of_methods
+          @collection_of_methods ||= Collection.new
+        end
+
+        def methods_workbench
+          @methods_workbench ||= Workbench.work_with(collection_of_methods)
+        end
+      end
+    end
+  end
+end

data/lib/servactory/{make_methods/make_method.rb → methods/method.rb}

@@ -1,8 +1,8 @@
 # frozen_string_literal: true
 
 module Servactory
-  module MakeMethods
-    class MakeMethod
+  module Methods
+    class Method
       attr_reader :name,
                   :condition
 

data/lib/servactory/methods/shortcuts/collection.rb

@@ -0,0 +1,17 @@
+# frozen_string_literal: true
+
+module Servactory
+  module Methods
+    module Shortcuts
+      class Collection
+        # NOTE: http://words.steveklabnik.com/beware-subclassing-ruby-core-classes
+        extend Forwardable
+        def_delegators :@collection, :<<, :each, :merge, :include?
+
+        def initialize(*)
+          @collection = Set.new
+        end
+      end
+    end
+  end
+end

data/lib/servactory/{make_methods → methods}/workbench.rb

@@ -1,14 +1,14 @@
 # frozen_string_literal: true
 
 module Servactory
-  module MakeMethods
+  module Methods
     class Workbench
       def self.work_with(...)
         new(...)
       end
 
-      def initialize(collection_of_make_methods)
-        @collection_of_make_methods = collection_of_make_methods
+      def initialize(collection_of_methods)
+        @collection_of_methods = collection_of_methods
       end
 
       def assign(context:)
@@ -16,7 +16,7 @@ module Servactory
       end
 
       def run!
-        collection_of_make_methods.each do |make_method|
+        collection_of_methods.each do |make_method|
           next if unnecessary_for?(make_method)
 
           context.send(make_method.name)
@@ -26,7 +26,7 @@ module Servactory
       private
 
       attr_reader :context,
-                  :collection_of_make_methods
+                  :collection_of_methods
 
       def unnecessary_for?(make_method)
         condition = make_method.condition
@@ -34,7 +34,7 @@ module Servactory
         return false if condition.blank?
         return !Servactory::Utils.boolean?(condition) unless condition.is_a?(Proc)
 
-        !condition.call(context)
+        !condition.call(context: context)
       end
     end
   end

data/lib/servactory/outputs/checks/base.rb

@@ -0,0 +1,17 @@
+# frozen_string_literal: true
+
+module Servactory
+  module Outputs
+    module Checks
+      class Base
+        protected
+
+        def raise_error_with(message, **attributes)
+          message = message.call(**attributes) if message.is_a?(Proc)
+
+          raise Servactory.configuration.output_error_class.new(message: message)
+        end
+      end
+    end
+  end
+end

data/lib/servactory/{output_arguments → outputs}/checks/type.rb

@@ -1,14 +1,14 @@
 # frozen_string_literal: true
 
 module Servactory
-  module OutputArguments
+  module Outputs
     module Checks
       class Type < Base
-        DEFAULT_MESSAGE = lambda do |service_class_name:, output_argument:, expected_type:, given_type:|
+        DEFAULT_MESSAGE = lambda do |service_class_name:, output:, expected_type:, given_type:|
           I18n.t(
-            "servactory.output_arguments.checks.type.default_error",
+            "servactory.outputs.checks.type.default_error",
             service_class_name: service_class_name,
-            output_argument_name: output_argument.name,
+            output_name: output.name,
             expected_type: expected_type,
             given_type: given_type
           )
@@ -22,11 +22,11 @@ module Servactory
 
         ##########################################################################
 
-        def initialize(context:, output_argument:, value:)
+        def initialize(context:, output:, value:)
           super()
 
           @context = context
-          @output_argument = output_argument
+          @output = output
           @value = value
         end
 
@@ -36,7 +36,7 @@ module Servactory
           raise_error_with(
             DEFAULT_MESSAGE,
             service_class_name: @context.class.name,
-            output_argument: @output_argument,
+            output: @output,
             expected_type: prepared_types.join(", "),
             given_type: @value.class.name
           )
@@ -46,7 +46,7 @@ module Servactory
 
         def prepared_types
           @prepared_types ||=
-            Array(@output_argument.types).map do |type|
+            Array(@output.types).map do |type|
               if type.is_a?(String)
                 Object.const_get(type)
               else

data/lib/servactory/{internal_arguments → outputs}/collection.rb

@@ -1,7 +1,7 @@
 # frozen_string_literal: true
 
 module Servactory
-  module InternalArguments
+  module Outputs
     class Collection
       # NOTE: http://words.steveklabnik.com/beware-subclassing-ruby-core-classes
       extend Forwardable

data/lib/servactory/outputs/dsl.rb

@@ -0,0 +1,33 @@
+# frozen_string_literal: true
+
+module Servactory
+  module Outputs
+    module DSL
+      def self.included(base)
+        base.extend(ClassMethods)
+      end
+
+      module ClassMethods
+        def inherited(child)
+          super
+
+          child.send(:collection_of_outputs).merge(collection_of_outputs)
+        end
+
+        private
+
+        def output(name, **options)
+          collection_of_outputs << Output.new(name, **options)
+        end
+
+        def collection_of_outputs
+          @collection_of_outputs ||= Collection.new
+        end
+
+        def outputs_workbench
+          @outputs_workbench ||= Workbench.work_with(collection_of_outputs)
+        end
+      end
+    end
+  end
+end

data/lib/servactory/{output_arguments/output_argument.rb → outputs/output.rb}

@@ -1,8 +1,8 @@
 # frozen_string_literal: true
 
 module Servactory
-  module OutputArguments
-    class OutputArgument
+  module Outputs
+    class Output
       attr_reader :name,
                   :types,
                   :required,

data/lib/servactory/{output_arguments → outputs}/tools/conflicts.rb

@@ -1,36 +1,36 @@
 # frozen_string_literal: true
 
 module Servactory
-  module OutputArguments
+  module Outputs
     module Tools
       class Conflicts
         def self.check!(...)
           new(...).check!
         end
 
-        def initialize(context, collection_of_output_arguments, collection_of_internal_arguments)
+        def initialize(context, collection_of_outputs, collection_of_internals)
           @context = context
-          @collection_of_output_arguments = collection_of_output_arguments
-          @collection_of_internal_arguments = collection_of_internal_arguments
+          @collection_of_outputs = collection_of_outputs
+          @collection_of_internals = collection_of_internals
         end
 
         def check!
           return if overlapping_attributes.empty?
 
           message_text = I18n.t(
-            "servactory.output_arguments.tools.conflicts.error",
+            "servactory.outputs.tools.conflicts.error",
             service_class_name: @context.class.name,
             overlapping_attributes: overlapping_attributes.join(", ")
           )
 
-          raise Servactory.configuration.output_argument_error_class, message_text
+          raise Servactory.configuration.output_error_class.new(message: message_text)
         end
 
         private
 
         def overlapping_attributes
           @overlapping_attributes ||=
-            @collection_of_output_arguments.names.intersection(@collection_of_internal_arguments.names)
+            @collection_of_outputs.names.intersection(@collection_of_internals.names)
         end
       end
     end

data/lib/servactory/outputs/tools/prepare.rb

@@ -0,0 +1,62 @@
+# frozen_string_literal: true
+
+module Servactory
+  module Outputs
+    module Tools
+      class Prepare
+        def self.prepare(...)
+          new(...).prepare
+        end
+
+        def initialize(context, collection_of_outputs)
+          @context = context
+          @collection_of_outputs = collection_of_outputs
+        end
+
+        def prepare
+          @collection_of_outputs.each do |output|
+            create_instance_variable_for(output)
+          end
+        end
+
+        private
+
+        def create_instance_variable_for(output)
+          @context.instance_variable_set(:"@#{output.name}", nil)
+
+          @context.class.class_eval(context_output_template_for(output))
+        end
+
+        # EXAMPLE:
+        #
+        #   define_method(:user=) do |value|
+        #     Servactory::Internals::Checks::Type.check!( context: self, output:, value: )
+        #
+        #     instance_variable_set(:@user, value)
+        #   end
+        #
+        #   private
+        #
+        #   attr_reader :user
+        #
+        def context_output_template_for(output)
+          <<-RUBY
+            define_method(:#{output.name}=) do |value|
+              Servactory::Outputs::Checks::Type.check!(
+                context: self,
+                output: output,
+                value: value
+              )
+
+              instance_variable_set(:@#{output.name}, value)
+            end
+
+            private
+
+            attr_reader :#{output.name}
+          RUBY
+        end
+      end
+    end
+  end
+end

data/lib/servactory/outputs/workbench.rb

@@ -0,0 +1,31 @@
+# frozen_string_literal: true
+
+module Servactory
+  module Outputs
+    class Workbench
+      def self.work_with(...)
+        new(...)
+      end
+
+      def initialize(collection_of_outputs)
+        @collection_of_outputs = collection_of_outputs
+      end
+
+      def assign(context:)
+        @context = context
+      end
+
+      def find_conflicts_in!(collection_of_internals:)
+        Tools::Conflicts.check!(context, collection_of_outputs, collection_of_internals)
+      end
+
+      def prepare
+        Tools::Prepare.prepare(context, collection_of_outputs)
+      end
+
+      private
+
+      attr_reader :context, :collection_of_outputs
+    end
+  end
+end

data/lib/servactory/result.rb

@@ -8,15 +8,15 @@ module Servactory
 
     private
 
-    def prepare_for(context:, collection_of_output_arguments:)
-      prepare_outputs_with(context: context, collection_of_output_arguments: collection_of_output_arguments)
+    def prepare_for(context:, collection_of_outputs:)
+      prepare_outputs_with(context: context, collection_of_outputs: collection_of_outputs)
       prepare_statuses_with(context: context)
 
       self
     end
 
-    def prepare_outputs_with(context:, collection_of_output_arguments:)
-      collection_of_output_arguments.each do |output|
+    def prepare_outputs_with(context:, collection_of_outputs:)
+      collection_of_outputs.each do |output|
         self.class.attr_reader(:"#{output.name}")
 
         instance_variable_set(:"@#{output.name}", context.instance_variable_get(:"@#{output.name}"))

data/lib/servactory/utils.rb

@@ -4,6 +4,8 @@ module Servactory
   module Utils
     module_function
 
+    # @param value [#to_s]
+    # @return [Boolean]
     def boolean?(value)
       value.to_s.casecmp("true").to_i.zero?
     end

data/lib/servactory/version.rb

@@ -3,8 +3,8 @@
 module Servactory
   module VERSION
     MAJOR = 1
-    MINOR = 5
-    PATCH = 2
+    MINOR = 6
+    PATCH = 1
 
     STRING = [MAJOR, MINOR, PATCH].join(".")
   end