cuprum-cli 0.1.0

data/lib/cuprum/cli/commands/echo_command.rb

@@ -0,0 +1,76 @@
+# frozen_string_literal: true
+
+require 'json'
+
+require 'cuprum/cli/command'
+require 'cuprum/cli/commands'
+
+module Cuprum::Cli::Commands
+  # Outputs the arguments and options passed to the command.
+  class EchoCommand < Cuprum::Cli::Command
+    dependency :file_system
+    dependency :standard_io
+
+    description 'Outputs the arguments and options passed to the command.'
+
+    arguments :args, type: String
+
+    option :format, type: String
+    option :out,    type: String
+
+    private
+
+    def format_arguments_as_text
+      return '[]' if args.empty?
+
+      formatted = args.map(&:inspect).join(', ')
+
+      "[#{formatted}]"
+    end
+
+    def format_options_as_text(kwargs)
+      return '{}' if kwargs.empty?
+
+      formatted =
+        kwargs.map { |key, value| "#{key}: #{value.inspect}" }.join(', ')
+
+      "{ #{formatted} }"
+    end
+
+    def format_parameters
+      case format&.downcase
+      when 'json'
+        JSON.pretty_generate({ arguments: args, options: options.compact })
+      else
+        format_parameters_as_text
+      end
+    end
+
+    def format_parameters_as_text
+      buffer = "#{self.class.name} called with "
+      kwargs = options.compact
+
+      return buffer << 'no parameters.' if args.empty? && kwargs.empty?
+
+      buffer <<
+        "parameters:\n" \
+        "\n  Arguments: #{format_arguments_as_text}" \
+        "\n  Options:   #{format_options_as_text(kwargs)}" \
+        "\n"
+
+      buffer.freeze
+    end
+
+    def process
+      formatted = format_parameters
+
+      if out
+        file_system.write(out, formatted)
+      else
+        standard_io.write_output(formatted)
+      end
+
+      nil
+    end
+  end
+end

data/lib/cuprum/cli/commands/file/generate_file.rb

@@ -0,0 +1,141 @@
+# frozen_string_literal: true
+
+require 'cuprum/command'
+require 'plumbum'
+
+require 'cuprum/cli/commands/file'
+require 'cuprum/cli/commands/file/render_erb'
+require 'cuprum/cli/dependencies'
+require 'cuprum/cli/dependencies/file_system'
+require 'cuprum/cli/errors/files/missing_template'
+require 'cuprum/cli/options'
+
+module Cuprum::Cli::Commands::File
+  # Utility command for generating a file from a template.
+  class GenerateFile < Cuprum::Command
+    include Plumbum::Consumer
+    prepend Plumbum::Parameters
+    include Cuprum::Cli::Dependencies::StandardIo::Helpers
+    extend  Cuprum::Cli::Options::ClassMethods
+    include Cuprum::Cli::Options::Quiet
+    include Cuprum::Cli::Options::Verbose
+
+    dependency :file_system
+    dependency :standard_io
+
+    provider Cuprum::Cli::Dependencies.provider
+
+    option :directories, type: :boolean, default: true
+    option :dry_run,     type: :boolean, default: false
+    option :force,       type: :boolean, default: false
+
+    # @overload initialize(**options)
+    #   @param options [Hash] options for initializing the command.
+    def initialize(**)
+      super()
+
+      @options = self.class.resolve_options(**)
+    end
+
+    private
+
+    attr_reader :options
+
+    def check_if_file_already_exists(file_path:)
+      return unless file_system.file?(file_path)
+      return if force?
+
+      error  =
+        file_not_writeable_error(file_path:, reason: 'file already exists')
+
+      failure(error)
+    end
+
+    def check_if_file_is_directory(file_path:)
+      return unless file_system.directory?(file_path)
+
+      error  =
+        file_not_writeable_error(file_path:, reason: 'file is a directory')
+
+      failure(error)
+    end
+
+    def create_directory(file_path:)
+      return unless directories?
+
+      return if dry_run?
+      return if file_system.directory?(file_path)
+
+      *dir_names, _ = file_path.split(File::SEPARATOR)
+
+      return if dir_names.empty?
+
+      file_system.create_directory(
+        dir_names.join(File::SEPARATOR),
+        recursive: true
+      )
+    end
+
+    def file_not_writeable_error(**)
+      Cuprum::Cli::Errors::Files::FileNotWriteable.new(**)
+    end
+
+    def load_template(file_path:, template_path:)
+      file_system.read_file(template_path)
+    rescue Cuprum::Cli::Dependencies::FileSystem::FileNotFoundError
+      error = Cuprum::Cli::Errors::Files::MissingTemplate.new(
+        message:       "unable to generate file #{file_path}",
+        template_path:
+      )
+      failure(error)
+    end
+
+    def process(file_path:, parameters:, template_path:)
+      say "Generating file #{file_path}..."
+
+      template = step { load_template(file_path:, template_path:) }
+      contents =
+        step { render_template(parameters:, template:, template_path:) }
+
+      report_file_contents(contents)
+
+      step { create_directory(file_path:) }
+
+      step { write_file(contents:, file_path:) }
+
+      file_path
+    end
+
+    def render_template(parameters:, template:, template_path:)
+      case File.extname(template_path)
+      when '.erb'
+        RenderErb.new(template_name: template_path).call(template, **parameters)
+      else
+        template
+      end
+    end
+
+    def report_file_contents(contents)
+      say "\n", verbose: true
+      say(
+        contents
+          .each_line
+          .map { |line| line == "\n" ? "\n" : "  #{line}" }.join,
+        verbose: true
+      )
+      say "\n", verbose: true
+    end
+
+    def write_file(contents:, file_path:)
+      step { check_if_file_is_directory(file_path:) }
+      step { check_if_file_already_exists(file_path:) }
+
+      file_system.write_file(file_path, contents) unless dry_run?
+    rescue Cuprum::Cli::Dependencies::FileSystem::DirectoryNotFoundError
+      error =
+        file_not_writeable_error(file_path:, reason: 'directory not found')
+
+      failure(error)
+    end
+  end
+end

