convenient_service 0.8.0 → 0.10.0

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA256:
-  metadata.gz: d53f96dab5d2b97b26168f4859dc0daefe41c8768e83e607d13234c2c7d77101
-  data.tar.gz: c6d5a9d30e5c3c768f556eb7d84b558099fcbeb96dbff655b7bd2b553435a26a
+  metadata.gz: 9ae92003a48bd04299fc7d8d6036c3d1c94e1a0e2a436c645969350bc3653a6a
+  data.tar.gz: 177c46a70660b06e1985c4653cfc2ade49c07e9353880847c19b41e5017d3a05
 SHA512:
-  metadata.gz: 9f3fb867003d44c6786446fdb2baac4550bd6ac8f34ee9196ee310912c4eb2084f40dc731dce8a2af7ac8a963d6a3579c6e886ad28251c4bf5a9a08ca290a6d2
-  data.tar.gz: e24704e463ac31d3f65a4c9a5777617157bdebb62ab785e92f3f18125d8968e5c3a6d44368553c706c9f8bab0ce7bd8f938ce53ebc1df68585493738533ef2cb
+  metadata.gz: 80e69d94ebbd681b3d9aaabd78367b3a104e3e452b596c5cfbf3b32ee6a2855b1352712ee0645c095eed9e66fdd6337be27ff2b9eb14bebf61166314db3d7d40
+  data.tar.gz: 28bea96a05480a11360d261b853039fbc7fd364a2a495280cc457e083d62271b66ed861f089a9ad0172910976cfa1326c53a599fb2bf91ebbca68bba5e688e14

data/CHANGELOG.md

@@ -1,5 +1,39 @@
 # Changelog
 
