convenient_service 0.1.0

data/lib/convenient_service/dependencies/extractions/active_support_concern/concern.rb

@@ -0,0 +1,258 @@
+# frozen_string_literal: true
+
+module ConvenientService
+  module Dependencies
+    module Extractions
+      module ActiveSupportConcern
+        ##
+        # https://github.com/marian13/rails/blob/v7.0.3.1/activesupport/lib/active_support/concern.rb
+        #
+        # A typical module looks like this:
+        #
+        #   module M
+        #     def self.included(base)
+        #       base.extend ClassMethods
+        #       base.class_eval do
+        #         scope :disabled, -> { where(disabled: true) }
+        #       end
+        #     end
+        #
+        #     module ClassMethods
+        #       ...
+        #     end
+        #   end
+        #
+        # By using <tt>ActiveSupport::Concern</tt> the above module could instead be
+        # written as:
+        #
+        #   require "active_support/concern"
+        #
+        #   module M
+        #     extend ActiveSupport::Concern
+        #
+        #     included do
+        #       scope :disabled, -> { where(disabled: true) }
+        #     end
+        #
+        #     class_methods do
+        #       ...
+        #     end
+        #   end
+        #
+        # Moreover, it gracefully handles module dependencies. Given a +Foo+ module
+        # and a +Bar+ module which depends on the former, we would typically write the
+        # following:
+        #
+        #   module Foo
+        #     def self.included(base)
+        #       base.class_eval do
+        #         def self.method_injected_by_foo
+        #           ...
+        #         end
+        #       end
+        #     end
+        #   end
+        #
+        #   module Bar
+        #     def self.included(base)
+        #       base.method_injected_by_foo
+        #     end
+        #   end
+        #
+        #   class Host
+        #     include Foo # We need to include this dependency for Bar
+        #     include Bar # Bar is the module that Host really needs
+        #   end
+        #
+        # But why should +Host+ care about +Bar+'s dependencies, namely +Foo+? We
+        # could try to hide these from +Host+ directly including +Foo+ in +Bar+:
+        #
+        #   module Bar
+        #     include Foo
+        #     def self.included(base)
+        #       base.method_injected_by_foo
+        #     end
+        #   end
+        #
+        #   class Host
+        #     include Bar
+        #   end
+        #
+        # Unfortunately this won't work, since when +Foo+ is included, its <tt>base</tt>
+        # is the +Bar+ module, not the +Host+ class. With <tt>ActiveSupport::Concern</tt>,
+        # module dependencies are properly resolved:
+        #
+        #   require "active_support/concern"
+        #
+        #   module Foo
+        #     extend ActiveSupport::Concern
+        #     included do
+        #       def self.method_injected_by_foo
+        #         ...
+        #       end
+        #     end
+        #   end
+        #
+        #   module Bar
+        #     extend ActiveSupport::Concern
+        #     include Foo
+        #
+        #     included do
+        #       self.method_injected_by_foo
+        #     end
+        #   end
+        #
+        #   class Host
+        #     include Bar # It works, now Bar takes care of its dependencies
+        #   end
+        #
+        # === Prepending concerns
+        #
+        # Just like <tt>include</tt>, concerns also support <tt>prepend</tt> with a corresponding
+        # <tt>prepended do</tt> callback. <tt>module ClassMethods</tt> or <tt>class_methods do</tt> are
+        # prepended as well.
+        #
+        # <tt>prepend</tt> is also used for any dependencies.
+        module Concern
+          class MultipleIncludedBlocks < StandardError # :nodoc:
+            def initialize
+              super "Cannot define multiple 'included' blocks for a Concern"
+            end
+          end
+
+          class MultiplePrependBlocks < StandardError # :nodoc:
+            def initialize
+              super "Cannot define multiple 'prepended' blocks for a Concern"
+            end
+          end
+
+          def self.extended(base) # :nodoc:
+            base.instance_variable_set(:@_dependencies, [])
+          end
+
+          def append_features(base) # :nodoc:
+            if base.instance_variable_defined?(:@_dependencies)
+              base.instance_variable_get(:@_dependencies) << self
+              false
+            else
+              return false if base < self
+              @_dependencies.each { |dep| base.include(dep) }
+              super
+
+              base.class_eval(&@_included_block) if instance_variable_defined?(:@_included_block)
+
+              ##
+              # NOTE: Customization compared to original `Concern` implementation.
+              # TODO: Why original `Concern` implementation uses `const_defined?(:ClassMethods)`, not `const_defined?(:ClassMethods, false)`?
+              # NOTE: Changed order to have a way to control when to include `InstanceMethods` and `ClassMethods` from `included` block.
+              #
+              base.include const_get(:InstanceMethods) if const_defined?(:InstanceMethods)
+
+              base.extend const_get(:ClassMethods) if const_defined?(:ClassMethods)
+            end
+          end
+
+          def prepend_features(base) # :nodoc:
+            if base.instance_variable_defined?(:@_dependencies)
+              base.instance_variable_get(:@_dependencies).unshift self
+              false
+            else
+              return false if base < self
+              @_dependencies.each { |dep| base.prepend(dep) }
+              super
+
+              base.class_eval(&@_prepended_block) if instance_variable_defined?(:@_prepended_block)
+
+              ##
+              # NOTE: Customization compared to original `Concern` implementation.
+              # TODO: Why original `Concern` implementation uses `const_defined?(:ClassMethods)`, not `const_defined?(:ClassMethods, false)`?
+              # NOTE: Changed order to have a way to control when to include `InstanceMethods` and `ClassMethods` from `included` block.
+              #
+              base.prepend const_get(:InstanceMethods) if const_defined?(:InstanceMethods)
+
+              base.singleton_class.prepend const_get(:ClassMethods) if const_defined?(:ClassMethods)
+            end
+          end
+
+          # Evaluate given block in context of base class,
+          # so that you can write class macros here.
+          # When you define more than one +included+ block, it raises an exception.
+          def included(base = nil, &block)
+            if base.nil?
+              if instance_variable_defined?(:@_included_block)
+                if @_included_block.source_location != block.source_location
+                  raise MultipleIncludedBlocks
+                end
+              else
+                @_included_block = block
+              end
+            else
+              super
+            end
+          end
+
+          # Evaluate given block in context of base class,
+          # so that you can write class macros here.
+          # When you define more than one +prepended+ block, it raises an exception.
+          def prepended(base = nil, &block)
+            if base.nil?
+              if instance_variable_defined?(:@_prepended_block)
+                if @_prepended_block.source_location != block.source_location
+                  raise MultiplePrependBlocks
+                end
+              else
+                @_prepended_block = block
+              end
+            else
+              super
+            end
+          end
+
+          ##
+          # NOTE: Customization compared to original `Concern` implementation.
+          #
+          def instance_methods(include_private = false, &instance_methods_module_definition)
+            ##
+            # NOTE: This `if` is propably the reason why Rails team decided to create only `class_methods` in the original Concern implementation.
+            #
+            return super(include_private) unless instance_methods_module_definition
+
+            mod = const_defined?(:InstanceMethods, false) ?
+              const_get(:InstanceMethods) :
+              const_set(:InstanceMethods, Module.new)
+
+            mod.module_eval(&instance_methods_module_definition)
+          end
+
+          # Define class methods from given block.
+          # You can define private class methods as well.
+          #
+          #   module Example
+          #     extend ActiveSupport::Concern
+          #
+          #     class_methods do
+          #       def foo; puts 'foo'; end
+          #
+          #       private
+          #         def bar; puts 'bar'; end
+          #     end
+          #   end
+          #
+          #   class Buzz
+          #     include Example
+          #   end
+          #
+          #   Buzz.foo # => "foo"
+          #   Buzz.bar # => private method 'bar' called for Buzz:Class(NoMethodError)
+          def class_methods(&class_methods_module_definition)
+            mod = const_defined?(:ClassMethods, false) ?
+              const_get(:ClassMethods) :
+              const_set(:ClassMethods, Module.new)
+
+            mod.module_eval(&class_methods_module_definition)
+          end
+        end
+      end
+    end
+  end
+end

