servactory 3.1.0.rc1 → 3.1.0.rc2

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA256:
-  metadata.gz: 1c4398d2ffb193d4acd86b96f02871198d13d4e8b31ec96dddaa05c3966f1525
-  data.tar.gz: bf35a15c0d771ef1c6362d573e2fbd5a04a0021cb0a80d847f37b23d5dff3b76
+  metadata.gz: 6a7c9b4d9ad2e7d15265ba278d740eb34e6df33590bf517a0b42d914dad46e22
+  data.tar.gz: 21ad5c1814f6bd2c62221057547f5388cf928fd1f937f37131dab041d6325983
 SHA512:
-  metadata.gz: baa8f5c12c6edbf0786d807611a759f8fd54b3f087967ea981942843e3a19b2f1026f607bc52ad9c5f4dd42830216582e4e54d38bef5e00fa48dea47bbe84210
-  data.tar.gz: c8af2b260386c4c2711a6b034bb116ad843cfb57c5e2b3181d59e9b9d38692ec562afc69bd5b33b46820c20972c0904e9921dfd1516e1576ec8622439ae1b382
+  metadata.gz: 9f231bf3c0662ec8285125cacd138d765622eb1ebad7e9eae5d95ae2dd84ad48f80a65783e208b3b9752e40e9bc755ca245bcf2f3b1c68b3724ca13a68d1f6a5
+  data.tar.gz: 8fb3f9f3bcf2a49f26d4cff76885537559ba4173c78585c2432fc7bf814a8e587303dc941c36a7992800bff1c561661cc04ae20beffbc17dac4d5a0af64de387

data/lib/servactory/context/warehouse/inputs.rb

@@ -29,55 +29,42 @@ module Servactory
           @arguments.keys
         end
 
-        # Merges new arguments into storage and defines accessor methods.
+        # Merges new arguments into storage.
         #
         # @param arguments [Hash] Input name-value pairs to merge
-        # @return [void]
+        # @return [Hash] Updated arguments hash
         def merge!(arguments)
           @arguments.merge!(arguments)
-          define_methods_for!(arguments)
         end
 
-        # Raises error for any method call not pre-defined as a singleton accessor.
+        # Delegates method calls to stored inputs.
         #
         # Supports predicate methods when enabled in config.
         #
         # @param name [Symbol] Method name (input or predicate)
         # @param _args [Array] Method arguments (unused)
-        # @raise [Exception] Failure exception for undefined input
+        # @return [Object] Input value or predicate result
         def method_missing(name, *_args)
           predicate = @context.config.predicate_methods_enabled && name.end_with?("?")
+
           input_name = predicate ? name.to_s.chomp("?").to_sym : name
-          raise_error_for(input_name)
+
+          input_value = @arguments.fetch(input_name) { raise_error_for(input_name) }
+
+          predicate ? Servactory::Utils.query_attribute(input_value) : input_value
         end
 
-        # Returns false since all valid methods are defined as singleton methods.
+        # Checks if method corresponds to stored input.
         #
-        # @return [Boolean] Always false
-        def respond_to_missing?(*)
-          false
+        # @param name [Symbol] Method name to check
+        # @return [Boolean] True if input exists for this method
+        def respond_to_missing?(name, *)
+          input_name = name.to_s.chomp("?").to_sym
+          @arguments.key?(input_name) || @arguments.key?(name) || super
         end
 
         private
 
-        # Defines singleton accessor methods for given arguments.
-        #
-        # @param arguments [Hash] Input name-value pairs to define methods for
-        # @return [void]
-        def define_methods_for!(arguments)
-          arguments.each_key do |name|
-            define_singleton_method(name) do
-              @arguments.fetch(name) { raise_error_for(name) }
-            end
-
-            next unless @context.config.predicate_methods_enabled
-
-            define_singleton_method(:"#{name}?") do
-              Servactory::Utils.query_attribute(@arguments.fetch(name) { raise_error_for(name) })
-            end
-          end
-        end
-
         # Raises error for undefined input.
         #
         # @param input_name [Symbol] Name of undefined input

data/lib/servactory/context/workspace/inputs.rb

@@ -7,8 +7,6 @@ module Servactory
         def initialize(context:, collection_of_inputs:)
           @context = context
           @collection_of_inputs = collection_of_inputs
-
-          define_attribute_methods!
         end
 
         def only(*names)
