convenient_service 0.1.0

data/lib/convenient_service/examples/standard/gemfile/services/read_file_content.rb

@@ -0,0 +1,39 @@
+# frozen_string_literal: true
+
+module ConvenientService
+  module Examples
+    module Standard
+      module Gemfile
+        module Services
+          class ReadFileContent
+            include ConvenientService::Standard::Config
+
+            attr_reader :path
+
+            step :validate_path
+            step Services::AssertFileExists, in: :path
+            step Services::AssertFileNotEmpty, in: :path
+            step :result, in: :path, out: :content
+
+            def initialize(path:)
+              @path = path
+            end
+
+            def result
+              success(data: {content: ::File.read(path)})
+            end
+
+            private
+
+            def validate_path
+              return failure(path: "Path is `nil`") if path.nil?
+              return failure(path: "Path is empty") if path.empty?
+
+              success
+            end
+          end
+        end
+      end
+    end
+  end
+end

data/lib/convenient_service/examples/standard/gemfile/services/run_shell.rb

@@ -0,0 +1,37 @@
+# frozen_string_literal: true
+
+module ConvenientService
+  module Examples
+    module Standard
+      module Gemfile
+        module Services
+          class RunShell
+            include ConvenientService::Standard::Config
+
+            attr_reader :command, :debug
+
+            def initialize(command:, debug: false)
+              @command = command
+              @debug = debug
+            end
+
+            def result
+              Services::PrintShellCommand[text: command] if debug
+
+              ##
+              # NOTE: When the command exit code is 0, `system` return true, and false otherwise.
+              # - https://ruby-doc.org/core-3.1.2/Kernel.html#method-i-system
+              # - https://stackoverflow.com/a/37329716/12201472
+              #
+              if system(command)
+                success
+              else
+                error(message: "#{command} returned non-zero exit code")
+              end
+            end
+          end
+        end
+      end
+    end
+  end
+end

data/lib/convenient_service/examples/standard/gemfile/services/strip_comments.rb

@@ -0,0 +1,111 @@
+# frozen_string_literal: true
+
+##
+# Usage:
+#
+#   ConvenientService::Examples::Standard::Gemfile::Services::StripComments.result(content: "abc")
+#
+module ConvenientService
+  module Examples
+    module Standard
+      module Gemfile
+        module Services
+          class StripComments
+            include ConvenientService::Standard::Config
+
+            attr_reader :content
+
+            alias_method :content_with_comments, :content
+
+            step Services::AssertNpmPackageAvailable, in: {name: -> { "strip-comments" }}
+            step Services::RunShell, in: {command: -> { "node -e '#{js_script}' #{file_with_comments.path} #{file_without_comments.path}" }}
+            step :result, in: :file_without_comments, out: :content_without_comments
+
+            def initialize(content:)
+              @content = content
+            end
+
+            def result
+              success(data: {content_without_comments: file_without_comments.read})
+            end
+
+            private
+
+            ##
+            # NOTE: When you have no time to do something well, delegate that task to someone who already works with it all the time.
+            # That is why `strip-comments` npm package is used to remove comments.
+            #
+            def js_script
+              ##
+              # NOTE: `main` function is created in order to have an ability to use early returns.
+              #
+              # IMPORTANT: Use only double quotes inside this JS script, since it is later consumed by `node -e` option wrapped by single quoutes.
+              #
+              # TODO: Consider to use WeakRef if memory is a concern.
+              # https://ruby-doc.org/stdlib-2.5.1/libdoc/weakref/rdoc/WeakRef.html
+              #
+              # TODO: Jest tests for JS script.
+              #
+              @js_script ||= <<~JAVASCRIPT.gsub(/\n\s*/, " ")
+                const main = () => {
+                  const process = require("process");
+                  const fs = require("fs");
+
+                  /**
+                   * TODO: try/catch when "strip-comments" is not available.
+                   */
+                  const strip = require("strip-comments");
+
+                  const fileWithCommentsPath = process.argv[1];
+                  const fileWithoutCommentsPath = process.argv[2];
+                  const language = process.argv[3] || "ruby";
+
+                  if (!fileWithCommentsPath) {
+                    console.log("Error: Input file path is NOT passed.");
+
+                    process.exit(1);
+                  }
+
+                  if (!fileWithoutCommentsPath) {
+                    console.log("Error: Output file path is NOT passed.");
+
+                    process.exit(1);
+                  }
+
+                  if (!["ruby", "javascript"].includes(language)) {
+                    console.log("Error: Language " + language + " is NOT supported.");
+
+                    process.exit(1);
+                  }
+
+                  const fileWithCommentsContent = fs.readFileSync(fileWithCommentsPath, { encoding: "utf8" });
+                  const fileWithoutCommentsContent = strip(fileWithCommentsContent, { language });
+
+                  fs.writeFileSync(fileWithoutCommentsPath, fileWithoutCommentsContent, { encoding: "utf8" });
+
+                  process.exit(0);
+                };
+
+                main();
+              JAVASCRIPT
+            end
+
+            def file_with_comments
+              ##
+              # NOTE: Tempfile is used to avoid issues with escaping of quotes inside JS script.
+              #
+              @file_with_comments ||= ::Tempfile.new.tap { |tempfile| tempfile.write(content_with_comments) }.tap(&:close)
+            end
+
+            def file_without_comments
+              ##
+              # NOTE: JS script tries to fill content of the file without comments.
+              #
+              @file_without_comments ||= ::Tempfile.new
+            end
+          end
+        end
+      end
+    end
+  end
+end

