convenient_service 0.3.1 → 0.5.0

data/lib/convenient_service/rspec/matchers/custom/results/be_not_failure.rb

@@ -0,0 +1,20 @@
+# frozen_string_literal: true
+
+module ConvenientService
+  module RSpec
+    module Matchers
+      module Custom
+        module Results
+          class BeNotFailure < Results::Base
+            def statuses
+              [
+                Service::Plugins::HasResult::Constants::ERROR_STATUS,
+                Service::Plugins::HasResult::Constants::SUCCESS_STATUS
+              ]
+            end
+          end
+        end
+      end
+    end
+  end
+end

data/lib/convenient_service/rspec/matchers/custom/results/be_not_success.rb

@@ -0,0 +1,20 @@
+# frozen_string_literal: true
+
+module ConvenientService
+  module RSpec
+    module Matchers
+      module Custom
+        module Results
+          class BeNotSuccess < Results::Base
+            def statuses
+              [
+                Service::Plugins::HasResult::Constants::ERROR_STATUS,
+                Service::Plugins::HasResult::Constants::FAILURE_STATUS
+              ]
+            end
+          end
+        end
+      end
+    end
+  end
+end

data/lib/convenient_service/rspec/matchers/custom/results/be_success.rb

@@ -5,118 +5,9 @@ module ConvenientService
     module Matchers
       module Custom
         module Results
-          class BeSuccess
-            def matches?(result)
-              @result = result
-
-              rules = []
-
-              rules << ->(result) { result.class.include?(ConvenientService::Service::Plugins::HasResult::Entities::Result::Concern) }
-              rules << ->(result) { result.success? }
-              rules << ->(result) { result.service.instance_of?(service_class) } if used_of?
-              rules << ->(result) { result.data == data } if used_data?
-
-              condition = ConvenientService::Utils::Proc.conjunct(rules)
-
-              condition.call(result)
-            end
-
-            def with_data(data)
-              chain[:data] = data
-
-              self
-            end
-
-            def without_data
-              chain[:data] = {}
-
-              self
-            end
-
-            def of(service_class)
-              chain[:service_class] = service_class
-
-              self
-            end
-
-            def description
-              ##
-              # TODO: of
-              #
-              parts = []
-
-              parts << "be a `success`"
-              parts << "of `#{service_class}`" if used_of?
-              parts << "with data `#{data}`" if used_data?
-              parts << "\n\n"
-              parts << "got `#{result.status}`"
-              parts << "of `#{result.service.class}`" if used_of?
-              parts << "with data `#{result.data.to_h}`" if used_data?
-
-              parts.join(" ")
-            end
-
-            def failure_message
-              ##
-              # TODO: got text after expect text.
-              #
-              parts = []
-
-              parts << "expected that `#{result}` would be a `success`"
-              parts << "of `#{service_class}`" if used_of?
-              parts << "with data `#{data}`" if used_data?
-              parts << "\n\n"
-              parts << "got `#{result.status}`"
-              parts << "of `#{result.service.class}`" if used_of?
-              parts << "with data `#{result.data.to_h}`" if used_data?
-
-              parts.join(" ")
-            end
-
-            ##
-            # https://relishapp.com/rspec/rspec-expectations/v/3-11/docs/custom-matchers/define-a-custom-matcher#overriding-the-failure-message-when-negated
-            #
-            def failure_message_when_negated
-              ##
-              # TODO: got text after expect text.
-              #
-              parts = []
-
-              parts << "expected that #{result} would NOT be a `success`"
-              parts << "of `#{service_class}`" if used_of?
-              parts << "with data `#{data}`" if used_data?
-              parts << "\n\n"
-              parts << "got `#{result.status}`"
-              parts << "of `#{result.service.class}`" if used_of?
-              parts << "with data `#{result.data.to_h}`" if used_data?
-
-              parts.join(" ")
-            end
-
-            private
-
-            attr_reader :result
-
-            def used_data?
-              chain.key?(:data)
-            end
-
-            def used_of?
-              chain.key?(:service_class)
-            end
-
-            def chain
-              @chain ||= {}
-            end
-
-            def data
-              @data ||= chain[:data] || {}
-            end
-
-            def service_class
-              return @service_class if defined? @service_class
-
-              @service_class = chain[:service_class]
+          class BeSuccess < Results::Base
+            def statuses
+              [Service::Plugins::HasResult::Constants::SUCCESS_STATUS]
             end
           end
         end

data/lib/convenient_service/rspec/matchers/custom/results.rb

@@ -1,5 +1,11 @@
 # frozen_string_literal: true
 