data/lib/cuprum/cli/commands/file/new_command.rb

@@ -0,0 +1,86 @@
+# frozen_string_literal: true
+
+require 'cuprum/cli/command'
+require 'cuprum/cli/commands/file'
+require 'cuprum/cli/commands/file/render_erb'
+require 'cuprum/cli/commands/file/resolve_template'
+
+module Cuprum::Cli::Commands::File
+  # Command for generating a templated file or files.
+  class NewCommand < Cuprum::Cli::Command
+    dependency :file_system
+    dependency :standard_io
+
+    include Cuprum::Cli::Options::Quiet
+    include Cuprum::Cli::Options::Verbose
+
+    argument :file_path, type: String, required: true
+
+    option :directories,  type: :boolean, default: true
+    option :dry_run,      type: :boolean, default: false
+    option :parent_class, type: String
+    option :templates,
+      type:    Array,
+      default: Cuprum::Cli::Commands::File::Templates::DEFAULT_TEMPLATES
+    option :extra_flags,
+      type:     :boolean,
+      variadic: true
+
+    description 'Generates a new templated file or files.'
+
+    private
+
+    def excluded_tags
+      excluded = []
+
+      extra_flags.each do |flag, value|
+        excluded << flag if value == false
+      end
+
+      excluded
+    end
+
+    def generate_file(file_path:, parameters:, template_path:) # rubocop:disable Metrics/MethodLength
+      file_path = resolve_file_path(file_path, **parameters)
+      command   = GenerateFile.new(
+        file_system:,
+        standard_io:,
+        directories: directories?,
+        dry_run:     dry_run?,
+        quiet:       quiet?,
+        verbose:     verbose?
+      )
+
+      parameters = parameters.merge(parent_class:)
+
+      step { command.call(file_path:, parameters:, template_path:) }
+
+      file_path
+    end
+
+    def process
+      templates, parameters = step { resolve_template }
+
+      templates.map do |template|
+        file_path     = template.fetch(:file_path, self.file_path)
+        template_path = template.fetch(:template)
+
+        step { generate_file(file_path:, parameters:, template_path:) }
+      end
+    end
+
+    def resolve_file_path(file_path, **params)
+      params = tools.hash_tools.convert_keys_to_symbols(params)
+
+      format(file_path, params)
+    end
+
+    def resolve_template
+      command = Cuprum::Cli::Commands::File::ResolveTemplate.new(templates:)
+
+      command.call(file_path, except: excluded_tags)
+    end
+
+    def tools = @tools ||= SleepingKingStudios::Tools::Toolbelt.instance
+  end
+end

