servactory 2.5.0.rc2 → 2.5.0.rc3

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA256:
-  metadata.gz: ce8eb77c5347f231539b115081d7706f6546830ccda8269e414ba05d097d3d85
-  data.tar.gz: 3393084486439b10177a5a13eb4826f4b2ab19c21aefbe92a23aaa7c5ce0096c
+  metadata.gz: 1e7661bf7b65a1dd0c2214be8364897c91522116fb208de82ac7869f4ec81534
+  data.tar.gz: f87706b5056118c9c772a08b9cd13047c79d121eb8dbdc21447e21677c4d1504
 SHA512:
-  metadata.gz: 4ae8873bb459d8bedac4d64cee6ca8f4049e57fd87f62e3842b47e5f20415196cc6470704e3d9fd1d2c380e75ae2ffdcd5f93ad5dfc87e677b259ef215d8974b
-  data.tar.gz: c0a37302c68b09fa238656f88bcdd536bb81d1a5f47db60ac8de52d7455d534b3622cbcd5568474e7d303b86bb7a6f5219f1f7e5fa0c7a5a0833d955194406d9
+  metadata.gz: 62ff3f88d0df55e1a02761990cc0b624bb151ef0f7d5fe2f5e5f13f22934d88e50c036e97faa854b27b7a34bfb05fcef4d839e3cc4c0aed1b282613b93a37da5
+  data.tar.gz: 1f78163c75c54c7f6eaac73b9ceaa8b433964bfae3ba0d45fb0bc743a5a4d586f19453ccb1d4e67d67e8dbd3157d32d8b5c047405550775b6aab6976c0944e98

data/lib/generators/servactory/install_generator.rb

@@ -0,0 +1,21 @@
+# frozen_string_literal: true
+
+require "rails/generators/base"
+
+module Servactory
+  module Generators
+    class InstallGenerator < Rails::Generators::Base
+      source_root File.expand_path("templates", __dir__)
+
+      def copy_services
+        directory "services/application_service", "app/services/application_service"
+      end
+
+      def copy_locales
+        %i[en ru].each do |locale|
+          copy_file "../../../../config/locales/#{locale}.yml", "config/locales/servactory.#{locale}.yml"
+        end
+      end
+    end
+  end
+end

data/lib/generators/servactory/rspec_generator.rb

@@ -0,0 +1,88 @@
+# frozen_string_literal: true
+
+require "rails/generators/named_base"
+
+module Servactory
+  module Generators
+    class RspecGenerator < Rails::Generators::NamedBase
+      source_root File.expand_path("templates", __dir__)
+
+      argument :attributes, type: :array, default: [], banner: "input_name"
+
+      def create_service
+        create_file "app/services/#{file_path}_spec.rb" do
+          <<~RUBY
+            # frozen_string_literal: true
+
+            RSpec.describe #{class_name}, type: :service do
+              pending "add some examples to (or delete) \#{__FILE__}"
+
+              # let(:attributes) do
+              #   {
+              #{input_attribute_draw}
+              #   }
+              # end
+              #
+              #{input_let_draw}
+              #
+              # describe "validation" do
+              #   describe "inputs" do
+              #{input_validation_draw}
+              #   end
+              #
+              #   describe "internals" do
+              #     it { expect { perform }.to have_internal(:some_data).type(String) }
+              #   end
+              # end
+              #
+              # describe ".call!" do
+              #   subject(:perform) { described_class.call!(**attributes) }
+              #
+              #   describe "and the data required for work is also valid" do
+              #     it { expect(perform).to be_success_service }
+              #
+              #     # ...
+              #   end
+              #
+              #   describe "but the data required for work is invalid" do
+              #     # Provide a reason why the data is invalid and then use this:
+              #     it { expect(perform).to be_failure_service }
+              #
+              #     # ...
+              #   end
+              # end
+            end
+          RUBY
+        end
+      end
+
+      def input_attribute_draw
+        input_names.map do |input_name|
+          <<~RUBY.strip
+            #     #{input_name}: #{input_name}
+          RUBY
+        end.join(",\n  ")
+      end
+
+      def input_let_draw
+        input_names.map do |input_name|
+          <<~RUBY.strip
+            # let(:#{input_name}) { "Some value" }
+          RUBY
+        end.join("\n  ")
+      end
+
+      def input_validation_draw
+        input_names.map do |input_name|
+          <<~RUBY.strip
+            #     it { expect { perform }.to have_input(:#{input_name}).valid_with(attributes).type(String).required }
+          RUBY
+        end.join("\n  ")
+      end
+
+      def input_names
+        @input_names ||= attributes_names
+      end
+    end
+  end
+end