+require_relative "results/base"
+
 require_relative "results/be_error"
 require_relative "results/be_failure"
 require_relative "results/be_success"
+
+require_relative "results/be_not_error"
+require_relative "results/be_not_failure"
+require_relative "results/be_not_success"

data/lib/convenient_service/rspec/matchers/results/be_not_error.rb

@@ -0,0 +1,15 @@
+# frozen_string_literal: true
+
+module ConvenientService
+  module RSpec
+    module Matchers
+      module Results
+        module BeNotError
+          def be_not_error(...)
+            Custom::Results::BeNotError.new(...)
+          end
+        end
+      end
+    end
+  end
+end

data/lib/convenient_service/rspec/matchers/results/be_not_failure.rb

@@ -0,0 +1,15 @@
+# frozen_string_literal: true
+
+module ConvenientService
+  module RSpec
+    module Matchers
+      module Results
+        module BeNotFailure
+          def be_not_failure(...)
+            Custom::Results::BeNotFailure.new(...)
+          end
+        end
+      end
+    end
+  end
+end

data/lib/convenient_service/rspec/matchers/results/be_not_success.rb

@@ -0,0 +1,15 @@
+# frozen_string_literal: true
+
+module ConvenientService
+  module RSpec
+    module Matchers
+      module Results
+        module BeNotSuccess
+          def be_not_success(...)
+            Custom::Results::BeNotSuccess.new(...)
+          end
+        end
+      end
+    end
+  end
+end

data/lib/convenient_service/rspec/matchers/results.rb

@@ -4,6 +4,10 @@ require_relative "results/be_error"
 require_relative "results/be_failure"
 require_relative "results/be_success"
 
+require_relative "results/be_not_error"
+require_relative "results/be_not_failure"
+require_relative "results/be_not_success"
+
 module ConvenientService
   module RSpec
     module Matchers
@@ -14,6 +18,10 @@ module ConvenientService
           include Results::BeError
           include Results::BeFailure
           include Results::BeSuccess
+
+          include Results::BeNotError
+          include Results::BeNotFailure
+          include Results::BeNotSuccess
         end
       end
     end

data/lib/convenient_service/service/plugins/has_result/constants.rb

@@ -5,10 +5,7 @@ module ConvenientService
     module Plugins
       module HasResult
         module Constants
-          ##
-          # TODO: Consider to include `::ConvenientService::Configs::Minimal`
-          #
-          DEFAULT_SERVICE_CLASS = ::Class.new { include ::ConvenientService::Core }
+          DEFAULT_SERVICE_CLASS = ::Class.new { include ::ConvenientService::Service::Plugins::HasResult::Concern }
           DEFAULT_SERVICE_INSTANCE = DEFAULT_SERVICE_CLASS.new
 
           SUCCESS_STATUS = :success

data/lib/convenient_service/service/plugins/has_result/entities/result/plugins/has_jsend_status_and_attributes/entities/data.rb

@@ -22,6 +22,14 @@ module ConvenientService
                       @value = value
                     end
 
+                    ##
+                    # @param key [String, Symbol]
+                    # @return [Boolean]
+                    #
+                    def has_attribute?(key)
+                      value.has_key?(key.to_sym)
+                    end
+
                     def ==(other)
                       casted = cast(other)
 

data/lib/convenient_service/service/plugins/has_result/entities/result/plugins/has_jsend_status_and_attributes/entities/status.rb

@@ -54,6 +54,10 @@ module ConvenientService
                       !error?
                     end
 
+                    def in?(statuses)
+                      statuses.any? { |status| self == status }
+                    end
+
                     def to_s
                       @to_s ||= value.to_s
                     end

data/lib/convenient_service/service/plugins/has_result_method_steps/middleware.rb

@@ -24,11 +24,8 @@ module ConvenientService
 
           private
 
-          ##
-          # TODO: `Plugins::HasResultSteps::Entities::Method.raw_value`.
-          #
           def raw(object)
-            Plugins::HasResultSteps::Entities::Method::Entities::Values::Raw.wrap(object)
+            Support::RawValue.wrap(object)
           end
         end
       end

data/lib/convenient_service/service/plugins/has_result_steps/concern.rb

@@ -33,10 +33,16 @@ module ConvenientService
             end
 
             ##
-            # NOTE: Allows to pass a value to `in` method without processing it.
+            # Allows to pass a value to `in` method without its intermediate processing.
+            # @see https://marian13.github.io/convenient_service_docs/basics/step_to_result_translation_table
+            #
+            # @example `:chat_v2` is passed to `AssertFeatureEnabled` as it is.
+            #   step AssertFeatureEnabled, in: {name: raw(:chat_v2)}
+            #   # that is converted to the following service invocation:
+            #   AssertFeatureEnabled.result(name: :chat_v2)
             #
             def raw(value)
