convenient_service 0.5.0 → 0.6.0

data/lib/convenient_service/examples/standard/request_params/utils/integer/safe_parse.rb

@@ -0,0 +1,31 @@
+# frozen_string_literal: true
+
+##
+#
+#
+module ConvenientService
+  module Examples
+    module Standard
+      module RequestParams
+        module Utils
+          module Integer
+            ##
+            # TODO: Specs.
+            #
+            class SafeParse < Support::Command
+              attr_reader :object
+
+              def initialize(object)
+                @object = object
+              end
+
+              def call
+                ::Kernel.Integer(object, exception: false)
+              end
+            end
+          end
+        end
+      end
+    end
+  end
+end

data/lib/convenient_service/examples/standard/request_params/utils/integer.rb

@@ -0,0 +1,25 @@
+# frozen_string_literal: true
+
+##
+# @internal
+#   NOTE: `require_relative "integer/safe_parse"` does NOT work. Why?
+#
+require_relative "integer/safe_parse"
+
+module ConvenientService
+  module Examples
+    module Standard
+      module RequestParams
+        module Utils
+          module Integer
+            class << self
+              def safe_parse(string)
+                SafeParse.call(string)
+              end
+            end
+          end
+        end
+      end
+    end
+  end
+end

data/lib/convenient_service/examples/standard/request_params/utils/json/safe_parse.rb

@@ -0,0 +1,40 @@
+# frozen_string_literal: true
+
+##
+# Tries to parse a JSON string and return the corresponding JSON object (Ruby hash, array, etc).
+# Returns default value when fails to parse (default value is set to `nil` by default).
+#
+# IMPORTANT: `JSON::ParseError` is not the only exception that can be raised by `JSON.parse`.
+# Check this link (`Ctrl + f' for `error'):
+# https://github.com/ruby/ruby/blob/master/ext/json/lib/json.rb
+#
+module ConvenientService
+  module Examples
+    module Standard
+      module RequestParams
+        module Utils
+          module JSON
+            class SafeParse < Support::Command
+              attr_reader :json_string, :default_value
+
+              def initialize(json_string, default_value: nil)
+                @json_string = json_string
+                @default_value = default_value
+              end
+
+              def call
+                return default_value unless json_string.instance_of?(::String)
+
+                begin
+                  ::JSON.parse(json_string)
+                rescue
+                  default_value
+                end
+              end
+            end
+          end
+        end
+      end
+    end
+  end
+end

data/lib/convenient_service/examples/standard/request_params/utils/json.rb

@@ -0,0 +1,21 @@
+# frozen_string_literal: true
+
+require_relative "json/safe_parse"
+
+module ConvenientService
+  module Examples
+    module Standard
+      module RequestParams
+        module Utils
+          module JSON
+            class << self
+              def safe_parse(json_string, default_value: nil)
+                SafeParse.call(json_string, default_value: default_value)
+              end
+            end
+          end
+        end
+      end
+    end
+  end
+end

data/lib/convenient_service/examples/standard/request_params/utils/object/blank.rb

@@ -0,0 +1,34 @@
+# frozen_string_literal: true
+
+##
+#
+#
+module ConvenientService
+  module Examples
+    module Standard
+      module RequestParams
+        module Utils
+          module Object
+            ##
+            # TODO: Specs.
+            #
+            class Blank < Support::Command
+              attr_reader :object
+
+              def initialize(object)
+                @object = object
+              end
+
+              ##
+              # https://api.rubyonrails.org/classes/Object.html#method-i-blank-3F
+              #
+              def call
+                object.respond_to?(:empty?) ? !!object.empty? : !object
+              end
+            end
+          end
+        end
+      end
+    end
+  end
+end

data/lib/convenient_service/examples/standard/request_params/utils/object/present.rb

@@ -0,0 +1,31 @@
+# frozen_string_literal: true
+
+##
+#
+#
+module ConvenientService
+  module Examples
+    module Standard
+      module RequestParams
+        module Utils
+          module Object
+            ##
+            # TODO: Specs.
+            #
+            class Present < Support::Command
+              attr_reader :object
+
+              def initialize(object)
+                @object = object
+              end
+
+              def call
+                Utils::Object.blank?(object)
+              end
+            end
+          end
+        end
+      end
+    end
+  end
+end