data/lib/generators/servactory/service_generator.rb

@@ -0,0 +1,49 @@
+# frozen_string_literal: true
+
+require "rails/generators/named_base"
+
+module Servactory
+  module Generators
+    class ServiceGenerator < Rails::Generators::NamedBase
+      source_root File.expand_path("templates", __dir__)
+
+      argument :attributes, type: :array, default: [], banner: "input_name"
+
+      def create_service # rubocop:disable Metrics/MethodLength
+        create_file "app/services/#{file_path}.rb" do
+          <<~RUBY
+            # frozen_string_literal: true
+
+            class #{class_name} < ApplicationService::Base
+              #{input_draw}
+
+              output :result, type: Symbol
+
+              make :something
+
+              private
+
+              def something
+                # Write your code here
+
+                outputs.result = :done
+              end
+            end
+          RUBY
+        end
+      end
+
+      def input_draw
+        input_names.map do |input_name|
+          <<~RUBY.squish
+            input :#{input_name}, type: String
+          RUBY
+        end.join("\n  ")
+      end
+
+      def input_names
+        @input_names ||= attributes_names
+      end
+    end
+  end
+end

data/lib/generators/servactory/templates/services/application_service/base.rb

@@ -0,0 +1,60 @@
+# frozen_string_literal: true
+
+module ApplicationService
+  class Base
+    include Servactory::DSL
+
+    # More information: https://servactory.com/guide/extensions
+    # include Servactory::DSL.with_extensions(
+    #   ApplicationService::Extensions::YourExtension::DSL
+    # )
+
+    fail_on! ActiveRecord::RecordInvalid
+
+    # More information: https://servactory.com/guide/configuration
+    configuration do
+      input_exception_class ApplicationService::Exceptions::Input
+      internal_exception_class ApplicationService::Exceptions::Internal
+      output_exception_class ApplicationService::Exceptions::Output
+
+      failure_class ApplicationService::Exceptions::Failure
+
+      result_class ApplicationService::Result
+
+      # input_option_helpers(
+      #   [
+      #     Servactory::ToolKit::DynamicOptions::Format.use,
+      #     Servactory::ToolKit::DynamicOptions::Min.use,
+      #     Servactory::ToolKit::DynamicOptions::Max.use,
+      #     ApplicationService::DynamicOptions::CustomEq.use
+      #   ]
+      # )
+
+      # internal_option_helpers(
+      #   [
+      #     Servactory::ToolKit::DynamicOptions::Format.use,
+      #     Servactory::ToolKit::DynamicOptions::Min.use,
+      #     Servactory::ToolKit::DynamicOptions::Max.use,
+      #     ApplicationService::DynamicOptions::CustomEq.use
+      #   ]
+      # )
+
+      # output_option_helpers(
+      #   [
+      #     Servactory::ToolKit::DynamicOptions::Format.use,
+      #     Servactory::ToolKit::DynamicOptions::Min.use,
+      #     Servactory::ToolKit::DynamicOptions::Max.use,
+      #     ApplicationService::DynamicOptions::CustomEq.use
+      #   ]
+      # )
+
+      # collection_mode_class_names [ActiveRecord::Relation]
+
+      # hash_mode_class_names [CustomHash]
+
+      # action_shortcuts %i[assign build create save]
+
+      # action_aliases %i[do_it!]
+    end
+  end
+end

data/lib/generators/servactory/templates/services/application_service/exceptions.rb

@@ -0,0 +1,11 @@
+# frozen_string_literal: true
+
+module ApplicationService
+  module Exceptions
+    class Input < Servactory::Exceptions::Input; end
+    class Output < Servactory::Exceptions::Output; end
+    class Internal < Servactory::Exceptions::Internal; end
+
+    class Failure < Servactory::Exceptions::Failure; end
+  end
+end

data/lib/generators/servactory/templates/services/application_service/result.rb

@@ -0,0 +1,5 @@
+# frozen_string_literal: true
+
+module ApplicationService
+  class Result < Servactory::Result; end
+end

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

@@ -75,7 +75,7 @@ module Servactory
             internal_name: name
           )
 