data/lib/convenient_service/examples/standard/gemfile/services.rb

@@ -0,0 +1,17 @@
+# frozen_string_literal: true
+
+require_relative "services/run_shell"
+require_relative "services/assert_file_exists"
+require_relative "services/assert_file_not_empty"
+require_relative "services/assert_node_available"
+require_relative "services/assert_npm_package_available"
+require_relative "services/assert_valid_ruby_syntax"
+require_relative "services/read_file_content"
+require_relative "services/strip_comments"
+require_relative "services/parse_content"
+require_relative "services/print_shell_command"
+require_relative "services/format_header"
+require_relative "services/format_gems_without_envs"
+require_relative "services/format_gems_with_envs"
+require_relative "services/format_body"
+require_relative "services/format"

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

@@ -0,0 +1,23 @@
+# frozen_string_literal: true
+
+require_relative "gemfile/services"
+
+##
+# Usage example:
+#
+# result = ConvenientService::Examples::Standard::Gemfile.format(path: "Gemfile")
+# result = ConvenientService::Examples::Standard::Gemfile.format(path: "spec/cli/gemfile/format/fixtures/Gemfile")
+#
+module ConvenientService
+  module Examples
+    module Standard
+      module Gemfile
+        class << self
+          def format
+            Services::Format[path: path]
+          end
+        end
+      end
+    end
+  end
+end

data/lib/convenient_service/logger.rb

@@ -0,0 +1,70 @@
+# frozen_string_literal: true
+
+##
+# Usage example:
+#
+#   ConvenientService::Logger.instance
+#   ConvenientService::Logger.instance.level = ::Logger::WARN
+#   ConvenientService::Logger.instance.warn { "log message" }
+#
+# Docs:
+#
+# - https://ruby-doc.org/stdlib-3.1.0/libdoc/logger/rdoc/Logger.html
+# - https://newbedev.com/ruby-create-singleton-with-parameters
+#
+module ConvenientService
+  ##
+  # TODO: Custom matcher to track log messages.
+  #
+  class Logger < ::Logger
+    include ::Singleton
+
+    class << self
+      private
+
+      ##
+      # NOTE: `super` is `Logger.new`.
+      # https://ruby-doc.org/stdlib-3.1.0/libdoc/logger/rdoc/Logger.html#method-c-new
+      #
+      # rubocop:disable Style/GlobalStdStream
+      def new
+        super(STDOUT).tap do |logger|
+          logger.level = ENV["ACTIVE_SERVICE_LOGGER_LEVEL"] || "INFO"
+
+          logger.formatter = colored_formatter if ENV["ACTIVE_SERVICE_LOGGER_ENABLE_COLORS"] == "true"
+        end
+      end
+      # rubocop:enable Style/GlobalStdStream
+
+      def original_formatter
+        ::Logger::Formatter.new
+      end
+
+      ##
+      # https://ruby-doc.org/stdlib-2.4.0/libdoc/logger/rdoc/Logger.html#method-i-add
+      #
+      def colored_formatter
+        return original_formatter unless defined? ::Paint
+
+        proc do |severity, datetime, progname, message|
+          log = original_formatter.call(severity, datetime, progname, message)
+
+          case severity.to_s.downcase
+          when "info" then ::Paint[log, :cyan, :bold]
+          when "warn" then ::Paint[log, :yellow, :bold]
+          when "error" then ::Paint[log, :red, :bold]
+          when "fatal" then ::Paint[log, :red, :underline]
+          when "debug" then ::Paint[log, :magenta, :bold]
+          else log
+          end
+        end
+      end
+    end
+  end
+
+  class << self
+    def logger
+      Logger.instance
+    end
+  end
+end

data/lib/convenient_service/rspec/helpers/custom/ignoring_error.rb

