convenient_service 0.1.0

data/lib/convenient_service/utils/proc/exec_config.rb

@@ -0,0 +1,136 @@
+# frozen_string_literal: true
+
+module ConvenientService
+  module Utils
+    module Proc
+      class ExecConfig < Support::Command
+        ##
+        # @!attribute [r] object
+        #   @return [Object] Can be any type.
+        #
+        attr_reader :object
+
+        ##
+        # @!attribute [r] proc
+        #   @return [Proc]
+        #
+        attr_reader :proc
+
+        ##
+        # @param proc [Proc]
+        # @param object [Object] Can be any type.
+        # @return [void]
+        #
+        def initialize(proc, object)
+          @proc = proc
+          @object = object
+        end
+
+        ##
+        # @return [Object] Can be any type.
+        #
+        # @example Preparation.
+        #   class Foo
+        #     class << self
+        #       def stack
+        #         @stack ||= SomeMiddlewareStack.new
+        #       end
+        #
+        #       def configure(&block)
+        #         ConvenientService::Utils::Proc.exec_config(block, stack)
+        #       end
+        #
+        #       def test
+        #       end
+        #     end
+        #   end
+        #
+        # @example First form - no arguments. Block is executed inside the object context (`stack` in this particular case, see preparation example).
+        #   class Foo
+        #     configure do
+        #       use SomeMiddleware
+        #
+        #       test # Raises Exception since `test` is NOT defined in `stack`.
+        #     end
+        #   end
+        #
+        # @example Second form - one argument. Block is executed in the enclosing context.
+        #   class Foo
+        #     configure do |stack|
+        #       stack.use SomeMiddleware
+        #
+        #       test # Works.
+        #     end
+        #   end
+        #
+        # @note Second form allows to access methods from the enclosing context (like `test` in examples).
+        #
+        # @internal
+        #   TODO: Stronger check whether `proc` receives exactly one mandatory positional argument.
+        #
+        def call
+          proc_has_one_positional_argument? ? proc.call(object) : object.instance_exec(&proc)
+        end
+
+        private
+
+        ##
+        # @return [Boolean]
+        #
+        # @internal
+        #   NOTE: More about `parameters`, `:req`, `:opt`.
+        #   - https://jemma.dev/blog/ruby-method-parameters
+        #   - https://ruby-doc.org/core-2.7.0/Proc.html#method-i-parameters
+        #   - https://ruby-doc.org/core-2.7.0/Method.html#method-i-parameters
+        #
+        #   NOTE: `Proc#arity` is ambiguous. It can return `1` for different sets of arguments.
+        #   https://ruby-doc.org/core-2.7.0/Proc.html#method-i-arity
+        #
+        #   For example:
+        #     proc { |a| }.arity
+        #     # => 1
+        #
+        #     proc { |a:, b:, c: 0| }.arity
+        #     # => 1
+        #
+        def proc_has_one_positional_argument?
+          return false unless proc.parameters.one?
+
+          return false unless acceptable_proc_parameter_types.include?(proc_first_parameter_type)
+
+          true
+        end
+
+        ##
+        # @return [Array]
+        #
+        # @note
+        #   proc { |a| }.parameters
+        #   # => [[:opt, :a]]
+        #
+        #   proc { |a = 0| }.parameters
+        #   [[:opt, :a]]
+        #
+        #   ->(a) {}.parameters
+        #   # => [[:req, :a]]
+        #
+        #   ->(a = 0) {}.parameters
+        #   [[:opt, :a]]
+        #
+        def acceptable_proc_parameter_types
+          proc.lambda? ? [:req, :opt] : [:opt]
+        end
+
+        ##
+        # @return [Symbol]
+        #
+        # @internal
+        #   See `ConvenientService::Utils::Proc#acceptable_proc_parameter_types` why `first.first`.
+        #
+        def proc_first_parameter_type
+          proc.parameters.first.first
+        end
+      end
+    end
+  end
+end

data/lib/convenient_service/utils/proc.rb