+## [0.10.0](https://github.com/marian13/convenient_service/compare/v0.9.0...v0.10.0) (2023-03-01)
+
+
+### Features
+
+* **utils:** introduce Utils::String.demodulize ([87a145a](https://github.com/marian13/convenient_service/commit/87a145a7742e1fce04fa40917dae6ee61e811c71))
+
+
+### Bug Fixes
+
+* **be_result:** commit config manually ([658e314](https://github.com/marian13/convenient_service/commit/658e3147cad50cb7226c8530227e704bb4c30945))
+* **can_have_user_provided_entity:** use demodulized proto entity name ([f25e63c](https://github.com/marian13/convenient_service/commit/f25e63c23a9407ec8cc513311de506781e3cb5ca))
+* **has_result_steps:** no validate ([6c14a57](https://github.com/marian13/convenient_service/commit/6c14a572b8fa2dfcb3afef26e64859bb67ac9729))
+* **rescues_result_unhandled_exceptions:** add indentation for all message lines ([6458103](https://github.com/marian13/convenient_service/commit/6458103c362c66da42587b1a0bec4935b42606ac))
+* **rescues_result_unhandled_exceptions:** use formatted message and class for cause ([c75c389](https://github.com/marian13/convenient_service/commit/c75c3891158ea58d28d8de3718a6296565a1cd84))
+
+## [0.9.0](https://github.com/marian13/convenient_service/compare/v0.8.0...v0.9.0) (2023-02-22)
+
+
+### ⚠ BREAKING CHANGES
+
+* **export:** add a logic that forbids to use export in classes ([ca81536a](https://github.com/marian13/convenient_service/commit/ca81536a3080661cb762d549f4ef3ce1456bc566))
+
+
+### Features
+
+* **has_result_short_syntax:** introduce Result#ud, Result#um, Result#uc ([95856c9](https://github.com/marian13/convenient_service/commit/95856c921c14888a3253f1c3d12453dbfd97a14b))
+* **utils:** introduce Object#memoize_including_falsy_values ([22b2430](https://github.com/marian13/convenient_service/commit/22b2430f2a57dbded706754261defc53ec140e4f))
+
+
+### Bug Fixes
+
+* **export:** add a logic that forbids to use export in classes ([ca81536a](https://github.com/marian13/convenient_service/commit/ca81536a3080661cb762d549f4ef3ce1456bc566))
+
 ## [0.8.0](https://github.com/marian13/convenient_service/compare/v0.7.0...v0.8.0) (2023-02-20)
 
 

data/lib/convenient_service/common/plugins/can_have_user_provided_entity/commands/find_or_create_entity.rb

@@ -0,0 +1,117 @@
+# frozen_string_literal: true
+
+module ConvenientService
+  module Common
+    module Plugins
+      module CanHaveUserProvidedEntity
+        module Commands
+          class FindOrCreateEntity < Support::Command
+            ##
+            # @!attribute [r] namespace
+            #   @return [Class]
+            #
+            attr_reader :namespace
+
+            ##
+            # @!attribute [r] proto_entity
+            #   @return [Class]
+            #
+            attr_reader :proto_entity
+
+            ##
+            # @param namespace [Class]
+            # @param proto_entity [Class]
+            # @return [void]
+            #
+            def initialize(namespace:, proto_entity:)
+              @namespace = namespace
+              @proto_entity = proto_entity
+            end
+
+            ##
+            # @return [void]
+            #
+            def call
+              raise Errors::ProtoEntityHasNoName.new(proto_entity: proto_entity) unless proto_entity_name
+              raise Errors::ProtoEntityHasNoConcern.new(proto_entity: proto_entity) unless proto_entity_concern
+
+              entity.include proto_entity_concern
+
+              ##
+              # @example Result for service.
+              #
+              #   klass = ConvenientService::Common::Plugins::CanHaveUserProvidedEntity::Commands::FindOrCreateEntity.call(
+              #     namespace: SomeService,
+              #     proto_entity: ConvenientService::Service::Plugins::HasResult::Entities::Result
+              #   )
+              #
+              #   ##
+              #   # `klass` is something like:
+              #   #
+              #   # class Result < ConvenientService::Service::Plugins::HasResult::Entities::Result # or just `class Result` if service (namespace) class defines its own.
+              #   #   include ConvenientService::Service::Plugins::HasResult::Entities::Result::Concern # (concern)
+              #   #
+              #   #   class << self
+              #   #     def proto_entity
+              #   #       ##
+              #   #       # NOTE: Returns `proto_entity` passed to `FindOrCreateEntity`.
+              #   #       #
+              #   #       proto_entity
+              #   #     end
+              #   #
+              #   #     def ==(other)
+              #   #       return unless other.respond_to?(:proto_entity)
+              #   #
+              #   #       self.proto_entity == other.proto_entity
+              #   #     end
+              #   #   end
+              #   # end
+              #
+              entity.class_exec(proto_entity) do |proto_entity|
+                define_singleton_method(:proto_entity) { proto_entity }
+                define_singleton_method(:==) { |other| self.proto_entity == other.proto_entity if other.respond_to?(:proto_entity) }
+
+                ##
+                # TODO: `inspect`.
+                #
+                # define_singleton_method(:inspect) { "#{entity}(Prototyped by #{proto_entity})" }
+              end
+
+              entity
+            end
+
+            private
+
+            ##
+            # @return [Class]
+            #
+            def entity
+              @entity ||= Utils::Module.get_own_const(namespace, proto_entity_demodulized_name) || ::Class.new(proto_entity)
+            end
+
+            ##
+            # @return [String, nil]
+            #
+            def proto_entity_name
+              Utils::Object.memoize_including_falsy_values(self, :@proto_entity_name) { proto_entity.name }
+            end
+
+            ##
+            # @return [String]
+            #
+            def proto_entity_demodulized_name
+              @proto_entity_demodulized_name ||= Utils::String.demodulize(proto_entity_name)
+            end
+
+            ##
+            # @return [Module]
+            #
+            def proto_entity_concern
+              Utils::Object.memoize_including_falsy_values(self, :@proto_entity_concern) { Utils::Module.get_own_const(proto_entity, :Concern) }
+            end
+          end
+        end
+      end
+    end
+  end
+end

data/lib/convenient_service/common/plugins/can_have_user_provided_entity/commands.rb

@@ -0,0 +1,3 @@
+# frozen_string_literal: true
+
+require_relative "commands/find_or_create_entity"

data/lib/convenient_service/common/plugins/can_have_user_provided_entity/container.rb

@@ -0,0 +1,17 @@
+# frozen_string_literal: true
+
+module ConvenientService
+  module Common
+    module Plugins
+      module CanHaveUserProvidedEntity
+        module Container
+          include Support::DependencyContainer::Export
+
+          export :"commands.FindOrCreateEntity" do
+            Commands::FindOrCreateEntity
+          end
+        end
+      end
+    end
+  end
+end

data/lib/convenient_service/common/plugins/can_have_user_provided_entity/errors.rb

@@ -0,0 +1,42 @@
+# frozen_string_literal: true
+
+module ConvenientService
+  module Common
+    module Plugins
+      module CanHaveUserProvidedEntity
+        module Errors
+          class ProtoEntityHasNoName < ConvenientService::Error
+            def initialize(proto_entity:)
+              message = <<~TEXT
+                Proto entity `#{proto_entity}` has no name.
+
+                In other words:
+
+                  proto_entity.name
+                  # => nil
+
+                NOTE: Anonymous classes do NOT have names. Are you passing an anonymous class?
+              TEXT
+
+              super(message)
+            end
+          end
+
+          class ProtoEntityHasNoConcern < ConvenientService::Error
+            def initialize(proto_entity:)
+              message = <<~TEXT
+                Proto entity `#{proto_entity}` has no concern.
+
+                Have a look at `ConvenientService::Service::Plugins::HasResult::Entities::Result`.
+
+                It is an example of a valid proto entity.
+              TEXT
+
+              super(message)
+            end
+          end
+        end
+      end
+    end
+  end
+end

data/lib/convenient_service/common/plugins/can_have_user_provided_entity.rb

@@ -0,0 +1,5 @@
+# frozen_string_literal: true
+
+require_relative "can_have_user_provided_entity/commands"
+require_relative "can_have_user_provided_entity/container"
+require_relative "can_have_user_provided_entity/errors"

data/lib/convenient_service/common/plugins/has_internals/commands/create_internals_class.rb

@@ -6,47 +6,32 @@ module ConvenientService
       module HasInternals
         module Commands
           class CreateInternalsClass < Support::Command
-            attr_reader :service_class
+            include Support::DependencyContainer::Import
 
-            def initialize(service_class:)
-              @service_class = service_class
-            end
-
-            def call
-              internals_class.include Entities::Internals::Concern
+            ##
+            # @!attribute [r] entity_class
+            #   @return Class
+            #
+            attr_reader :entity_class
 
-              ##
-              # class Internals < ConvenientService::Common::Plugins::HasInternals::Entities::Internals # or just `class Internals` if service class defines its own.
-              #   include ConvenientService::Common::Plugins::HasInternals::Entities::Internals::Concern
-              #
-              #   class << self
-              #     def service_class
-              #       ##
-              #       # NOTE: Returns `service_class` passed to `CreateInternalsClass`.
-              #       #
-              #       service_class
-              #     end
-              #
-              #     def ==(other)
-              #       return unless other.instance_of?(self.class)
-              #
-              #       self.service_class == other.service_class
-              #     end
-              #   end
-              # end
-              #
-              internals_class.class_exec(service_class) do |service_class|
-                define_singleton_method(:service_class) { service_class }
-                define_singleton_method(:==) { |other| self.service_class == other.service_class if other.instance_of?(self.class) }
-              end
+            ##
+            # @return Class
+            #
+            import :"commands.FindOrCreateEntity", from: Common::Plugins::CanHaveUserProvidedEntity::Container
 
-              internals_class
+            ##
+            # @param entity_class [Class]
+            # @return [void]
+            #
+            def initialize(entity_class:)
+              @entity_class = entity_class
             end
 
-            private
-
-            def internals_class
-              @internals_class ||= Utils::Module.get_own_const(service_class, :Internals) || ::Class.new(Entities::Internals)
+            ##
+            # @return [Class]
+            #
+            def call
+              commands.FindOrCreateEntity.call(namespace: entity_class, proto_entity: Entities::Internals)
             end
           end
         end

data/lib/convenient_service/common/plugins/has_internals/concern.rb

@@ -15,10 +15,7 @@ module ConvenientService
 
           class_methods do
             def internals_class
-              ##
-              # TODO: Generic `CreateInternalsClass`.
-              #
-              @internals_class ||= Commands::CreateInternalsClass.call(service_class: self)
+              @internals_class ||= Commands::CreateInternalsClass.call(entity_class: self)
             end
           end
         end

data/lib/convenient_service/common/plugins.rb

@@ -8,6 +8,7 @@ require_relative "plugins/normalizes_env"
 require_relative "plugins/caches_constructor_params"
 require_relative "plugins/caches_return_value"
 require_relative "plugins/can_be_copied"
+require_relative "plugins/can_have_user_provided_entity"
 require_relative "plugins/has_callbacks"
 require_relative "plugins/has_around_callbacks"
 require_relative "plugins/has_constructor"

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

@@ -25,6 +25,11 @@ module ConvenientService
 
               rules = []
 
+              ##
+              # IMPORTANT: Makes `result.class.include?` from the following line idempotent.
+              #
+              result.commit_config! if result.respond_to?(:commit_config!)
+
               rules << ->(result) { result.class.include?(Service::Plugins::HasResult::Entities::Result::Concern) }
 
               ##

data/lib/convenient_service/service/plugins/has_result/commands/create_result_class.rb

@@ -6,57 +6,32 @@ module ConvenientService
       module HasResult
         module Commands
           class CreateResultClass < Support::Command
+            include Support::DependencyContainer::Import
+
+            ##
+            # @!attribute [r] service_class
+            #   @return Class
+            #
             attr_reader :service_class
 
             ##
-            # @param service_class [Class]
-            # @return [void]
+            # @return Class
             #
-            def initialize(service_class:)
-              @service_class = service_class
-            end
+            import :"commands.FindOrCreateEntity", from: Common::Plugins::CanHaveUserProvidedEntity::Container
 
             ##
+            # @param service_class [Class]
             # @return [void]
             #
-            def call
-              result_class.include Entities::Result::Concern
-
-              ##
-              # class Result < ConvenientService::Service::Plugins::HasResult::Entities::Result # or just `class Result` if service class defines its own.
-              #   include ConvenientService::Service::Plugins::HasResult::Entities::Result::Concern
-              #
-              #   class << self
-              #     def service_class
-              #       ##
-              #       # NOTE: Returns `service_class` passed to `CreateResultClass`.
-              #       #
-              #       service_class
-              #     end
-              #
-              #     def ==(other)
-              #       return unless other.instance_of?(self.class)
-              #
-              #       self.service_class == other.service_class
-              #     end
-              #   end
-              # end
-              #
-              result_class.class_exec(service_class) do |service_class|
-                define_singleton_method(:service_class) { service_class }
-                define_singleton_method(:==) { |other| self.service_class == other.service_class if other.instance_of?(self.class) }
-              end
-
-              result_class
+            def initialize(service_class:)
+              @service_class = service_class
             end
 
-            private
-
             ##
             # @return [Class]
             #
-            def result_class
-              @result_class ||= Utils::Module.get_own_const(service_class, :Result) || ::Class.new(Entities::Result)
+            def call
+              commands.FindOrCreateEntity.call(namespace: service_class, proto_entity: Entities::Result)
             end
           end
         end

data/lib/convenient_service/service/plugins/has_result/concern/class_methods.rb

@@ -80,6 +80,10 @@ module ConvenientService
             # @api private
             # @return [Class]
             #
+            # @internal
+            #   NOTE: A command instead of `import` is used in order to NOT pollute the public interface.
+            #   TODO: Specs that prevent public interface accidental pollution.
+            #
             def result_class
               @result_class ||= Commands::CreateResultClass.call(service_class: self)
             end

data/lib/convenient_service/service/plugins/has_result/entities/result/plugins/{has_result_short_syntax/concern/instance_methods.rb → has_jsend_status_and_attributes/concern/class_methods.rb}

@@ -7,15 +7,9 @@ module ConvenientService
         module Entities
           class Result
             module Plugins
-              module HasResultShortSyntax
+              module HasJsendStatusAndAttributes
                 module Concern
-                  module InstanceMethods
-                    ##
-                    # NOTE: `Support::Delegate` is NOT used intentionally in order to NOT pollute the public interface.
-                    #
-                    def [](key)
-                      data[key]
-                    end
+                  module ClassMethods
                   end
                 end
               end

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

@@ -1,5 +1,6 @@
 # frozen_string_literal: true
 
+require_relative "concern/class_methods"
 require_relative "concern/instance_methods"
 
 module ConvenientService
@@ -15,6 +16,8 @@ module ConvenientService
 
                   included do |result_class|
                     result_class.include InstanceMethods
+
+                    result_class.extend ClassMethods
                   end
                 end
               end

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

@@ -0,0 +1,40 @@
+# frozen_string_literal: true
+
+module ConvenientService
+  module Service
+    module Plugins
+      module HasResult
+        module Entities
+          class Result
+            module Plugins
+              module HasJsendStatusAndAttributes
+                module Entities
+                  class Code
+                    module Concern
+                      module ClassMethods
+                        ##
+                        # @param other [Object] Can be any type.
+                        # @return [ConvenientService::Service::Plugins::HasResult::Entities::Result::Plugins::HasJsendStatusAndAttributes::Entities::Code, nil]
+                        #
+                        def cast(other)
+                          case other
+                          when ::String
+                            new(value: other.to_sym)
+                          when ::Symbol
+                            new(value: other)
+                          when Code
+                            new(value: other.value)
+                          end
+                        end
+                      end
+                    end
+                  end
+                end
+              end
+            end
+          end
+        end
+      end
+    end
+  end
+end

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

@@ -0,0 +1,65 @@
+# frozen_string_literal: true
+
+module ConvenientService
+  module Service
+    module Plugins
+      module HasResult
+        module Entities
+          class Result
+            module Plugins
+              module HasJsendStatusAndAttributes
+                module Entities
+                  class Code
+                    module Concern
+                      module InstanceMethods
+                        ##
+                        # @!attribute value [r]
+                        #   @return [Symbol]
+                        #
+                        attr_reader :value
+
+                        ##
+                        # @param value [Symbol]
+                        # @return [void]
+                        #
+                        def initialize(value:)
+                          @value = value
+                        end
+
+                        ##
+                        # @param other [Object] Can be any type.
+                        # @return [Boolean]
+                        #
+                        def ==(other)
+                          casted = cast(other)
+
+                          return unless casted
+
+                          value == casted.value
+                        end
+
+                        ##
+                        # @return [String]
+                        #
+                        def to_s
+                          @to_s ||= value.to_s
+                        end
+
+                        ##
+                        # @return [Symbol]
+                        #
+                        def to_sym
+                          @to_sym ||= value.to_sym
+                        end
+                      end
+                    end
+                  end
+                end
+              end
+            end
+          end
+        end
+      end
+    end
+  end
+end

data/lib/convenient_service/service/plugins/has_result/entities/result/plugins/has_jsend_status_and_attributes/entities/code/{class_methods.rb → concern.rb}

@@ -1,5 +1,8 @@
 # frozen_string_literal: true
 
+require_relative "concern/class_methods"
+require_relative "concern/instance_methods"
+
 module ConvenientService
   module Service
     module Plugins
@@ -10,16 +13,15 @@ module ConvenientService
               module HasJsendStatusAndAttributes
                 module Entities
                   class Code
-                    module ClassMethods
-                      def cast(other)
-                        case other
-                        when ::String
-                          new(value: other.to_sym)
-                        when ::Symbol
-                          new(value: other)
-                        when Code
-                          new(value: other.value)
-                        end
+                    module Concern
+                      include Support::Concern
+
+                      included do |code_class|
+                        code_class.include Support::Castable
+
+                        code_class.include InstanceMethods
+
+                        code_class.extend ClassMethods
                       end
                     end
                   end

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

@@ -1,6 +1,6 @@
 # frozen_string_literal: true
 
-require_relative "code/class_methods"
+require_relative "code/concern"
 
 module ConvenientService
   module Service
@@ -12,31 +12,7 @@ module ConvenientService
               module HasJsendStatusAndAttributes
                 module Entities
                   class Code
-                    include Support::Castable
-
-                    extend ClassMethods
-
-                    attr_reader :value
-
-                    def initialize(value:)
-                      @value = value
-                    end
-
-                    def ==(other)
-                      casted = cast(other)
-
-                      return unless casted
-
-                      value == casted.value
-                    end
-
-                    def to_s
-                      @to_s ||= value.to_s
-                    end
-
-                    def to_sym
-                      @to_sym ||= value.to_sym
-                    end
+                    include Concern
                   end
                 end
               end