data/lib/convenient_service/dependencies/extractions/active_support_concern.rb

@@ -0,0 +1,16 @@
+# frozen_string_literal: true
+
+##
+# @internal
+#   NOTE:
+#     Copied from `rails/rails` with some logic modification.
+#     Version: v7.0.3.1.
+#     Wrapped in a namespace `ConvenientService::Dependencies::Extractions::ActiveSupportConcern`.
+#     Added `instance_methods` that works in a similar way as `class_methods`.
+#     Also `ClassMethods` (and `InstanceMethods`) are loaded after `included` block, not as in the original implementation.
+#
+#   - https://github.com/marian13/rails/blob/v7.0.3.1/activesupport/lib/active_support/concern.rb
+#   - https://github.com/rails/rails/blob/v7.0.3.1/activesupport/lib/active_support/concern.rb
+#   - https://github.com/rails/rails
+#
+require_relative "active_support_concern/concern"

data/lib/convenient_service/dependencies/extractions/b.rb

@@ -0,0 +1,12 @@
+##
+# Works in a similar way as `p`, but for `byebug`.
+# @see https://ruby-doc.org/core-2.7.0/Kernel.html#method-i-p
+#
+def b(*args)
+  require "byebug"
+  require "byebug/core"
+
+  ::Byebug.attach
+
+  args.one? ? args.first : args
+end