-              Entities::Method::Entities::Values::Raw.wrap(value)
+              Support::RawValue.wrap(value)
             end
 
             def steps

data/lib/convenient_service/service/plugins/has_result_steps/entities/method/commands/cast_method_caller.rb

@@ -49,7 +49,7 @@ module ConvenientService
                     Entities::Callers::Alias.new(value)
                   when ::Proc
                     Entities::Callers::Proc.new(value)
-                  when Entities::Values::Raw
+                  when Support::RawValue
                     Entities::Callers::Raw.new(value)
                   end
                 end

data/lib/convenient_service/service/plugins/has_result_steps/entities/method/commands/cast_method_key.rb

@@ -53,7 +53,7 @@ module ConvenientService
                     Entities::Key.new(key)
                   when ::Proc
                     Entities::Key.new(key)
-                  when Entities::Values::Raw
+                  when Support::RawValue
                     Entities::Key.new(key)
                   end
                 end

data/lib/convenient_service/service/plugins/has_result_steps/entities/method/commands/cast_method_name.rb

@@ -53,7 +53,7 @@ module ConvenientService
                     Entities::Name.new(value)
                   when ::Proc
                     Entities::Name.new(key)
-                  when Entities::Values::Raw
+                  when Support::RawValue
                     Entities::Name.new(key)
                   end
                 end

data/lib/convenient_service/service/plugins/has_result_steps/entities/method/commands/define_method_in_container.rb

@@ -26,11 +26,13 @@ module ConvenientService
                   #
                   <<~RUBY.tap { |code| container.klass.class_eval(code, __FILE__, __LINE__ + 1) }
                     def #{name}