@@ -0,0 +1,29 @@
+# frozen_string_literal: true
+
+module ConvenientService
+  module RSpec
+    module Helpers
+      module Custom
+        ##
+        # TODO: Specs.
+        #
+        class IgnoringError < Support::Command
+          attr_reader :errors, :block
+
+          def initialize(*errors, &block)
+            @errors = errors
+            @block = block
+          end
+
+          def call
+            block.call
+          rescue *errors
+            nil
+          else
+            raise
+          end
+        end
+      end
+    end
+  end
+end

data/lib/convenient_service/rspec/helpers/custom/stub_service/entities/result_spec.rb

@@ -0,0 +1,119 @@
+# frozen_string_literal: true
+
+module ConvenientService
+  module RSpec
+    module Helpers
+      module Custom
+        ##
+        # TODO: Specs.
+        #
+        class StubService < Support::Command
+          module Entities
+            class ResultSpec
+              def initialize(status:, service_class: nil, chain: {})
+                @status = status
+                @service_class = service_class
+                @chain = chain
+              end
+
+              def for(service_class)
+                self.class.new(status: status, service_class: service_class, chain: chain)
+              end
+
+              def with_data(data)
+                chain[:data] = data
+
+                self
+              end
+
+              def with_message(message)
+                chain[:message] = message
+
+                self
+              end
+
+              def with_code(code)
+                chain[:code] = code
+
+                self
+              end
+
+              def and_data(data)
+                chain[:data] = data
+
+                self
+              end
+
+              def and_message(message)
+                chain[:message] = message
+
+                self
+              end
+
+              def and_code(code)
+                chain[:code] = code
+
+                self
+              end
+
+              def calculate_value
+                ##
+                # TODO: Assert.
+                #
+                service_class.__send__(status, **kwargs)
+              end
+
+              private
+
+              attr_reader :status, :service_class, :chain
+
+              def kwargs
+                @kwargs ||= calculate_kwargs
+              end
+
+              def calculate_kwargs
+                kwargs = {}
+
+                kwargs[:data] = data if used_data?
+                kwargs[:message] = message if used_message?
+                kwargs[:code] = code if used_code?
+
+                kwargs[:service] = service_instance
+
+                kwargs
+              end
+
+              def used_data?
+                chain.key?(:data)
+              end
+
+              def used_message?
+                chain.key?(:message)
+              end
+
+              def used_code?
+                chain.key?(:code)
+              end
+
+              def data
+                @data ||= chain[:data] || {}
+              end
+
+              def message
+                @message ||= chain[:message] || ""
+              end
+
+              def code
+                @code ||= chain[:code] || ""
+              end
+
+              def service_instance
+                @service_instance ||= service_class.new_without_initialize
+              end
+            end
+          end
+        end
+      end
+    end
+  end
+end

data/lib/convenient_service/rspec/helpers/custom/stub_service/entities/stubbed_service.rb

@@ -0,0 +1,99 @@
+# frozen_string_literal: true
+
+module ConvenientService
+  module RSpec
+    module Helpers
+      module Custom
+        class StubService < Support::Command
+          module Entities
+            ##
+            # TODO: Specs.
+            #
+            class StubbedService < Support::Command
+              ##
+              # NOTE: `include ::RSpec::Matchers`.
+              # - https://github.com/rspec/rspec-expectations/blob/v3.11.0/lib/rspec/matchers.rb
+              # - https://github.com/rspec/rspec-expectations/blob/main/lib/rspec/matchers.rb
+              #
+              include ::RSpec::Matchers
+
+              ##
+              # 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
+
+              def initialize(service_class:)
+                @service_class = service_class
+              end
+
+              def with_arguments(*args, **kwargs, &block)
+                chain[:with_arguments] = {args: args, kwargs: kwargs, block: block}
+
+                self
+              end
+
+              def to(result_spec)
+                @result_spec = result_spec
+
+                service_class.commit_config!
+
+                if used_with_arguments?
+                  allow(service_class).to receive(:result).and_wrap_original do |original, *actual_args, **actual_kwargs, &actual_block|
+                    expect(actual_args).to eq(expected_args)
+                    expect(actual_kwargs).to eq(expected_kwargs)
+                    expect(actual_block).to eq(expected_block)
+
+                    result_value
+                  end
+                else
+                  allow(service_class).to receive(:result).and_return(result_value)
+                end
+              end
+
+              private
+
+              attr_reader :service_class, :result_spec
+
+              def result_value
+                @result_value ||= result_spec.for(service_class).calculate_value
+              end
+
+              def used_with_arguments?
+                chain.key?(:with_arguments)
+              end
+
+              def chain
+                @chain ||= {}
+              end
+
+              def args
+                @args ||= chain.dig(:with_arguments, :args) || []
+              end
+
+              alias_method :expected_args, :args
+
+              def kwargs
+                @kwargs ||= chain.dig(:with_arguments, :kwargs) || {}
+              end
+
+              alias_method :expected_kwargs, :kwargs
+
+              ##
+              # NOTE: `if defined?` is used in order to cache `nil` if needed.
+              #
+              def block
+                return @block if defined? @block
+
+                @block = chain.dig(:with_arguments, :block)
+              end
+
+              alias_method :expected_block, :block
+            end
+          end
+        end
+      end
+    end
+  end
+end