data/lib/convenient_service/dependencies/extractions/byebug_syntax_highlighting.rb

@@ -0,0 +1,58 @@
+##
+# @internal
+#   Yet another hack how to enable the syntax highlighting for the byebug gem. Works for v10.0.0 and higher.
+#   (See https://gist.github.com/marian13/5dade20a431d7254db30e543167058ce)
+#
+#   WARNING: Although this hack is based on the monkey patching,
+#   use this technique for other issues in your own codebases with a precaution.
+#
+require "byebug/runner" unless defined? Byebug::VERSION
+
+if Gem::Version.new(Byebug::VERSION) >= Gem::Version.new("10.0.0")
+  module Byebug
+    class SourceFileFormatter
+      ##
+      # This is a replacement of the internal <tt>Byebug::SourceFileFormatter.file</tt> method
+      # which adds syntax highlighting capability to it.
+      #
+      # The original implementation simply returns the file path
+      # which is passed to the <tt>Byebug::SourceFileFormatter</tt> constructor just as <tt>file</tt>.
+      # (See https://github.com/deivid-rodriguez/byebug/blob/master/lib/byebug/source_file_formatter.rb#L13)
+      #
+      # The current replacement, instead of returning the original file path,
+      # returns a copy of it, where the syntax is highlighted by the Rouge gem(A pure Ruby code highlighter).
+      # (See https://github.com/rouge-ruby/rouge)
+      #
+      # In order to create a copy, it utilizes Ruby's <tt>tempfile</tt> stdlib.
+      # (See https://ruby-doc.org/stdlib-2.7.0/libdoc/tempfile/rdoc/Tempfile.html)
+      # A tempfile is automatically deleted from the underlying OS when it is garbage-collected.
+      #
+      def file
+        @highlighted_file ||=
+          begin
+            if defined? Rouge
+              source = File.read(@file)
+
+              theme     = Rouge::Themes::Monokai.new
+              formatter = Rouge::Formatters::Terminal256.new(theme)
+              lexer     = Rouge::Lexers::Ruby.new
+
+              dest = formatter.format(lexer.lex(source))
+
+              # Tempfile with the highlighted syntax is assigned to the instance variable
+              # in order to prevent its premature garbage collection.
+              @tempfile_with_highlighted_syntax = Tempfile.new.tap { |t| t.write(dest) }.tap(&:close)
+
+              @tempfile_with_highlighted_syntax.path
+            else
+              warn %q{Rouge(a pure Ruby code highlighter) is not defined. Maybe you forgot to require it? (require 'rouge')}
+
+              @file
+            end
+          end
+      end
+    end
+  end
+else
+  warn "Byebug version is lower than v10.0.0..."
+end

data/lib/convenient_service/dependencies/extractions/ruby_middleware/middleware/builder.rb