data/lib/cuprum/cli/commands/file/render_erb.rb

@@ -0,0 +1,88 @@
+# frozen_string_literal: true
+
+require 'cuprum/command'
+require 'herb'
+
+require 'cuprum/cli/commands/file'
+require 'cuprum/cli/errors/files/missing_parameter'
+
+module Cuprum::Cli::Commands::File
+  # Utility command for generating file contents from an .erb template.
+  class RenderErb < Cuprum::Command
+    class RenderingContext < BasicObject; end
+    private_constant :RenderingContext
+
+    # @param template_name [String, nil] the name of the rendered template. Used
+    #   for error reporting.
+    def initialize(template_name: nil)
+      super()
+
+      @template_name = template_name
+    end
+
+    # @return [String, nil] the name of the rendered template.
+    attr_reader :template_name
+
+    private
+
+    def compilation_error(details)
+      message = 'unable to render ERB template'
+      message = "#{message} #{template_name}" if template_name
+
+      Cuprum::Cli::Errors::Files::TemplateError.new(message:, details:)
+    end
+
+    def empty_binding = RenderingContext.new.instance_exec { Kernel.binding }
+
+    def generate_binding(**params)
+      params.each.with_object(empty_binding) do |(key, value), binding|
+        binding.local_variable_set(key, value)
+      end
+    end
+
+    def generate_engine(template)
+      Herb::Engine.new(template)
+    rescue Herb::Engine::CompilationError,
+           Herb::Engine::SecurityError => exception
+      error = compilation_error(exception.message)
+
+      failure(error)
+    end
+
+    def missing_parameter_error(parameter_name)
+      Cuprum::Cli::Errors::Files::MissingParameter.new(
+        message:        'unable to render ERB template',
+        parameter_name:,
+        template_name:
+      )
+    end
+
+    def process(template, **params) # rubocop:disable Metrics/AbcSize, Metrics/MethodLength
+      engine  = step { generate_engine(template) }
+      binding = generate_binding(**params)
+
+      binding.eval(engine.src)
+    rescue NameError => exception
+      error =
+        # @todo [RUBY_VERSION <= '3.3'] remove regexp case
+        if exception.message.match?(/RenderingContext:0x\h+>/)
+          # :nocov:
+          missing_parameter_error(exception.name)
+          # :nocov:
+        elsif exception.message.end_with?(RenderingContext.name) # rubocop:disable Lint/DuplicateBranch
+          missing_parameter_error(exception.name)
+        else
+          template_error(exception.message)
+        end
+
+      failure(error)
+    end
+
+    def template_error(message)
+      Cuprum::Cli::Errors::Files::TemplateError.new(
+        message:       "unable to render ERB template - #{message}",
+        template_name:
+      )
+    end
+  end
+end

data/lib/cuprum/cli/commands/file/resolve_template.rb