@@ -26,30 +24,31 @@ module Servactory
         def method_missing(name, *_args)
           if name.to_s.end_with?("=")
             prepared_name = name.to_s.delete("=").to_sym
+
             raise_error_for(:assign, prepared_name)
           else
-            raise_error_for(:fetch, name)
+            fetch_with(name:) { raise_error_for(:fetch, name) }
           end
         end
 
-        def respond_to_missing?(*)
-          false
+        def respond_to_missing?(name, *)
+          resolve_input(name) || super
         end
 
         private
 
-        def define_attribute_methods!
-          @collection_of_inputs.each do |input|
-            define_singleton_method(input.internal_name) do
-              fetch_value(attribute: input)
-            end
+        def fetch_with(name:, &_block)
+          predicate = @context.config.predicate_methods_enabled && name.end_with?("?")
 
-            next unless @context.config.predicate_methods_enabled
+          input_name = predicate ? name.to_s.chomp("?").to_sym : name
 
-            define_singleton_method(:"#{input.internal_name}?") do
-              fetch_predicate(attribute: input)
-            end
-          end
+          input = @collection_of_inputs.find_by(name: input_name)
+
+          return yield if input.nil?
+
+          value = fetch_value(attribute: input)
+
+          predicate ? Servactory::Utils.query_attribute(value) : value
         end
 
         def fetch_value(attribute:)
@@ -65,8 +64,12 @@ module Servactory
           value
         end
 
-        def fetch_predicate(attribute:)
-          Servactory::Utils.query_attribute(fetch_value(attribute:))
+        def resolve_input(name)
+          return true if @collection_of_inputs.find_by(name:)
+
+          @context.config.predicate_methods_enabled &&
+            name.to_s.end_with?("?") &&
+            @collection_of_inputs.find_by(name: name.to_s.chomp("?").to_sym)
         end
 
         def raise_error_for(type, name)

data/lib/servactory/context/workspace/internals.rb

@@ -7,9 +7,6 @@ module Servactory
         def initialize(context:, collection_of_internals:)
           @context = context
           @collection_of_internals = collection_of_internals
-          @validated_attributes = Set.new
-
-          define_attribute_methods!
         end
 
         def only(*names)
@@ -24,57 +21,61 @@ module Servactory
             .to_h { |internal| [internal.name, send(internal.name)] }
         end
 
-        def method_missing(name, *_args)
+        def method_missing(name, *args)
           if name.to_s.end_with?("=")
             prepared_name = name.to_s.delete("=").to_sym
-            raise_error_for(:assign, prepared_name)
+
+            assign_with(prepared_name:, value: args.pop) { raise_error_for(:assign, prepared_name) }
           else
-            raise_error_for(:fetch, name)
+            fetch_with(name:) { raise_error_for(:fetch, name) }
           end
         end
 
-        def respond_to_missing?(*)
-          false
+        def respond_to_missing?(name, *)
+          resolve_internal(name) || super
         end
 
         private
 
-        def define_attribute_methods! # rubocop:disable Metrics/MethodLength
-          @collection_of_internals.each do |internal|
-            define_singleton_method(internal.name) do
-              fetch_value(attribute: internal)
-            end
+        def validated_attributes
+          @validated_attributes ||= Set.new
+        end
 
-            define_singleton_method(:"#{internal.name}=") do |value|
-              assign_value(attribute: internal, value:)
-            end
+        def assign_with(prepared_name:, value:, &_block)
+          internal = @collection_of_internals.find_by(name: prepared_name)
 
-            next unless @context.config.predicate_methods_enabled
+          return yield if internal.nil?
 
-            define_singleton_method(:"#{internal.name}?") do
-              fetch_predicate(attribute: internal)
-            end
-          end
-        end
-
-        def assign_value(attribute:, value:)
-          @validated_attributes.delete(attribute.name)
+          validated_attributes.delete(internal.name)
 
           Servactory::Maintenance::Validations::Performer.validate!(
             context: @context,
-            attribute:,
+            attribute: internal,
             value:
           )
 
-          @context.send(:servactory_service_warehouse).assign_internal(attribute.name, value)
+          @context.send(:servactory_service_warehouse).assign_internal(internal.name, value)
 