data/lib/convenient_service/examples/standard/request_params/utils/object.rb

@@ -0,0 +1,26 @@
+# frozen_string_literal: true
+
+require_relative "object/blank"
+require_relative "object/present"
+
+module ConvenientService
+  module Examples
+    module Standard
+      module RequestParams
+        module Utils
+          module Object
+            class << self
+              def blank?(object)
+                Blank.call(object)
+              end
+
+              def present?(object)
+                Present.call(object)
+              end
+            end
+          end
+        end
+      end
+    end
+  end
+end

data/lib/convenient_service/examples/standard/request_params/utils.rb

@@ -0,0 +1,7 @@
+# frozen_string_literal: true
+
+require_relative "utils/array"
+require_relative "utils/http"
+require_relative "utils/integer"
+require_relative "utils/json"
+require_relative "utils/object"

data/lib/convenient_service/examples/standard/request_params.rb

@@ -0,0 +1,48 @@
+# frozen_string_literal: true
+
+require_relative "request_params/constants"
+require_relative "request_params/entities"
+require_relative "request_params/services"
+require_relative "request_params/utils"
+
+##
+# @since 0.3.0
+#
+# @internal
+#   Usage example:
+#
+#     http_string =
+#       <<~TEXT
+#         POST /rules/1000000.json HTTP/1.1
+#         User-Agent: Mozilla/5.0 (Windows NT 10.0; Win64; x64) AppleWebKit/537.36 (KHTML, like Gecko) Chrome/108.0.0.0 Safari/537.36
+#         Host: code-review.com
+#         Content-Type: application/json; charset=utf-8
+#         Content-Length: 134
+#         Accept-Language: en-us
+#         Accept-Encoding: gzip, deflate
+#         Connection: Keep-Alive
+#
+#         {"title":"Avoid error shadowing","description":"Check the official User Docs","tags":["error-shadowing"]}
+#       TEXT
+#
+#     request = ConvenientService::Examples::Standard::RequestParams::Entities::Request.new(http_string:)
+#
+#     ConvenientService::Examples::Standard::RequestParams.prepare(request)
+#
+#   - https://developer.mozilla.org/en-US/docs/Web/HTTP/Basics_of_HTTP/MIME_types
+#   - https://www.whatismybrowser.com/guides/the-latest-user-agent/chrome
+#   - https://www.tutorialspoint.com/http/http_requests.htm
+#
+module ConvenientService
+  module Examples
+    module Standard
+      module RequestParams
+        class << self
+          def prepare(request)
+            Services::Prepare[request: request]
+          end
+        end
+      end
+    end
+  end
+end

data/lib/convenient_service/rspec/matchers/custom/delegate_to/entities/matcher/commands/generate_printable_method.rb

@@ -0,0 +1,50 @@
+# frozen_string_literal: true
+
+module ConvenientService
+  module RSpec
+    module Matchers
+      module Custom
+        class DelegateTo
+          module Entities
+            class Matcher
+              module Commands
+                class GeneratePrintableMethod < Support::Command
+                  ##
+                  # @!attribute [r] object
+                  #   @return [Object] Can be any type.
+                  #
+                  attr_reader :object
+
+                  ##
+                  # @!attribute [r] method
+                  #   @return [Symbol, String]
+                  #
+                  attr_reader :method
+
+                  ##
+                  # @param object [Object] Can by any type.
+                  # @param method [Symbol, String]
+                  # @return [void]
+                  #
+                  def initialize(object:, method:)
+                    @object = object
+                    @method = method
+                  end
+
+                  def call
+                    case Utils::Object.resolve_type(object)
+                    when "class", "module"
+                      "#{object}.#{method}"
+                    when "instance"
+                      "#{object.class}##{method}"
+                    end
+                  end
+                end
+              end
+            end
+          end
+        end
+      end
+    end
+  end
+end

data/lib/convenient_service/rspec/matchers/custom/delegate_to/entities/matcher/commands.rb

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