-                      step, key, name, error = steps[#{index}], :#{key}, :#{name}, #{error}
+                      step, key, method_name = steps[#{index}], :#{key}, :#{name}
 
-                      return step.result.data[key] if step.completed?
+                      raise #{not_completed_step_error}.new(step: step, method_name: method_name) unless step.completed?
 
-                      raise ::#{error}.new(step: step, method_name: name)
+                      raise #{not_existing_step_result_data_attribute_error}.new(step: step, key: key) unless step.result.data.has_attribute?(key)
+
+                      step.result.data[key]
                     end
                   RUBY
 
@@ -39,11 +41,16 @@ module ConvenientService
 
                 private
 
-                def error
-                  @error ||=
-                    <<~RUBY.chomp
-                      ConvenientService::Service::Plugins::HasResultSteps::Entities::Method::Errors::NotCompletedStep
-                    RUBY
+                def not_completed_step_error
+                  <<~RUBY.chomp
+                    ::ConvenientService::Service::Plugins::HasResultSteps::Entities::Method::Errors::NotCompletedStep
+                  RUBY
+                end
+
+                def not_existing_step_result_data_attribute_error
+                  <<~RUBY.chomp
+                    ::ConvenientService::Service::Plugins::HasResultSteps::Entities::Method::Errors::NotExistingStepResultDataAttribute
+                  RUBY
                 end
               end
             end

data/lib/convenient_service/service/plugins/has_result_steps/entities/method/entities.rb

@@ -4,4 +4,3 @@ require_relative "entities/directions"
 require_relative "entities/callers"
 require_relative "entities/key"
 require_relative "entities/name"
-require_relative "entities/values"

data/lib/convenient_service/service/plugins/has_result_steps/entities/method/errors.rb

@@ -110,7 +110,7 @@ module ConvenientService
               class NotCompletedStep < ConvenientService::Error
                 def initialize(method_name:, step:)
                   message = <<~TEXT
-                    `out` method `#{method_name}` is called before its corresponding step `#{step.service}` is completed.
+                    `out` method `#{method_name}` is called before its corresponding step `#{step.printable_service}` is completed.
 
                     Maybe it makes sense to change the steps order?
                   TEXT
@@ -118,6 +118,20 @@ module ConvenientService
                   super(message)
                 end
               end
+
+              class NotExistingStepResultDataAttribute < ConvenientService::Error
+                def initialize(key:, step:)
+                  message = <<~TEXT
+                    Step `#{step.printable_service}` result does NOT return `#{key}` data attribute.
+
+                    Maybe there is a typo in `out` definition?
+
+                    Or `success` of `#{step.printable_service}` accepts a wrong key?
+                  TEXT
+
+                  super(message)
+                end
+              end
             end
           end
         end

data/lib/convenient_service/service/plugins/has_result_steps/entities/step/concern/instance_methods.rb

@@ -70,6 +70,16 @@ module ConvenientService
                   @result ||= calculate_result
                 end
 
+                ##
+                # @return [String]
+                #
+                # @internal
+                #   TODO: printable service for methods steps.
+                #
+                def printable_service
+                  service.klass.to_s
+                end
+
                 def validate!
                   inputs.each { |input| input.validate_as_input_for_container!(container) }
 

data/lib/convenient_service/support/dependency_container/commands/create_methods_module.rb

@@ -0,0 +1,27 @@
+# frozen_string_literal: true
+
+module ConvenientService
+  module Support
+    module DependencyContainer
+      module Commands
+        class CreateMethodsModule < Support::Command
+          ##
+          # @return [Module]
+          #
+          def call
+            ::Module.new do
+              class << self
+                ##
+                # @return namespaces [ConvenientService::Support::DependencyContainer::Entities::NamespaceCollection]
+                #
+                def namespaces
+                  @namespaces ||= Entities::NamespaceCollection.new
+                end
+              end
+            end
+          end
+        end
+      end
+    end
+  end
+end

data/lib/convenient_service/support/dependency_container/commands/import_method.rb

@@ -0,0 +1,111 @@
+# frozen_string_literal: true
+
+module ConvenientService
+  module Support
+    module DependencyContainer
+      module Commands
+        class ImportMethod < Support::Command
+          ##
+          # @!attribute [r] importing_module
+          #   @return [Module]
+          #
+          attr_reader :importing_module
+
+          ##
+          # @!attribute [r] exporting_module
+          #   @return [Module]
+          #
+          attr_reader :exporting_module
+
+          ##
+          # @!attribute [r] method
+          #   @return [ConvenientService::Support::DependencyContainer::Method]
+          #
+          attr_reader :method
+
+          ##
+          # @!attribute [r] scope
+          #   @return [Symbol]
+          #
+          attr_reader :scope
+
+          ##
+          # @!attribute [r] prepend
+          #   @return [Boolean]
+          #
+          attr_reader :prepend
+
+          ##
+          # @param importing_module [Module]
+          # @param exporting_module [Module]
+          # @param method [ConvenientService::Support::DependencyContainer::Method]
+          # @param scope [:instance, :class]
+          # @param prepend [Boolean]
+          #
+          def initialize(importing_module:, exporting_module:, method:, scope:, prepend:)
+            @importing_module = importing_module
+            @exporting_module = exporting_module
+            @method = method
+            @scope = scope
+            @prepend = prepend
+          end
+
+          ##
+          # @return [ConvenientService::Support::DependencyContainer::Method]
+          #
+          def call
+            import imported_scoped_methods
+
+            method.define_in_module!(imported_scoped_methods)
+
+            method
+          end
+
+          private
+
+          ##
+          # @return [Module]
+          #
+          def imported_scoped_methods
+            @imported_scoped_methods ||= Utils::Module.fetch_own_const(importing_module, :"Imported#{imported_prefix}#{scoped_prefix}Methods") { Commands::CreateMethodsModule.call }
+          end
+
+          ##
+          # @return [String]
+          #
+          def imported_prefix
+            prepend ? "Prepended" : "Included"
+          end
+
+          ##
+          # @return [String]
+          #
+          def scoped_prefix
+            case scope
+            when Constants::INSTANCE_SCOPE then "Instance"
+            when Constants::CLASS_SCOPE then "Class"
+            end
+          end
+
+          ##
+          # @return [Module, Class]
+          #
+          def importer
+            case scope
+            when Constants::INSTANCE_SCOPE then importing_module
+            when Constants::CLASS_SCOPE then importing_module.singleton_class
+            end
+          end
+
+          ##
+          # @param mod [Module]
+          # @return [Module]
+          #
+          def import(mod)
+            prepend ? importer.prepend(mod) : importer.include(mod)
+          end
+        end
+      end
+    end
+  end
+end

data/lib/convenient_service/support/dependency_container/commands.rb

@@ -0,0 +1,4 @@
+# frozen_string_literal: true
+
+require_relative "commands/create_methods_module"
+require_relative "commands/import_method"

data/lib/convenient_service/support/dependency_container/constants.rb

@@ -0,0 +1,15 @@
+# frozen_string_literal: true
+
+module ConvenientService
+  module Support
+    module DependencyContainer
+      module Constants
+        INSTANCE_SCOPE = :instance
+        CLASS_SCOPE = :class
+
+        DEFAULT_SCOPE = Constants::INSTANCE_SCOPE
+        DEFAULT_PREPEND = false
+      end
+    end
+  end
+end