-          @validated_attributes << attribute.name
+          validated_attributes << internal.name
+        end
+
+        def fetch_with(name:, &_block)
+          predicate = @context.config.predicate_methods_enabled && name.end_with?("?")
+
+          internal_name = predicate ? name.to_s.chomp("?").to_sym : name
+          internal = @collection_of_internals.find_by(name: internal_name)
+
+          return yield if internal.nil?
+
+          internal_value = fetch_value(attribute: internal)
+
+          predicate ? Servactory::Utils.query_attribute(internal_value) : internal_value
         end
 
         def fetch_value(attribute:)
           value = @context.send(:servactory_service_warehouse).fetch_internal(attribute.name)
 
-          if @validated_attributes.exclude?(attribute.name)
+          if validated_attributes.exclude?(attribute.name)
             Servactory::Maintenance::Validations::Performer.validate!(
               context: @context,
               attribute:,
@@ -85,8 +86,12 @@ module Servactory
           value
         end
 
-        def fetch_predicate(attribute:)
-          Servactory::Utils.query_attribute(fetch_value(attribute:))
+        def resolve_internal(name)
+          return true if @collection_of_internals.find_by(name:)
+
+          @context.config.predicate_methods_enabled &&
+            name.to_s.end_with?("?") &&
+            @collection_of_internals.find_by(name: name.to_s.chomp("?").to_sym)
         end
 
         def raise_error_for(type, name)

data/lib/servactory/context/workspace/outputs.rb

@@ -7,8 +7,6 @@ module Servactory
         def initialize(context:, collection_of_outputs:)
           @context = context
           @collection_of_outputs = collection_of_outputs
-
-          define_attribute_methods!
         end
 
         def only(*names)
@@ -23,55 +21,55 @@ module Servactory
             .to_h { |output| [output.name, send(output.name)] }
         end
 
-        def method_missing(name, *_args)
+        def method_missing(name, *args)
           if name.to_s.end_with?("=")
             prepared_name = name.to_s.delete("=").to_sym
-            raise_error_for(:assign, prepared_name)
+
+            assign_with(prepared_name:, value: args.pop) { raise_error_for(:assign, prepared_name) }
           else
-            raise_error_for(:fetch, name)
+            fetch_with(name:) { raise_error_for(:fetch, name) }
           end
         end
 
-        def respond_to_missing?(*)
-          false
+        def respond_to_missing?(name, *)
+          resolve_output(name) || super
         end
 
         private
 
-        def define_attribute_methods! # rubocop:disable Metrics/MethodLength
-          @collection_of_outputs.each do |output|
-            define_singleton_method(output.name) do
-              fetch_value(attribute: output)
-            end
-
-            define_singleton_method(:"#{output.name}=") do |value|
-              assign_value(attribute: output, value:)
-            end
+        def assign_with(prepared_name:, value:, &_block)
+          output = @collection_of_outputs.find_by(name: prepared_name)
 
-            next unless @context.config.predicate_methods_enabled
-
-            define_singleton_method(:"#{output.name}?") do
-              fetch_predicate(attribute: output)
-            end
-          end
-        end
+          return yield if output.nil?
 
-        def assign_value(attribute:, value:)
           Servactory::Maintenance::Validations::Performer.validate!(
             context: @context,
-            attribute:,
+            attribute: output,
             value:
           )
 
-          @context.send(:servactory_service_warehouse).assign_output(attribute.name, value)
+          @context.send(:servactory_service_warehouse).assign_output(output.name, value)
         end
 
-        def fetch_value(attribute:)
-          @context.send(:servactory_service_warehouse).fetch_output(attribute.name)
+        def fetch_with(name:, &_block)
+          predicate = @context.config.predicate_methods_enabled && name.end_with?("?")
+
+          output_name = predicate ? name.to_s.chomp("?").to_sym : name
+          output = @collection_of_outputs.find_by(name: output_name)
+
+          return yield if output.nil?
+
+          output_value = @context.send(:servactory_service_warehouse).fetch_output(output.name)
+
+          predicate ? Servactory::Utils.query_attribute(output_value) : output_value
         end
 
-        def fetch_predicate(attribute:)
-          Servactory::Utils.query_attribute(fetch_value(attribute:))
+        def resolve_output(name)
+          return true if @collection_of_outputs.find_by(name:)
+
+          @context.config.predicate_methods_enabled &&
+            name.to_s.end_with?("?") &&
+            @collection_of_outputs.find_by(name: name.to_s.chomp("?").to_sym)
         end
 
         def raise_error_for(type, name)

data/lib/servactory/result.rb

@@ -41,7 +41,7 @@ module Servactory
   # ```ruby
   # result.active?  # Equivalent to Utils.query_attribute(result.active)
   # ```
-  class Result # rubocop:disable Metrics/ClassLength
+  class Result
     # Internal container for service output values.
     #
     # Provides dynamic method access to output values.
@@ -55,8 +55,6 @@ module Servactory
       def initialize(outputs:, predicate_methods_enabled:)
         @outputs = outputs
         @predicate_methods_enabled = predicate_methods_enabled
-
-        define_attribute_methods!
       end
 
       # Returns string representation for debugging.
@@ -66,26 +64,34 @@ module Servactory
         "#<#{self.class.name} #{draw_result}>"
       end
 
-      private
-
-      # Defines singleton accessor methods for output values on this instance.
-      #
-      # Creates getter methods for each output key and, when predicate methods
-      # are enabled, predicate methods (e.g., user?) for boolean queries.
-      #
-      # @return [void]
-      def define_attribute_methods!
-        @outputs.each_key do |name|
-          define_singleton_method(name) { @outputs[name] }
+      # Delegates method calls to stored outputs.
+      def method_missing(name, *args)
+        if name.to_s.end_with?("?")
+          base_name = name.to_s.chomp("?").to_sym
+          if @predicate_methods_enabled && @outputs.key?(base_name)
+            return Servactory::Utils.query_attribute(@outputs[base_name])
+          end
+        elsif @outputs.key?(name)
+          return @outputs[name]
+        end
 
-          next unless @predicate_methods_enabled
+        super
+      end
 
-          define_singleton_method(:"#{name}?") do
-            Servactory::Utils.query_attribute(@outputs[name])
-          end
+      # Checks if method corresponds to stored output.
+      def respond_to_missing?(name, include_private = false)
+        if name.to_s.end_with?("?")
+          base_name = name.to_s.chomp("?").to_sym
+          return true if @predicate_methods_enabled && @outputs.key?(base_name)
+        elsif @outputs.key?(name)
+          return true
         end
+
+        super
       end
 
+      private
+
       # Returns array of output attribute names.
       #
       # @return [Array<Symbol>] Output names without predicates
@@ -282,9 +288,6 @@ module Servactory
 
     # Delegates method calls to the outputs container.
     #
-    # On first access, triggers lazy initialization of outputs and
-    # installs singleton delegator methods for subsequent direct access.
-    #
     # @param name [Symbol] Method name (output attribute)
     # @param args [Array] Method arguments
     # @param block [Proc] Optional block
@@ -332,12 +335,9 @@ module Servactory
 
     # Returns outputs container, lazily initialized.
     #
-    # On first access, also defines singleton delegator methods on this
-    # Result instance for subsequent direct access.
-    #
     # @return [Outputs] Outputs container with service values
     def outputs
-      @outputs ||= build_outputs.tap { |outputs_container| define_output_delegators!(outputs_container) }
+      @outputs ||= build_outputs
     end
 
     # Builds Outputs container with predicate configuration.
@@ -362,21 +362,6 @@ module Servactory
       hash
     end
 
-    # Defines singleton delegator methods on this Result instance
-    # for direct access to output values without method_missing.
-    #
-    # @param outputs_container [Outputs] Outputs container to delegate to
-    # @return [void]
-    def define_output_delegators!(outputs_container)
-      outputs_container.send(:output_names).each do |name|
-        define_singleton_method(name) { outputs.public_send(name) }
-      end
-
-      outputs_container.send(:predicate_names).each do |name|
-        define_singleton_method(name) { outputs.public_send(name) }
-      end
-    end
-
     ########################################################################
 
     # Wraps NoMethodError with contextual failure.

data/lib/servactory/version.rb

@@ -5,7 +5,7 @@ module Servactory
     MAJOR = 3
     MINOR = 1
     PATCH = 0
-    PRE = "rc1"
+    PRE = "rc2"
 
     STRING = [MAJOR, MINOR, PATCH, PRE].compact.join(".")
   end

metadata

@@ -1,7 +1,7 @@
 --- !ruby/object:Gem::Specification
 name: servactory
 version: !ruby/object:Gem::Version
-  version: 3.1.0.rc1
+  version: 3.1.0.rc2
 platform: ruby
 authors:
 - Anton Sokolov