@@ -0,0 +1,194 @@
+require_relative 'logger'
+
+module ConvenientService
+  module Dependencies
+    module Extractions
+      module RubyMiddleware
+        ##
+        # https://github.com/marian13/ruby-middleware/blob/v0.4.2/lib/middleware/builder.rb
+        #
+        module Middleware
+          # This provides a DSL for building up a stack of middlewares.
+          #
+          # This code is based heavily off of `Rack::Builder` and
+          # `ActionDispatch::MiddlewareStack` in Rack and Rails, respectively.
+          #
+          # # Usage
+          #
+          # Building a middleware stack is very easy:
+          #
+          #     app = Middleware::Builder.new do |b|
+          #       b.use A
+          #       b.use B
+          #     end
+          #
+          #     # Call the middleware
+          #     app.call(7)
+          #
+          class Builder
+
+            # Initializes the builder. An optional block can be passed which
+            # will either yield the builder or be evaluated in the context of the instance.
+            #
+            # Example:
+            #
+            #     Builder.new do |b|
+            #       b.use A
+            #       b.use B
+            #     end
+            #
+            #     Builder.new do
+            #       use A
+            #       use B
+            #     end
+            #
+            # @param [Hash] opts Options hash
+            # @option opts [Class] :runner_class The class to wrap the middleware stack
+            #   in which knows how to run them.
+            # @yield [] Evaluated in this instance which allows you to use methods
+            #   like {#use} and such.
+            def initialize(opts = nil, &block)
+              opts ||= {}
+              @runner_class = opts.fetch(:runner_class, Runner)
+              @middleware_name = opts.fetch(:name, 'Middleware')
+
+              if block_given?
+                if block.arity == 1
+                  yield self
+                else
+                  instance_eval(&block)
+                end
+              end
+            end
+
+            # Returns the name of the current middleware
+            def name
+              @middleware_name
+            end
+
+            # Returns a mergeable version of the builder. If `use` is called with
+            # the return value of this method, then the stack will merge, instead
+            # of being treated as a separate single middleware.
+            def flatten
+              lambda do |env|
+                call(env)
+              end
+            end
+
+            # Adds a middleware class to the middleware stack. Any additional
+            # args and a block, if given, are saved and passed to the initializer
+            # of the middleware.
+            #
+            # @param [Class] middleware The middleware class
+            def use(middleware, *args, &block)
+              if middleware.is_a?(Builder)
+                # Merge in the other builder's stack into our own
+                stack.concat(middleware.stack)
+              else
+                stack << [middleware, args, block]
+              end
+
+              self
+            end
+
+            # Inserts a middleware at the given index or directly before the given middleware object.
+            def insert(index, middleware, *args, &block)
+              index = self.index(index) unless index.is_a?(Integer)
+              fail "no such middleware to insert before: #{index.inspect}" unless index
+              stack.insert(index, [middleware, args, block])
+            end
+
+            alias_method :insert_before, :insert
+
+            # Inserts a middleware after the given index or middleware object.
+            def insert_after(index, middleware, *args, &block)
+              index = self.index(index) unless index.is_a?(Integer)
+              fail "no such middleware to insert after: #{index.inspect}" unless index
+              insert(index + 1, middleware, *args, &block)
+            end
+
+            # Inserts a middleware before each middleware object
+            def insert_before_each(middleware, *args, &block)
+              self.stack = stack.reduce([]) do |carry, item|
+                carry.push([middleware, args, block], item)
+              end
+            end
+
+            # Inserts a middleware after each middleware object
+            def insert_after_each(middleware, *args, &block)
+              self.stack = stack.reduce([]) do |carry, item|
+                carry.push(item, [middleware, args, block])
+              end
+            end
+
+            # Replaces the given middleware object or index with the new middleware.
+            def replace(index, middleware, *args, &block)
+              index = self.index index unless index.is_a? Integer
+
+              delete(index)
+              insert(index, middleware, *args, &block)
+            end
+
+            # Deletes the given middleware object or index
+            def delete(index)
+              index = self.index(index) unless index.is_a?(Integer)
+              stack.delete_at(index)
+            end
+
+            # Runs the builder stack with the given environment.
+            def call(env = nil)
+              to_app.call(env)
+            end
+
+            def inspect
+              name+'[' + stack.map do |middleware|
+                name = middleware[0].is_a?(Proc) ? 'Proc' : middleware[0].name
+                "#{name}(#{middleware[1].join(', ')})"
+              end.join(', ') + ']'
+            end
+
+            def inject_logger logger
+              insert_before_each Middleware::Logger, logger, name
+
+              self
+            end
+
+            protected
+
+            # Returns the numeric index for the given middleware object.
+            #
+            # @param [Object] object The item to find the index for
+            # @return [Integer]
+            def index(object)
+              stack.each_with_index do |item, i|
+                return i if item[0] == object
+              end
+
+              nil
+            end
+
+            # Returns the current stack of middlewares. You probably won't
+            # need to use this directly, and it's recommended that you don't.
+            #
+            # @return [Array]
+            def stack
+              @stack ||= []
+            end
+
+            # you shouldn't use this method
+            # used for insert_before|after_each
+            # @return [Array]
+            attr_writer :stack
+
+            # Converts the builder stack to a runnable action sequence.
+            #
+            # @return [Object] A callable object
+            def to_app
+              @runner_class.new(stack.dup)
+            end
+          end
+        end
+      end
+    end
+  end
+end

data/lib/convenient_service/dependencies/extractions/ruby_middleware/middleware/logger.rb

