sod 0.0.0

data/lib/sod/action.rb

@@ -0,0 +1,84 @@
+# frozen_string_literal: true
+
+require "forwardable"
+
+module Sod
+  # A generic action (and DSL) from which to inherit and build custom actions from.
+  # :reek:TooManyInstanceVariables
+  class Action
+    extend Forwardable
+
+    def self.inherited base
+      super
+      base.class_eval { @attributes = {} }
+    end
+
+    def self.description text
+      @description ? fail(Error, "Description can only be defined once.") : @description = text
+    end
+
+    def self.ancillary(*lines)
+      @ancillary ? fail(Error, "Ancillary can only be defined once.") : @ancillary = lines
+    end
+
+    def self.on(aliases, **keywords)
+      fail Error, "On can only be defined once." if @attributes.any?
+
+      @attributes.merge! keywords, aliases: Array(aliases)
+    end
+
+    def self.default &block
+      @default ? fail(Error, "Default can only be defined once.") : @default = block
+    end
+
+    delegate [*Models::Action.members, :handle, :to_a, :to_h] => :record
+
+    attr_reader :record
+
+    def initialize context: Context::EMPTY, model: Models::Action
+      klass = self.class
+
+      @context = context
+
+      @record = model[
+        **klass.instance_variable_get(:@attributes),
+        description: klass.instance_variable_get(:@description),
+        ancillary: Array(klass.instance_variable_get(:@ancillary)).compact,
+        default: load_default
+      ]
+
+      verify_argument
+    end
+
+    def call(*)
+      fail NotImplementedError,
+           "`#{self.class}##{__method__} #{method(__method__).parameters}` must be implemented."
+    end
+
+    def inspect
+      attributes = record.to_h.map { |key, value| "#{key}=#{value.inspect}" }
+      %(#<#{self.class} @context=#{context.inspect} #{attributes.join ", "}>)
+    end
+
+    def to_proc = method(:call).to_proc
+
+    protected
+
+    attr_reader :context
+
+    private
+
+    def verify_argument
+      return unless argument && !argument.start_with?("[") && default
+
+      fail Error, "Required argument can't be used with default."
+    end
+
+    def load_default
+      klass = self.class
+      fallback = klass.instance_variable_get(:@attributes)[:default].method :itself
+
+      (klass.instance_variable_get(:@default) || fallback).call
+    end
+  end
+end

data/lib/sod/command.rb

@@ -0,0 +1,74 @@
+# frozen_string_literal: true
+
+require "forwardable"
+
+module Sod
+  # A generic command (and DSL) from which to inherit and build custom commands from.
+  # :reek:TooManyInstanceVariables
+  class Command
+    extend Forwardable
+
+    include Import[:logger]
+
+    def self.inherited base
+      super
+      base.class_eval { @actions = Set.new }
+    end
+
+    def self.handle text
+      @handle ? fail(Error, "Handle can only be defined once.") : @handle = text
+    end
+
+    def self.description text
+      @description ? fail(Error, "Description can only be defined once.") : @description = text
+    end
+
+    def self.ancillary(*lines)
+      @ancillary ? fail(Error, "Ancillary can only be defined once.") : @ancillary = lines
+    end
+
+    def self.on(action, *positionals, **keywords) = @actions.add [action, positionals, keywords]
+
+    delegate Models::Command.members => :record
+
+    attr_reader :record
+
+    def initialize(context: Context::EMPTY, model: Models::Command, **)
+      super(**)
+      klass = self.class
+      @context = context
+
+      @record = model[
+        handle: klass.instance_variable_get(:@handle),
+        description: klass.instance_variable_get(:@description),
+        ancillary: Array(klass.instance_variable_get(:@ancillary)).compact,
+        actions: Set[*build_actions],
+        operation: method(:call)
+      ]
+    end
+
+    def call
+      logger.debug { "`#{self.class}##{__method__}}` called without implementation. Skipped." }
+    end
+
+    def inspect
+      attributes = record.to_h
+                         .map { |key, value| "#{key}=#{value.inspect}" }
+                         .join ", "
+
+      "#<#{self.class} @logger=#{logger.inspect} @context=#{context.inspect} #{attributes}>"
+    end
+
+    protected
+
+    attr_reader :context
+
+    private
+
+    def build_actions
+      self.class.instance_variable_get(:@actions).map do |action, positionals, keywords|
+        action.new(*positionals, **keywords.merge!(context:))
+      end
+    end
+  end
+end

data/lib/sod/container.rb

@@ -0,0 +1,18 @@
+# frozen_string_literal: true
+
+require "cogger"
+require "dry/container"
+require "optparse"
+require "tone"
+
+module Sod
+  # The primary container.
+  module Container
+    extend Dry::Container::Mixin
+
+    register(:client) { OptionParser.new nil, 40, "  " }
+    register(:color) { Tone.new }
+    register(:kernel) { Kernel }
+    register(:logger) { Cogger.new formatter: :emoji }
+  end
+end

data/lib/sod/context.rb

@@ -0,0 +1,33 @@
+# frozen_string_literal: true
+
+module Sod
+  # Provides a sharable, read-only, context for commands and actions.
+  class Context
+    EMPTY = new.freeze
+
+    def self.[](...) = new(...)
+
+    def initialize **attributes
+      @attributes = attributes
+    end
+
+    # :reek:ControlParameter
+    def [] default, fallback
+      default || public_send(fallback)
+    rescue NoMethodError
+      raise Error, "Invalid context. Default or fallback (#{fallback.inspect}) values are missing."
+    end
+
+    def to_h = attributes.dup
+
+    def method_missing(name, *) = respond_to_missing?(name) ? attributes[name] : super(name, *)
+
+    private
+
+    attr_reader :attributes
+
+    def respond_to_missing? name, include_private = false
+      (attributes && attributes.key?(name)) || super
+    end
+  end
+end

data/lib/sod/error.rb

@@ -0,0 +1,7 @@
+# frozen_string_literal: true
+
+module Sod
+  # The namespaced root of all errors for this gem.
+  class Error < StandardError
+  end
+end

data/lib/sod/graph/loader.rb

@@ -0,0 +1,40 @@
+# frozen_string_literal: true
+
+module Sod
+  module Graph
+    # Loads and decorates option parsers within graph.
+    class Loader
+      include Import[:client]
+
+      using Refines::OptionParsers
+
+      def initialize(graph, **)
+        super(**)
+        @graph = graph
+        @registry = {}
+      end
+
+      def call
+        registry.clear
+        load graph
+        graph.children.each { |child| visit child, child.handle }
+        registry
+      end
+
+      private
+
+      attr_reader :graph, :registry
+
+      def visit command, key = ""
+        load command, key
+        command.children.each { |child| visit child, "#{key} #{child.handle}".strip }
+      end
+
+      def load node, key = ""
+        parser = client.replicate
+        node.actions.each { |action| parser.on(*action.to_a, action.to_proc) }
+        registry[key] = [parser, node]
+      end
+    end
+  end
+end

data/lib/sod/graph/node.rb

@@ -0,0 +1,107 @@
+# frozen_string_literal: true
+
+require "refinements/arrays"
+
+module Sod
+  module Graph
+    # A generic graph node (and DSL) from which to build multiple lineages with.
+    Node = Struct.new :handle, :description, :ancillary, :actions, :operation, :children do
+      using Refinements::Arrays
+
+      def initialize(**)
+        super
+        self[:actions] = Set.new actions
+        self[:children] = Set.new children
+        self[:ancillary] = Array ancillary
+        @depth = 0
+        @lineage = []
+      end
+
+      def get_action *lineage
+        handle = lineage.pop
+        get_actions(*lineage).find { |action| action.handle.include? handle }
+      end
+
+      def get_actions *lineage, node: self
+        lineage.empty? ? node.actions : get(lineage, node, __method__)
+      end
+
+      def get_child(*lineage, node: self) = lineage.empty? ? node : get(lineage, node, __method__)
+
+      def on(object, *, **, &block)
+        lineage.clear if depth.zero?
+
+        process(object, *, **)
+
+        increment
+        instance_eval(&block) if block
+        decrement
+      end
+
+      def call = (operation.call if operation)
+
+      private
+
+      attr_reader :lineage
+
+      attr_accessor :depth
+
+      # :reek:TooManyStatements
+      # rubocop:todo Metrics/AbcSize
+      def process(object, *, **)
+        ancestry = object.is_a?(Class) ? object.ancestors : []
+
+        if ancestry.include? Command
+          add_child(*lineage, self.class[**object.new(*, **).record.to_h])
+        elsif object.is_a? String
+          add_inline_command(object, *, **)
+        elsif ancestry.include? Action
+          add_action(*lineage, object.new(*, **))
+        else
+          fail Error, "Invalid command or action. Unable to add: #{object.inspect}."
+        end
+      end
+      # rubocop:enable Metrics/AbcSize
+
+      def add_inline_command handle, *positionals
+        description, *ancillary = positionals
+
+        fail Error, <<~CONTENT unless handle && description
+          Unable to add command. Invalid handle or description (both are required):
+          - Handle: #{handle.inspect}
+          - Description: #{description.inspect}
+        CONTENT
+
+        add_child(*lineage, self.class[handle:, description:, ancillary: ancillary.compact])
+      end
+
+      def add_child *lineage
+        node = lineage.pop
+        handle = node.handle
+        tracked_lineage = self.lineage
+
+        add lineage[...depth], node, :children
+        tracked_lineage.replace_at depth, handle
+      end
+
+      def add_action(*lineage) = add lineage, lineage.pop, :actions
+
+      def add lineage, node, message
+        get_child(*lineage).then { |child| child.public_send(message).add node }
+      end
+
+      def get lineage, node, message
+        handle = lineage.shift
+        node = node.children.find { |child| child.handle == handle }
+
+        fail Error, "Unable to find command or action: #{handle.inspect}." unless node
+
+        public_send(message, *lineage, node:)
+      end
+
+      def increment = self.depth += 1
+
+      def decrement = self.depth -= 1
+    end
+  end
+end

data/lib/sod/graph/runner.rb

@@ -0,0 +1,71 @@
+# frozen_string_literal: true
+
+module Sod
+  module Graph
+    # Runs the appropriate parser for given command line arguments.
+    class Runner
+      include Import[:client, :logger]
+
+      using Refines::OptionParsers
+
+      HELP_PATTERN = /
+        \A       # Start of string.
+        -h       # Short alias.
+        |        # Or.
+        --help   # Long alias.
+        \Z       # End of string.
+      /x
+
+      # rubocop:todo Metrics/ParameterLists
+      def initialize(graph, help_pattern: HELP_PATTERN, loader: Loader, **)
+        super(**)
+        @graph = graph
+        @registry = loader.new(graph).call
+        @help_pattern = help_pattern
+        @lineage = +""
+      end
+      # rubocop:enable Metrics/ParameterLists
+
+      # :reek:DuplicateMethodCall
+      # :reek:TooManyStatements
+      def call arguments = ARGV
+        lineage.clear
+        visit arguments.dup
+      rescue OptionParser::ParseError => error
+        log_error error.message
+      rescue Sod::Error => error
+        log_error error.message
+        help
+      end
+
+      private
+
+      attr_reader :graph, :registry, :help_pattern, :lineage
+
+      # :reek:TooManyStatements
+      def visit arguments
+        if arguments.empty? || arguments.any? { |argument| argument.match? help_pattern }
+          usage(*arguments)
+        else
+          parser, node = registry.fetch lineage, client
+          parser.order! arguments, command: node do |command|
+            lineage.concat(" ", command).tap(&:strip!)
+            visit arguments
+          end
+        end
+      end
+
+      def usage(*arguments)
+        commands = arguments.grep_v help_pattern
+        commands = lineage.split if commands.empty?
+        help(*commands)
+      end
+
+      def help(*commands)
+        graph.get_action("help").then { |action| action.call(*commands) if action }
+      end
+
+      def log_error(message) = logger.error { message.capitalize }
+    end
+  end
+end

data/lib/sod/import.rb

@@ -0,0 +1,7 @@
+# frozen_string_literal: true
+
+require "infusible"
+
+module Sod
+  Import = Infusible.with Container
+end

data/lib/sod/models/action.rb

@@ -0,0 +1,38 @@
+# frozen_string_literal: true
+
+require "refinements/arrays"
+
+module Sod
+  module Models
+    # Defines all attributes of an action.
+    Action = Data.define(
+      :aliases,
+      :argument,
+      :type,
+      :allow,
+      :default,
+      :description,
+      :ancillary
+    ) do
+      using Refinements::Arrays
+
+      def initialize aliases: nil,
+                     argument: nil,
+                     type: nil,
+                     allow: nil,
+                     default: nil,
+                     description: nil,
+                     ancillary: nil
+        super
+      end
+
+      def handle = [Array(aliases).join(", "), argument].tap(&:compact!).join " "
+
+      def to_a = [*handles, type, allow, description, *ancillary].tap(&:compress!)
+
+      private
+
+      def handles = Array(aliases).map { |item| [item, argument].tap(&:compact!).join " " }
+    end
+  end
+end

data/lib/sod/models/command.rb

@@ -0,0 +1,11 @@
+# frozen_string_literal: true
+
+module Sod
+  module Models
+    Command = Data.define :handle, :description, :ancillary, :actions, :operation do
+      def initialize handle:, description:, actions:, operation:, ancillary: []
+        super
+      end
+    end
+  end
+end

data/lib/sod/prefabs/actions/config/create.rb

@@ -0,0 +1,76 @@
+# frozen_string_literal: true
+
+require "refinements/pathnames"
+
+module Sod
+  module Prefabs
+    module Actions
+      module Config
+        # Creates project configuration.
+        class Create < Action
+          include Import[:kernel, :logger]
+
+          using Refinements::Pathnames
+
+          description "Create default configuration."
+
+          ancillary "Prompts for local or global path."
+
+          on %w[-c --create]
+
+          def initialize(xdg_config = nil, defaults_path: nil, **)
+            super(**)
+            @xdg_config = context[xdg_config, :xdg_config]
+            @defaults_path = Pathname context[defaults_path, :defaults_path]
+          end
+
+          def call(*)
+            ARGV.clear
+            check_defaults && choose
+          end
+
+          private
+
+          attr_reader :xdg_config, :defaults_path
+
+          def check_defaults
+            return true if defaults_path.exist?
+
+            logger.fatal { "Default configuration doesn't exist: #{defaults_path.to_s.inspect}." }
+            kernel.abort
+            false
+          end
+
+          def choose
+            kernel.print "Would you like to create (g)lobal, (l)ocal, or (n)o configuration? " \
+                         "(g/l/n)? "
+            response = kernel.gets.chomp
+
+            case response
+              when "g" then create xdg_config.global
+              when "l" then create xdg_config.local
+              else quit
+            end
+          end
+
+          # :reek:TooManyStatements
+          def create path
+            path_info = path.to_s.inspect
+
+            if path.exist?
+              logger.warn { "Skipped. Configuration exists: #{path_info}." }
+            else
+              defaults_path.copy path.make_ancestors
+              logger.info { "Created: #{path_info}." }
+            end
+          end
+
+          def quit
+            logger.info { "Creation canceled." }
+            kernel.exit
+          end
+        end
+      end
+    end
+  end
+end

data/lib/sod/prefabs/actions/config/delete.rb

@@ -0,0 +1,60 @@
+# frozen_string_literal: true
+
+require "refinements/pathnames"
+require "refinements/strings"
+
+module Sod
+  module Prefabs
+    module Actions
+      module Config
+        # Deletes project configuration.
+        class Delete < Action
+          include Import[:kernel, :logger]
+
+          using Refinements::Pathnames
+          using Refinements::Strings
+
+          description "Delete project configuration."
+
+          ancillary "Prompts for confirmation."
+
+          on %w[-d --delete]
+
+          # :reek:ControlParameter
+          def initialize(path = nil, **)
+            super(**)
+            @path = Pathname(path || context.xdg_config.active)
+          end
+
+          def call(*)
+            ARGV.clear
+
+            return confirm if path.exist?
+
+            logger.warn { "Skipped. Configuration doesn't exist: #{path_info}." }
+          end
+
+          private
+
+          attr_reader :path
+
+          def confirm
+            kernel.print "Are you sure you want to delete #{path_info} (y/n)? "
+            response = kernel.gets.chomp.to_bool
+
+            if response
+              path.delete
+              info "Deleted: #{path_info}."
+            else
+              info "Skipped: #{path_info}."
+            end
+          end
+
+          def path_info = path.to_s.inspect
+
+          def info(message) = logger.info { message }
+        end
+      end
+    end
+  end
+end

data/lib/sod/prefabs/actions/config/edit.rb

@@ -0,0 +1,47 @@
+# frozen_string_literal: true
+
+require "refinements/pathnames"
+
+module Sod
+  module Prefabs
+    module Actions
+      module Config
+        # Edits project configuration.
+        class Edit < Action
+          include Import[:kernel, :logger]
+
+          using Refinements::Pathnames
+
+          description "Edit project configuration."
+
+          on %w[-e --edit]
+
+          # :reek:ControlParameter
+          def initialize(path = nil, **)
+            super(**)
+            @path = Pathname(path || context.xdg_config.active)
+          end
+
+          def call(*)
+            return unless check
+
+            logger.info { "Editing: #{path.to_s.inspect}." }
+            kernel.system "$EDITOR #{path}"
+          end
+
+          private
+
+          attr_reader :path
+
+          def check
+            return true if path.exist?
+
+            logger.error { "Configuration doesn't exist: #{path.to_s.inspect}." }
+            kernel.abort
+            false
+          end
+        end
+      end
+    end
+  end
+end