data/lib/convenient_service/rspec/matchers/custom/delegate_to/entities/matcher/entities/chainings/sub_matchers/arguments/commands/apply_stub_to_track_delegations.rb

@@ -0,0 +1,78 @@
+# frozen_string_literal: true
+
+module ConvenientService
+  module RSpec
+    module Matchers
+      module Custom
+        class DelegateTo
+          module Entities
+            class Matcher
+              module Entities
+                module Chainings
+                  module SubMatchers
+                    class Arguments < Chainings::SubMatchers::Base
+                      module Commands
+                        class ApplyStubToTrackDelegations < Support::Command
+                          ##
+                          # @internal
+                          #   NOTE: `include ::RSpec::Mocks::ExampleMethods`.
+                          #   - https://github.com/rspec/rspec-mocks/blob/v3.11.1/lib/rspec/mocks/example_methods.rb
+                          #   - https://github.com/rspec/rspec-mocks/blob/main/lib/rspec/mocks/example_methods.rb
+                          #
+                          include ::RSpec::Mocks::ExampleMethods
+
+                          ##
+                          # @return [ConvenientService::RSpec::Matchers::Custom::DelegateTo]
+                          #
+                          attr_reader :matcher
+
+                          ##
+                          # @param matcher [ConvenientService::RSpec::Matchers::Custom::DelegateTo]
+                          # @return [void]
+                          #
+                          def initialize(matcher:)
+                            @matcher = matcher
+                          end
+
+                          def call
+                            ##
+                            # NOTE: RSpec `allow(object).to receive(method).with(*args, **kwargs)` does NOT support block.
+                            # https://github.com/rspec/rspec-mocks/issues/1182#issuecomment-679820352
+                            #
+                            # NOTE: RSpec `allow(object).to receive(method) do` does NOT support `and_call_original`.
+                            # https://github.com/rspec/rspec-mocks/issues/774#issuecomment-54245277
+                            #
+                            # NOTE: That is why `and_wrap_original` is used.
+                            # https://relishapp.com/rspec/rspec-mocks/docs/configuring-responses/wrapping-the-original-implementation
+                            #
+                            allow(matcher.object).to receive(matcher.method).and_wrap_original do |original, *actual_args, **actual_kwargs, &actual_block|
+                              ##
+                              # TODO: Add backtrace for easier reason tracing.
+                              #
+                              matcher.delegations << Entities::Delegation.new(
+                                object: matcher.object,
+                                method: matcher.method,
+                                args: actual_args,
+                                kwargs: actual_kwargs,
+                                block: actual_block
+                              )
+
+                              ##
+                              # NOTE: Imitates `and_call_original`.
+                              #
+                              original.call(*actual_args, **actual_kwargs, &actual_block) if matcher.should_call_original?
+                            end
+                          end
+                        end
+                      end
+                    end
+                  end
+                end
+              end
+            end
+          end
+        end
+      end
+    end
+  end
+end

data/lib/convenient_service/rspec/matchers/custom/delegate_to/entities/matcher/entities/chainings/sub_matchers/arguments/commands/generate_printable_arguments.rb