-          raise @context.class.config.input_exception_class.new(message: message_text)
+          raise @context.class.config.internal_exception_class.new(message: message_text)
         end
       end
     end

data/lib/servactory/info/dsl.rb

@@ -8,11 +8,63 @@ module Servactory
       end
 
       module ClassMethods
-        def info
+        def info # rubocop:disable Metrics/MethodLength, Metrics/AbcSize
           Servactory::Info::Result.new(
-            inputs: collection_of_inputs.names,
-            internals: collection_of_internals.names,
-            outputs: collection_of_outputs.names
+            inputs: collection_of_inputs.to_h do |input|
+              work = input.class::Work.new(input)
+              consists_of = input.collection_of_options.find_by(name: :consists_of)
+              inclusion = input.collection_of_options.find_by(name: :inclusion)
+              must = input.collection_of_options.find_by(name: :must)
+
+              [
+                input.name,
+                {
+                  work: work,
+                  types: input.types,
+                  required: input.required,
+                  default: input.default,
+                  consists_of: consists_of.body,
+                  inclusion: inclusion.body,
+                  must: must.body
+                }
+              ]
+            end,
+
+            internals: collection_of_internals.to_h do |internal|
+              work = internal.class::Work.new(internal)
+              consists_of = internal.collection_of_options.find_by(name: :consists_of)
+              inclusion = internal.collection_of_options.find_by(name: :inclusion)
+              must = internal.collection_of_options.find_by(name: :must)
+
+              [
+                internal.name,
+                {
+                  work: work,
+                  types: internal.types,
+                  consists_of: consists_of.body,
+                  inclusion: inclusion.body,
+                  must: must.body
+                }
+              ]
+            end,
+
+            outputs: collection_of_outputs.to_h do |output|
+              work = output.class::Work.new(output)
+              consists_of = output.collection_of_options.find_by(name: :consists_of)
+              inclusion = output.collection_of_options.find_by(name: :inclusion)
+              must = output.collection_of_options.find_by(name: :must)
+
+              [
+                output.name,
+                {
+                  work: work,
+                  types: output.types,
+                  consists_of: consists_of.body,
+                  inclusion: inclusion.body,
+                  must: must.body
+                }
+              ]
+            end
           )
         end
       end

data/lib/servactory/result.rb

@@ -110,7 +110,7 @@ module Servactory
     ########################################################################
 
     def rescue_no_method_error_with(exception:) # rubocop:disable Metrics/MethodLength