@@ -0,0 +1,136 @@
+# frozen_string_literal: true
+
+require 'cuprum/command'
+
+require 'cuprum/cli/commands/file'
+require 'cuprum/cli/errors/files/template_not_resolved'
+
+module Cuprum::Cli::Commands::File
+  # Utility command for resolving a template and parameterized values.
+  class ResolveTemplate < Cuprum::Command
+    # @param templates [Array<Hash>] the defined templates.
+    def initialize(templates:)
+      super()
+
+      @templates = templates
+    end
+
+    # @return [Array<Hash>] the defined templates.
+    attr_reader :templates
+
+    private
+
+    def default_params(file_path:, **params) # rubocop:disable Metrics/MethodLength
+      dir_name   = File.dirname(file_path)
+      ext_name   = File.extname(file_path)
+      base_name  = File.basename(file_path)
+      short_name = base_name.split('.').first
+
+      {
+        base_name:,
+        dir_name:,
+        ext_name:,
+        file_path:,
+        short_name:,
+        **params
+      }
+    end
+
+    def filter_templates(except:, file_templates:, only:)
+      file_templates = [file_templates] unless file_templates.is_a?(Array)
+      except         = Array(except).map(&:to_s)
+      only           = Array(only).map(&:to_s)
+
+      unless except.empty?
+        file_templates = reject_templates(file_templates, *except)
+      end
+
+      unless only.empty?
+        file_templates = select_templates(file_templates, *only)
+      end
+
+      file_templates
+    end
+
+    def match_pattern(pattern, file_path)
+      case pattern
+      when Proc
+        pattern.call(file_path)
+      when Regexp
+        match_regexp(pattern, file_path)
+      when String
+        { file_path: } if file_path.end_with?(pattern)
+      else
+        # :nocov:
+        false
+        # :nocov:
+      end
+    end
+
+    def match_regexp(pattern, file_path)
+      pattern
+        .match(file_path)
+        &.named_captures
+        &.then { |captures| tools.hash_tools.convert_keys_to_symbols(captures) }
+    end
+
+    def process(file_path, except: [], only: []) # rubocop:disable Metrics/MethodLength
+      templates.each do |hsh|
+        params = match_pattern(hsh.fetch(:pattern), file_path)
+
+        next unless params
+
+        file_templates = hsh.fetch(:templates)
+        file_templates = step do
+          filter_templates(file_templates:, except:, only:)
+        end
+
+        step { require_templates(file_path:, file_templates:, except:, only:) }
+
+        return success([file_templates, default_params(file_path:, **params)])
+      end
+
+      message = 'no template matching file path'
+
+      failure(template_not_resolved_error(file_path:, message:))
+    end
+
+    def reject_templates(file_templates, *filters)
+      file_templates.reject do |template|
+        types = template.fetch(:types, Array(template[:type])).map(&:to_s)
+
+        types.any? { |type| filters.include?(type) }
+      end
+    end
+
+    def require_templates(file_path:, file_templates:, except:, only:)
+      return unless file_templates.empty?
+
+      options = {}
+      options[:except] = except unless except.empty?
+      options[:only]   = only   unless only.empty?
+
+      error = template_not_resolved_error(
+        file_path:,
+        message:   'all templates filtered out',
+        options:
+      )
+
+      failure(error)
+    end
+
+    def select_templates(file_templates, *filters)
+      file_templates.select do |template|
+        types = template.fetch(:types, Array(template[:type])).map(&:to_s)
+
+        types.any? { |type| filters.include?(type) }
+      end
+    end
+
+    def template_not_resolved_error(**)
+      Cuprum::Cli::Errors::Files::TemplateNotResolved.new(**)
+    end
+
+    def tools = @tools ||= SleepingKingStudios::Tools::Toolbelt.instance
+  end
+end

data/lib/cuprum/cli/commands/file/templates/rspec.rb.erb

@@ -0,0 +1,14 @@
+# frozen_string_literal: true
+<% tools = SleepingKingStudios::Tools::Toolbelt.new %>
+
+<% module_path = relative_path.sub(/\/\z/, '').split('/') %>
+<% full_path = [*module_path, short_name.sub(/_spec\z/, '')] %>
+require '<%= full_path.join('/') %>'
+
+<%
+  qualified_module =
+    full_path.map { |rel| tools.str.camelize(rel) }.join('::')
+%>
+RSpec.describe <%= qualified_module %> do
+  pending
+end

data/lib/cuprum/cli/commands/file/templates/ruby.rb.erb

@@ -0,0 +1,29 @@
+# frozen_string_literal: true
+<% tools = SleepingKingStudios::Tools::Toolbelt.new %>
+
+<% if relative_path.empty? %>
+<% if defined?(parent_class) && parent_class %>
+class <%= tools.str.camelize(short_name) %> < <%= parent_class %>
+
+end
+<% else %>
+module <%= tools.str.camelize(short_name) %>
+
+end
+<% end %>
+<% else %>
+<% module_path = relative_path.sub(/\/\z/, '').split('/') %>
+require '<%= module_path.join('/') %>'
+
+module <%= module_path.map { |rel| tools.str.camelize(rel) }.join('::') %>
+  <% if defined?(parent_class) && parent_class %>
+  class <%= tools.str.camelize(short_name) %> < <%= parent_class %>
+
+  end
+  <% else %>
+  module <%= tools.str.camelize(short_name) %>
+
+  end
+  <% end %>
+end
+<% end %>