@@ -0,0 +1,100 @@
+# frozen_string_literal: true
+
+module ConvenientService
+  module RSpec
+    module Matchers
+      module Custom
+        class DelegateTo
+          module Entities
+            class Matcher
+              module Entities
+                module Chainings
+                  module SubMatchers
+                    class Arguments < Chainings::SubMatchers::Base
+                      module Commands
+                        class GeneratePrintableArguments < Support::Command
+                          include Support::Delegate
+
+                          ##
+                          # @!attribute [r] arguments
+                          #   @return [ConvenientService::RSpec::Matchers::Custom::DelegateTo::Entities::Arguments]
+                          #
+                          attr_reader :arguments
+
+                          ##
+                          # @return [Array]
+                          #
+                          delegate :args, to: :arguments
+
+                          ##
+                          # @return [Hash]
+                          #
+                          delegate :kwargs, to: :arguments
+
+                          ##
+                          # @return [Proc]
+                          #
+                          delegate :block, to: :arguments
+
+                          ##
+                          # @param arguments [ConvenientService::RSpec::Matchers::Custom::DelegateTo::Entities::Arguments]
+                          #
+                          def initialize(arguments:)
+                            @arguments = arguments
+                          end
+
+                          ##
+                          # @return [String]
+                          #
+                          def call
+                            return "" if arguments.null_arguments?
+
+                            text =
+                              if args.any? && kwargs.any?
+                                "(#{printable_args}, #{printable_kwargs})"
+                              elsif args.any?
+                                "(#{printable_args})"
+                              elsif kwargs.any?
+                                "(#{printable_kwargs})"
+                              else
+                                "()"
+                              end
+
+                            text += " #{printable_block}" if block
+
+                            text
+                          end
+
+                          ##
+                          # @return [String]
+                          #
+                          def printable_args
+                            args.map(&:inspect).join(", ")
+                          end
+
+                          ##
+                          # @return [String]
+                          #
+                          def printable_kwargs
+                            kwargs.map { |key, value| "#{key}: #{value.inspect}" }.join(", ")
+                          end
+
+                          ##
+                          # @return [String]
+                          #
+                          def printable_block
+                            block ? Utils::Proc.display(block) : ""
+                          end
+                        end
+                      end
+                    end
+                  end
+                end
+              end
+            end
+          end
+        end
+      end
+    end
+  end
+end

data/lib/convenient_service/rspec/matchers/custom/delegate_to/entities/matcher/entities/chainings/sub_matchers/arguments/commands.rb

@@ -0,0 +1,4 @@
+# frozen_string_literal: true
+
+require_relative "commands/apply_stub_to_track_delegations"
+require_relative "commands/generate_printable_arguments"

data/lib/convenient_service/rspec/matchers/custom/delegate_to/entities/matcher/entities/chainings/sub_matchers/arguments.rb

@@ -0,0 +1,95 @@
+# frozen_string_literal: true
+
+require_relative "arguments/commands"
+
+module ConvenientService
+  module RSpec
+    module Matchers
+      module Custom
+        class DelegateTo
+          module Entities
+            class Matcher
+              module Entities
+                module Chainings
+                  module SubMatchers
+                    class Arguments < Chainings::SubMatchers::Base
+                      ##
+                      # @return [void]
+                      #
+                      def apply_stubs!
+                        Commands::ApplyStubToTrackDelegations.call(matcher: matcher)
+                      end
+
+                      ##
+                      # @param block_expectation_value [Object]
+                      # @return [Boolean]
+                      #
+                      def matches?(block_expectation_value)
+                        super
+
+                        matcher.delegations.any? { |delegation| matches_arguments?(delegation.arguments) }
+                      end
+
+                      ##
+                      # @return [String]
+                      #
+                      # @internal
+                      #   TODO: Prettier message.
+                      #
+                      def failure_message
+                        <<~MESSAGE.chomp
+                          #{failure_message_expected_part}
+
+                          #{failure_message_got_part}
+                        MESSAGE
+                      end
+
+                      ##
+                      # @return [String]
+                      #
+                      def failure_message_when_negated
+                        "expected `#{matcher.printable_block_expectation}` NOT to delegate to `#{matcher.printable_method}` #{printable_expected_arguments} at least once, but it did."
+                      end
+
+                      ##
+                      # @return [String]
+                      #
+                      def printable_actual_arguments
+                        return "" if matcher.delegations.none?
+
+                        matcher.delegations
+                          .map { |delegation| Commands::GeneratePrintableArguments.call(arguments: delegation.arguments) }
+                          .join(", ")
+                          .prepend("with ")
+                      end
+
+                      private
+
+                      def failure_message_expected_part
+                        "expected `#{matcher.printable_block_expectation}` to delegate to `#{matcher.printable_method}` #{printable_expected_arguments} at least once, but it didn't."
+                      end
+
+                      ##
+                      # @return [String]
+                      #
+                      # @internal
+                      #   TODO: String diff.
+                      #
+                      def failure_message_got_part
+                        if matcher.delegations.any?
+                          "got delegated #{printable_actual_arguments}"
+                        else
+                          "got not delegated at all"
+                        end
+                      end
+                    end
+                  end
+                end
+              end
+            end
+          end
+        end
+      end
+    end
+  end
+end