data/lib/convenient_service/rspec/helpers/custom/stub_service/entities.rb

@@ -0,0 +1,4 @@
+# frozen_string_literal: true
+
+require_relative "entities/stubbed_service"
+require_relative "entities/result_spec"

data/lib/convenient_service/rspec/helpers/custom/stub_service.rb

@@ -0,0 +1,26 @@
+# frozen_string_literal: true
+
+require_relative "stub_service/entities"
+
+module ConvenientService
+  module RSpec
+    module Helpers
+      module Custom
+        ##
+        # TODO: Specs.
+        #
+        class StubService < Support::Command
+          attr_reader :service_class
+
+          def initialize(service_class)
+            @service_class = service_class
+          end
+
+          def call
+            Entities::StubbedService.new(service_class: @service_class)
+          end
+        end
+      end
+    end
+  end
+end

data/lib/convenient_service/rspec/helpers/custom/wrap_method/entities/wrapped_method.rb

@@ -0,0 +1,80 @@
+# frozen_string_literal: true
+
+module ConvenientService
+  module RSpec
+    module Helpers
+      module Custom
+        ##
+        # TODO: Specs.
+        #
+        class WrapMethod < Support::Command
+          module Entities
+            ##
+            # NOTE: Do NOT pollute the interface of this class until really needed. Avoid even pollution of private methods.
+            #
+            class WrappedMethod
+              ##
+              # NOTE: `middlewares` are `MethodChainMiddleware` classes.
+              #
+              def initialize(entity:, method:, middlewares:)
+                @entity = entity
+                @method = method
+                @middlewares = middlewares
+
+                @stack = Support::Middleware::StackBuilder.new do |stack|
+                  middlewares.each { |middleware| stack.use middleware }
+
+                  ##
+                  # NOTE: The following proc middleware is triggered only when `chain.next` is called from method chain middleware.
+                  #
+                  stack.use(
+                    proc do |env|
+                      ##
+                      # TODO: Enforce to always pass args, kwargs, block.
+                      #
+                      entity.__send__(method, *env[:args], **env[:kwargs], &env[:block])
+                        .tap { |value| @chain_value = value }
+                        .tap { @chain_arguments = {args: env[:args], kwargs: env[:kwargs], block: env[:block]} }
+                    end
+                  )
+                end
+              end
+
+              def call(*args, **kwargs, &block)
+                @stack.call(entity: @entity, method: @method, args: args, kwargs: kwargs, block: block)
+              end
+
+              def chain_called?
+                Utils::Bool.to_bool(defined? @chain_value)
+              end
+
+              def chain_value
+                raise Errors::ChainAttributePreliminaryAccess.new(attribute: :value) unless chain_called?
+
+                @chain_value
+              end
+
+              def chain_args
+                raise Errors::ChainAttributePreliminaryAccess.new(attribute: :args) unless chain_called?
+
+                @chain_arguments[:args]
+              end
+
+              def chain_kwargs
+                raise Errors::ChainAttributePreliminaryAccess.new(attribute: :kwargs) unless chain_called?
+
+                @chain_arguments[:kwargs]
+              end
+
+              def chain_block
+                raise Errors::ChainAttributePreliminaryAccess.new(attribute: :block) unless chain_called?
+
+                @chain_arguments[:block]
+              end
+            end
+          end
+        end
+      end
+    end
+  end
+end

data/lib/convenient_service/rspec/helpers/custom/wrap_method/entities.rb

@@ -0,0 +1,3 @@
+# frozen_string_literal: true
+
+require_relative "entities/wrapped_method"

data/lib/convenient_service/rspec/helpers/custom/wrap_method/errors.rb

@@ -0,0 +1,25 @@
+# frozen_string_literal: true
+
+module ConvenientService
+  module RSpec
+    module Helpers
+      module Custom
+        class WrapMethod < Support::Command
+          class WrappedMethod
+            module Errors
+              class ChainAttributePreliminaryAccess < ::StandardError
+                def initialize(attribute:)
+                  message <<~TEXT
+                    Chain attribute `#{attribute}` is accessed before the chain is called.
+                  TEXT
+
+                  super(message)
+                end
+              end
+            end
+          end
+        end
+      end
+    end
+  end
+end