data/lib/cuprum/cli/commands/file/templates.rb

@@ -0,0 +1,71 @@
+# frozen_string_literal: true
+
+require 'cuprum/cli/commands/file'
+
+module Cuprum::Cli::Commands::File
+  # Namespace for defining templates for generated files.
+  module Templates
+    RSPEC_PATTERN = <<~PATTERN.strip.then { |pattern| /#{pattern}/xo }
+      \\A
+      (?<root_path>\\w+#{File::SEPARATOR})?
+      (?<relative_path>(\\w+#{File::SEPARATOR})*)
+      (?<base_name>\\w+)_spec\\.rb
+      \\z
+    PATTERN
+    private_constant :RSPEC_PATTERN
+
+    RUBY_PATTERN = <<~PATTERN.strip.then { |pattern| /#{pattern}/xo }
+      \\A
+      (?<root_path>\\w+#{File::SEPARATOR})?
+      (?<relative_path>(\\w+#{File::SEPARATOR})*)
+      (?<base_name>\\w+)\\.rb
+      \\z
+    PATTERN
+    private_constant :RUBY_PATTERN
+
+    TEMPLATES_PATH =
+      File
+      .join(
+        Cuprum::Cli.gem_path,
+        'lib',
+        'cuprum',
+        'cli',
+        'commands',
+        'file',
+        'templates'
+      )
+      .freeze
+    private_constant :TEMPLATES_PATH
+
+    # Default templates used to generate Ruby and RSpec files.
+    DEFAULT_TEMPLATES = [
+      {
+        name:      'RSpec File',
+        pattern:   RSPEC_PATTERN,
+        templates: {
+          file_path: '%<root_path>s%<relative_path>s%<base_name>s_spec.rb',
+          template:  File.join(TEMPLATES_PATH, 'rspec.rb.erb'),
+          types:     %i[ruby rspec spec test]
+        }
+      },
+      {
+        name:      'Ruby File (With Spec)',
+        pattern:   RUBY_PATTERN,
+        templates: [
+          {
+            file_path: '%<root_path>s%<relative_path>s%<base_name>s.rb',
+            template:  File.join(TEMPLATES_PATH, 'ruby.rb.erb'),
+            type:      :ruby
+          },
+          {
+            file_path: 'spec/%<relative_path>s%<base_name>s_spec.rb',
+            template:  File.join(TEMPLATES_PATH, 'rspec.rb.erb'),
+            types:     %i[ruby rspec spec test]
+          }
+        ]
+      }
+    ].then do |ary|
+      SleepingKingStudios::Tools::Toolbelt.instance.array_tools.deep_freeze(ary)
+    end
+  end
+end

data/lib/cuprum/cli/commands/file.rb

@@ -0,0 +1,14 @@
+# frozen_string_literal: true
+
+require 'cuprum/cli/commands'
+
+module Cuprum::Cli::Commands
+  # Namespace for commands that create or manage files.
+  module File
+    autoload :GenerateFile,    'cuprum/cli/commands/file/generate_file'
+    autoload :NewCommand,      'cuprum/cli/commands/file/new_command'
+    autoload :RenderErb,       'cuprum/cli/commands/file/render_erb'
+    autoload :ResolveTemplate, 'cuprum/cli/commands/file/resolve_template'
+    autoload :Templates,       'cuprum/cli/commands/file/templates'
+  end
+end

data/lib/cuprum/cli/commands.rb

@@ -0,0 +1,12 @@
+# frozen_string_literal: true
+
+require 'cuprum/cli'
+
+module Cuprum::Cli
+  # Namespace for predefined commands.
+  module Commands
+    autoload :Ci,          'cuprum/cli/commands/ci'
+    autoload :File,        'cuprum/cli/commands/file'
+    autoload :EchoCommand, 'cuprum/cli/commands/echo_command'
+  end
+end