@@ -0,0 +1,60 @@
+require 'logger'
+require 'pp'
+
+module ConvenientService
+  module Dependencies
+    module Extractions
+      module RubyMiddleware
+        ##
+        # https://github.com/marian13/ruby-middleware/blob/v0.4.2/lib/middleware/logger.rb
+        #
+        module Middleware
+
+          class Logger
+            def initialize app, logger, name = nil
+              @app = app
+              @write_to = logger
+              @middleware_name = name
+            end
+
+            def call env
+              write(
+                  way_in_message(
+                      next_middleware_name, env
+              ))
+
+              time = Time.now
+
+              @app.call(env).tap { |env|
+                write(
+                    way_out_message(
+                        next_middleware_name, (Time.now - time) * 1000.0, env
+                ))
+              }
+            end
+
+            def next_middleware_name
+              @app.class.name
+            end
+
+            def pretty_print item
+              ->(out){ PP.pp(item, out) }.('')
+            end
+
+            def way_in_message name, env
+              ' %s has been called with: %s' % [name, pretty_print(env)]
+            end
+
+            def way_out_message name, time, value
+              ' %s finished in %.0f ms and returned: %s' % [name, time, pretty_print(value)]
+            end
+
+            def write msg
+              @write_to.add(::Logger::INFO, msg.slice(0, 255).strip!, @middleware_name)
+            end
+          end
+        end
+      end
+    end
+  end
+end

data/lib/convenient_service/dependencies/extractions/ruby_middleware/middleware/runner.rb

@@ -0,0 +1,79 @@
+module ConvenientService
+  module Dependencies
+    module Extractions
+      module RubyMiddleware
+        ##
+        # https://github.com/marian13/ruby-middleware/blob/v0.4.2/lib/middleware/runner.rb
+        #
+        module Middleware
+          # This is a basic runner for middleware stacks. This runner does
+          # the default expected behavior of running the middleware stacks
+          # in order, then reversing the order.
+          class Runner
+            # A middleware which does nothing
+            EMPTY_MIDDLEWARE = ->(env) { env }
+
+            # Build a new middleware runner with the given middleware
+            # stack.
+            #
+            # Note: This class usually doesn't need to be used directly.
+            # Instead, take a look at using the {Builder} class, which is
+            # a much friendlier way to build up a middleware stack.
+            #
+            # @param [Array] stack An array of the middleware to run.
+            def initialize(stack)
+              # We need to take the stack of middleware and initialize them
+              # all so they call the proper next middleware.
+              @kickoff = build_call_chain(stack)
+            end
+
+            # Run the middleware stack with the given state bag.
+            #
+            # @param [Object] env The state to pass into as the initial
+            #   environment data. This is usual a hash of some sort.
+            def call(env)
+              # We just call the kickoff middleware, which is responsible
+              # for properly calling the next middleware, and so on and so
+              # forth.
+              @kickoff.call(env)
+            end
+
+            protected
+
+            # This takes a stack of middlewares and initializes them in a way
+            # that each middleware properly calls the next middleware.
+            def build_call_chain(stack)
+              # We need to instantiate the middleware stack in reverse
+              # order so that each middleware can have a reference to
+              # the next middleware it has to call. The final middleware
+              # is always the empty middleware, which does nothing but return.
+              stack.reverse.inject(EMPTY_MIDDLEWARE) do |next_middleware, current_middleware|
+                # Unpack the actual item
+                klass, args, block = current_middleware
+
+                # Default the arguments to an empty array. Otherwise in Ruby 1.8
+                # a `nil` args will actually pass `nil` into the class. Not what
+                # we want!
+                args ||= []
+
+                if klass.is_a?(Class)
+                  # If the klass actually is a class, then instantiate it with
+                  # the app and any other arguments given.
+                  klass.new(next_middleware, *args, &block)
+                elsif klass.respond_to?(:call)
+                  # Make it a lambda which calls the item then forwards up
+                  # the chain.
+                  lambda do |env|
+                    next_middleware.call(klass.call(env, *args))
+                  end
+                else
+                  fail "Invalid middleware, doesn't respond to `call`: #{klass.inspect}"
+                end
+              end
+            end
+          end
+        end
+      end
+    end
+  end
+end

data/lib/convenient_service/dependencies/extractions/ruby_middleware/middleware.rb

@@ -0,0 +1,8 @@
+# frozen_string_literal: true
+
+##
+# @internal
+#   https://github.com/marian13/ruby-middleware/blob/v0.4.2/lib/middleware.rb
+#
+require_relative "middleware/builder"
+require_relative "middleware/runner"