-      raise exception if @context.blank?
+      raise exception if @context.blank? || @context.instance_of?(Servactory::TestKit::Result)
 
       raise @context.class.config.failure_class.new(
         type: :base,

data/lib/servactory/test_kit/rspec/helpers.rb

@@ -0,0 +1,95 @@
+# frozen_string_literal: true
+
+module Servactory
+  module TestKit
+    module Rspec
+      module Helpers
+        def allow_service_as_success!(service_class_name, &block)
+          allow_service!(service_class_name, :as_success, &block)
+        end
+
+        def allow_service_as_success(service_class_name, &block)
+          allow_service(service_class_name, :as_success, &block)
+        end
+
+        def allow_service_as_failure!(service_class_name, &block)
+          allow_service!(service_class_name, :as_failure, &block)
+        end
+
+        def allow_service_as_failure(service_class_name, &block)
+          allow_service(service_class_name, :as_failure, &block)
+        end
+
+        ########################################################################
+
+        def allow_service!(service_class_name, result_type, &block)
+          allow_servactory(service_class_name, :call!, result_type, &block)
+        end
+
+        def allow_service(service_class_name, result_type, &block)
+          allow_servactory(service_class_name, :call, result_type, &block)
+        end
+
+        ########################################################################
+
+        # rubocop:disable Metrics/MethodLength, Metrics/AbcSize, Metrics/CyclomaticComplexity, Metrics/PerceivedComplexity
+        def allow_servactory(service_class_name, method_call, result_type)
+          method_call = method_call.to_sym
+          result_type = result_type.to_sym
+
+          unless %i[call! call].include?(method_call)
+            raise ArgumentError, "Invalid value for `method_call`. Must be `:call!` or `:call`."
+          end
+
+          unless %i[as_success as_failure].include?(result_type)
+            raise ArgumentError, "Invalid value for `result_type`. Must be `:as_success` or `:as_failure`."
+          end
+
+          as_success = result_type == :as_success
+          with_bang = method_call == :call!
+
+          if block_given? && !yield.is_a?(Hash) && as_success
+            raise ArgumentError, "Invalid value for block. Must be a Hash with attributes."
+          end
+
+          and_return_or_raise = with_bang && !as_success ? :and_raise : :and_return
+
+          result = if block_given?
+                     if yield.is_a?(Hash)
+                       yield
+                     else
+                       { with_bang ? :exception : :error => yield }
+                     end
+                   else
+                     {}
+                   end
+
+          # puts
+          # puts <<~RUBY
+          #   allow(#{service_class_name}).to(
+          #     receive(#{method_call.inspect})
+          #       .public_send(
+          #         #{and_return_or_raise.inspect},
+          #         Servactory::TestKit::Result.public_send(#{result_type.inspect}, #{result})
+          #       )
+          #   )
+          # RUBY
+          # puts
+
+          allow(service_class_name).to(
+            receive(method_call)
+              .public_send(
+                and_return_or_raise,
+                if as_success
+                  Servactory::TestKit::Result.public_send(result_type, **result)
+                else
+                  Servactory::TestKit::Result.public_send(result_type, result)
+                end
+              )
+          )
+        end
+        # rubocop:enable Metrics/MethodLength, Metrics/AbcSize, Metrics/CyclomaticComplexity, Metrics/PerceivedComplexity
+      end
+    end
+  end
+end

data/lib/servactory/test_kit/rspec/matchers/have_service_attribute_matchers/consists_of_matcher.rb

@@ -0,0 +1,121 @@
+# frozen_string_literal: true
+
+module Servactory
+  module TestKit
+    module Rspec
+      module Matchers
+        module HaveServiceAttributeMatchers
+          class ConsistsOfMatcher
+            attr_reader :missing_option
+
+            def initialize(described_class, attribute_type, attribute_name, option_types, consists_of_types,
+                           custom_message)
+              @described_class = described_class
+              @attribute_type = attribute_type
+              @attribute_type_plural = attribute_type.to_s.pluralize.to_sym
+              @attribute_name = attribute_name
+              @option_types = option_types
+              @consists_of_types = consists_of_types
+              @custom_message = custom_message
+
+              @attribute_data = described_class.info.public_send(attribute_type_plural).fetch(attribute_name)
+
+              @missing_option = ""
+            end
+
+            def description
+              result = "consists_of: "
+              result + consists_of_types.join(", ")
+            end
+
+            def matches?(subject)
+              if submatcher_passes?(subject)
+                true
+              else
+                @missing_option = build_missing_option
+
+                false
+              end
+            end
+
+            private
+
+            attr_reader :described_class,
+                        :attribute_type,
+                        :attribute_type_plural,
+                        :attribute_name,
+                        :option_types,
+                        :consists_of_types,
+                        :custom_message,
+                        :attribute_data
+
+            def submatcher_passes?(_subject)
+              attribute_consists_of = Array(attribute_data.fetch(:consists_of).fetch(:type) || [])
+
+              matched = attribute_consists_of.difference(consists_of_types).empty?
+
+              matched &&= attribute_consists_of_message.casecmp(custom_message).zero? if custom_message.present?
+
+              matched
+            end
+
+            def attribute_consists_of_message # rubocop:disable Metrics/MethodLength, Metrics/AbcSize
+              attribute_consists_of_message = attribute_data.fetch(:consists_of).fetch(:message)
+
+              if attribute_consists_of_message.nil?
+                I18n.t(
+                  "servactory.#{attribute_type_plural}.validations.required.default_error.for_collection",
+                  service_class_name: described_class.name,
+                  "#{attribute_type}_name": attribute_name
+                )
+              elsif attribute_consists_of_message.is_a?(Proc)
+                input_work = attribute_data.fetch(:work)
+
+                attribute_consists_of_message.call(
+                  input: input_work,
+                  expected_type: String,
+                  given_type: Servactory::TestKit::FakeType.new.class.name
+                )
+              else
+                attribute_consists_of_message
+              end
+            end
+
+            def build_missing_option # rubocop:disable Metrics/MethodLength, Metrics/AbcSize
+              attribute_consists_of = Array(attribute_data.fetch(:consists_of).fetch(:type) || [])
+
+              unless attribute_consists_of.difference(consists_of_types).empty?
+                text_about_types = option_types.size > 1 ? "the following types" : "type"
+
+                return <<~MESSAGE
+                  should be a collection consisting of #{text_about_types}
+
+                    expected #{consists_of_types.inspect}
+                         got #{attribute_consists_of.inspect}
+                MESSAGE
+              end
+
+              if custom_message.present? && !attribute_consists_of_message.casecmp(custom_message).zero?
+                return <<~MESSAGE
+                  should be a collection with a message
+
+                    expected #{custom_message.inspect}
+                         got #{attribute_consists_of_message.inspect}
+                MESSAGE
+              end
+
+              <<~MESSAGE
+                got an unexpected case when using `consists_of`
+
+                Please try to build an example based on the documentation.
+                Or report your problem to us:
+
+                  https://github.com/servactory/servactory/issues
+              MESSAGE
+            end
+          end
+        end
+      end
+    end
+  end
+end

data/lib/servactory/test_kit/rspec/matchers/have_service_attribute_matchers/inclusion_matcher.rb

@@ -0,0 +1,70 @@
+# frozen_string_literal: true
+
+module Servactory
+  module TestKit
+    module Rspec
+      module Matchers
+        module HaveServiceAttributeMatchers
+          class InclusionMatcher
+            attr_reader :missing_option
+
+            def initialize(described_class, attribute_type, attribute_name, values)
+              @described_class = described_class
+              @attribute_type = attribute_type
+              @attribute_type_plural = attribute_type.to_s.pluralize.to_sym
+              @attribute_name = attribute_name
+              @values = values
+
+              @attribute_data = described_class.info.public_send(attribute_type_plural).fetch(attribute_name)
+
+              @missing_option = ""
+            end
+
+            def description
+              "inclusion: #{values.join(', ')}"
+            end
+
+            def matches?(subject)
+              if submatcher_passes?(subject)
+                true
+              else
+                @missing_option = build_missing_option
+
+                false
+              end
+            end
+
+            private
+
+            attr_reader :described_class,
+                        :attribute_type,
+                        :attribute_type_plural,
+                        :attribute_name,
+                        :values,
+                        :attribute_data
+
+            def submatcher_passes?(_subject)
+              attribute_inclusion = attribute_data.fetch(:inclusion)
+              attribute_inclusion_in = attribute_inclusion.fetch(:in)
+
+              attribute_inclusion_in.difference(values).empty? &&
+                values.difference(attribute_inclusion_in).empty?
+            end
+
+            def build_missing_option
+              attribute_inclusion = attribute_data.fetch(:inclusion)
+              attribute_inclusion_in = attribute_inclusion.fetch(:in)
+
+              <<~MESSAGE
+                should include the expected values
+
+                  expected #{values.inspect}
+                       got #{attribute_inclusion_in.inspect}
+              MESSAGE
+            end
+          end
+        end
+      end
+    end
+  end
+end

data/lib/servactory/test_kit/rspec/matchers/have_service_attribute_matchers/must_matcher.rb

@@ -0,0 +1,61 @@
+# frozen_string_literal: true
+
+module Servactory
+  module TestKit
+    module Rspec
+      module Matchers
+        module HaveServiceAttributeMatchers
+          class MustMatcher
+            attr_reader :missing_option
+
+            def initialize(described_class, attribute_type, attribute_name, must_names)
+              @described_class = described_class
+              @attribute_type = attribute_type
+              @attribute_type_plural = attribute_type.to_s.pluralize.to_sym
+              @attribute_name = attribute_name
+              @must_names = must_names
+
+              @attribute_data = described_class.info.public_send(attribute_type_plural).fetch(attribute_name)
+
+              @missing_option = ""
+            end
+
+            def description
+              "must: #{must_names.join(', ')}"
+            end
+
+            def matches?(subject)
+              if submatcher_passes?(subject)
+                true
+              else
+                @missing_option = build_missing_option
+
+                false
+              end
+            end
+
+            private
+
+            attr_reader :described_class,
+                        :attribute_type,
+                        :attribute_type_plural,
+                        :attribute_name,
+                        :must_names,
+                        :attribute_data
+
+            def submatcher_passes?(_subject)
+              attribute_must = attribute_data.fetch(:must)
+
+              attribute_must.keys.difference(must_names).empty? &&
+                must_names.difference(attribute_must.keys).empty?
+            end
+
+            def build_missing_option
+              "should #{must_names.join(', ')}"
+            end
+          end
+        end
+      end
+    end
+  end
+end