@@ -0,0 +1,20 @@
+# frozen_string_literal: true
+
+require_relative "proc/conjunct"
+require_relative "proc/exec_config"
+
+module ConvenientService
+  module Utils
+    module Proc
+      class << self
+        def conjunct(...)
+          Conjunct.call(...)
+        end
+
+        def exec_config(...)
+          ExecConfig.call(...)
+        end
+      end
+    end
+  end
+end

data/lib/convenient_service/utils/string/camelize.rb

@@ -0,0 +1,56 @@
+# frozen_string_literal: true
+
+module ConvenientService
+  module Utils
+    module String
+      ##
+      # Converts strings to UpperCamelCase (`capitalize_first_letter` option is set to `true` by default).
+      # Implementation is very basic just to serve the need of this library.
+      # More comprehensive solution can be found in Rails, for example:
+      # - https://github.com/rails/rails/blob/5aaaa1630ae9a71b3c3ecc4dc46074d678c08d67/activesupport/lib/active_support/core_ext/string/inflections.rb#L103
+      # - https://github.com/rails/rails/blob/5aaaa1630ae9a71b3c3ecc4dc46074d678c08d67/activesupport/lib/active_support/inflector/methods.rb#L53
+      #
+      class Camelize < Support::Command
+        ##
+        # @!attribute [r] string
+        #   @return [#to_s]
+        #
+        attr_reader :string
+
+        ##
+        # @!attribute [r] capitalize_first_letter
+        #   @return [Boolean]
+        #
+        attr_reader :capitalize_first_letter
+
+        ##
+        # @param string [Symbol, String]
+        # @return [void]
+        #
+        def initialize(string, capitalize_first_letter: true)
+          @string = string.to_s
+          @capitalize_first_letter = capitalize_first_letter
+        end
+
+        ##
+        # @return [String]
+        #
+        def call
+          camelized = string.split(/[:_?!\-\ ]/).map { |part| upcase_first_char(part) }.join
+
+          camelized[0] = camelized[0].downcase unless capitalize_first_letter
+
+          camelized
+        end
+
+        private
+
+        def upcase_first_char(part)
+          return part if part.empty?
+
+          "#{part[0].upcase}#{part[1..]}"
+        end
+      end
+    end
+  end
+end

data/lib/convenient_service/utils/string.rb

@@ -0,0 +1,15 @@
+# frozen_string_literal: true
+
+require_relative "string/camelize"
+
+module ConvenientService
+  module Utils
+    module String
+      class << self
+        def camelize(...)
+          Camelize.call(...)
+        end
+      end
+    end
+  end
+end

data/lib/convenient_service/utils.rb

@@ -0,0 +1,10 @@
+# frozen_string_literal: true
+
+require_relative "utils/array"
+require_relative "utils/bool"
+require_relative "utils/hash"
+require_relative "utils/method"
+require_relative "utils/module"
+require_relative "utils/proc"
+require_relative "utils/string"
+require_relative "utils/object"

data/lib/convenient_service/version.rb

@@ -0,0 +1,5 @@
+# frozen_string_literal: true
+
+module ConvenientService
+  VERSION = "0.1.0"
+end

data/lib/convenient_service.rb

@@ -0,0 +1,31 @@
+# frozen_string_literal: true
+
+##
+# @internal
+#   Convenient Service Dependencies.
+#
+require_relative "convenient_service/dependencies"
+
+##
+# @internal
+#   Convenient Service Inner Tools and Utilities.
+#
+require_relative "convenient_service/logger"
+require_relative "convenient_service/error"
+require_relative "convenient_service/support"
+require_relative "convenient_service/utils"
+require_relative "convenient_service/version"
+
+##
+# @internal
+#   Convenient Service Core.
+#
+require_relative "convenient_service/core"
+
+##
+# @internal
+#   Convenient Service Default Plugins/Extensions.
+#
+require_relative "convenient_service/common"
+require_relative "convenient_service/service"
+require_relative "convenient_service/configs"