ergane 0.0.1 → 0.1.0

data/lib/ergane/dsl/command_dsl.rb

@@ -0,0 +1,50 @@
+# frozen_string_literal: true
+
+module Ergane
+  module DSL
+    module CommandDSL
+      def description(text = nil)
+        text ? (@description = text) : (@description || "")
+      end
+
+      def aliases(*names)
+        names.any? ? (@aliases = names.flatten.map(&:to_sym)) : (@aliases || [])
+      end
+
+      def option(name, type = nil, short: nil, description: nil, default: nil, required: false, optional: false)
+        option_definitions[name.to_sym] = OptionDefinition.new(
+          name, type, short: short, description: description,
+          default: default, required: required, optional: optional
+        )
+      end
+
+      def flag(name, short: nil, description: nil)
+        option(name, nil, short: short, description: description, default: false)
+      end
+
+      def argument(name, type = String, description: nil, required: true, default: nil)
+        argument_definitions << ArgumentDefinition.new(
+          name, type, description: description, required: required, default: default
+        )
+      end
+
+      def command(name, aliases: [], &block)
+        klass = Class.new(command_base_for(name))
+        klass.command_name = name.to_sym
+        klass.aliases(*aliases) if aliases.any?
+
+        const_name = name.to_s.split("_").map(&:capitalize).join
+        const_set(const_name, klass) if const_name.match?(/\A[A-Z]/)
+
+        BlockDSL.new(klass).instance_eval(&block) if block
+        klass
+      end
+
+      private
+
+      def command_base_for(_name)
+        self
+      end
+    end
+  end
+end

data/lib/ergane/errors.rb

@@ -0,0 +1,51 @@
+# frozen_string_literal: true
+
+module Ergane
+  class Error < StandardError; end
+
+  class CommandNotFound < Error
+    attr_reader :token, :available
+
+    def initialize(token, available: [])
+      @token = token
+      @available = available
+      suggestion = find_suggestion
+      msg = "Unknown command: '#{token}'"
+      msg += ". Did you mean '#{suggestion}'?" if suggestion
+      msg += "\nAvailable commands: #{available.join(', ')}" if available.any?
+      super(msg)
+    end
+
+    private
+
+    def find_suggestion
+      return nil if available.empty?
+      best = available.min_by { |cmd| levenshtein(token.to_s, cmd.to_s) }
+      dist = levenshtein(token.to_s, best.to_s)
+      dist <= [token.to_s.length / 2, 3].max ? best : nil
+    end
+
+    def levenshtein(a, b)
+      m, n = a.length, b.length
+      return n if m.zero?
+      return m if n.zero?
+
+      d = Array.new(m + 1) { |i| i }
+      (1..n).each do |j|
+        prev = d[0]
+        d[0] = j
+        (1..m).each do |i|
+          cost = a[i - 1] == b[j - 1] ? 0 : 1
+          temp = d[i]
+          d[i] = [d[i] + 1, d[i - 1] + 1, prev + cost].min
+          prev = temp
+        end
+      end
+      d[m]
+    end
+  end
+
+  class MissingArgument < Error; end
+  class InvalidOption < Error; end
+  class AbstractCommand < Error; end
+end

data/lib/ergane/formatter.rb

@@ -0,0 +1,29 @@
+# frozen_string_literal: true
+
+module Ergane
+  # Small, generic output helpers for interactive CLIs.
+  module Formatter
+    class << self
+      # Prompt on stderr and return true only for an affirmative answer.
+      # Returns false when stdin isn't a TTY (non-interactive / piped input).
+      def confirm?(prompt)
+        $stderr.print "#{prompt} [y/N] "
+        return false unless $stdin.tty?
+
+        answer = $stdin.gets&.strip
+        answer&.match?(/\Ay(es)?\z/i)
+      end
+
+      # Humanize the distance from +time+ to now: "just now", "5m ago",
+      # "3h ago", "2d ago".
+      def time_ago(time)
+        seconds = (Time.now - time).to_i
+        return 'just now' if seconds < 60
+        return "#{seconds / 60}m ago" if seconds < 3600
+        return "#{seconds / 3600}h ago" if seconds < 86400
+
+        "#{seconds / 86400}d ago"
+      end
+    end
+  end
+end

data/lib/ergane/help_formatter.rb

@@ -0,0 +1,101 @@
+# frozen_string_literal: true
+
+module Ergane
+  class HelpFormatter
+    attr_reader :command_class, :command_path
+
+    def initialize(command_class, command_path: [])
+      @command_class = command_class
+      @command_path = command_path
+    end
+
+    def format
+      [
+        description_section,
+        version_section,
+        usage_section,
+        subcommands_section,
+        options_section,
+        arguments_section
+      ].compact.join("\n\n") + "\n"
+    end
+
+    private
+
+    def description_section
+      desc = command_class.description
+      desc if desc.present?
+    end
+
+    def version_section
+      ver = command_class.respond_to?(:version) && command_class.version
+      "Version: #{ver.to_s.light_blue}" if ver
+    end
+
+    def usage_section
+      path = command_path.any? ? command_path.join(" ") : command_class.command_name.to_s
+      usage = path.light_red
+      usage += " [options]".light_cyan if command_class.option_definitions.any?
+      usage += " [subcommand]".light_black.underline if command_class.subcommands.any?
+      command_class.argument_definitions.each do |arg|
+        label = arg.required ? "<#{arg.name}>" : "[#{arg.name}]"
+        usage += " #{label}".light_yellow
+      end
+      "Usage:".light_cyan + " " + usage
+    end
+
+    def subcommands_section
+      subs = command_class.subcommands
+      return if subs.empty?
+
+      max_width = subs.keys.map { |k| k.to_s.length }.max
+      Util::Formatting.reset_colors!
+
+      lines = []
+      lines << "Subcommands:".light_cyan
+      header_len = lines.last.uncolorize.length
+      lines << ("  \u250C" + ("\u2500" * (header_len - 2)) + "\u2518").light_black
+
+      subs.each do |name, sub_class|
+        label = name.to_s.ljust(max_width + 2)
+        desc = sub_class.description.present? ? sub_class.description.light_black : ""
+        lines << "  \u251C\u2500\u2510".light_black + " #{label.send(Util::Formatting.next_color)} #{desc}"
+      end
+
+      lines << ("  \u2514" + "\u2500" * 40).light_black
+      lines.join("\n")
+    end
+
+    def options_section
+      opts = command_class.option_definitions
+      return if opts.empty?
+
+      max_width = opts.values.map { |o| o.signature.length }.max
+
+      lines = ["Options:".light_cyan]
+      opts.each_value do |opt|
+        sig = opt.signature.ljust(max_width + 2)
+        desc = opt.description || ""
+        default_note = opt.default_value ? " (default: #{opt.default_value})".light_black : ""
+        lines << "  #{sig.light_green} #{desc}#{default_note}"
+      end
+      lines.join("\n")
+    end
+
+    def arguments_section
+      args = command_class.argument_definitions
+      return if args.empty?
+
+      max_width = args.map { |a| a.name.to_s.length }.max
+
+      lines = ["Arguments:".light_cyan]
+      args.each do |arg|
+        label = arg.name.to_s.ljust(max_width + 2)
+        desc = arg.description || ""
+        req = arg.required ? " (required)".light_red : " (optional)".light_black
+        lines << "  #{label.light_yellow} #{desc}#{req}"
+      end
+      lines.join("\n")
+    end
+  end
+end

data/lib/ergane/option_definition.rb

@@ -0,0 +1,49 @@
+# frozen_string_literal: true
+
+module Ergane
+  class OptionDefinition
+    attr_reader :name, :type, :short, :description, :default, :required, :optional
+
+    def initialize(name, type = nil, short: nil, description: nil, default: nil, required: false, optional: false)
+      @name = name.to_sym
+      @type = type
+      @short = short&.to_s
+      @description = description
+      @default = default
+      @required = required
+      @optional = optional
+    end
+
+    def boolean?
+      type.nil? || type == TrueClass || type == FalseClass
+    end
+
+    def default_value
+      boolean? ? (default.nil? ? false : default) : default
+    end
+
+    def long_flag
+      flag = "--#{name.to_s.tr('_', '-')}"
+      unless boolean?
+        flag += optional ? "=[VALUE]" : "=VALUE"
+      end
+      flag
+    end
+
+    def short_flag
+      "-#{short}" if short
+    end
+
+    def signature
+      [("#{short_flag}," if short), long_flag].compact.join(" ")
+    end
+
+    def attach(parser, store)
+      args = [short_flag, long_flag].compact
+      args << type if type && !boolean?
+      args << description if description
+
+      parser.on(*args) { |value| store[name] = value }
+    end
+  end
+end

data/lib/ergane/path_registry.rb

@@ -0,0 +1,47 @@
+# frozen_string_literal: true
+
+module Ergane
+  # An ordered registry of path-prefix → label substitutions, used by
+  # Command#abbreviate_path. Ships with $HOME → "~"; consumers register
+  # their own, e.g.:
+  #
+  #   Ergane.paths.register("~/Workspace", "@ws")
+  #
+  # When abbreviating, the longest matching prefix wins, and a prefix only
+  # matches at a path boundary so "/home/user" never clips "/home/username".
+  class PathRegistry
+    Substitution = Struct.new(:prefix, :label)
+
+    def initialize
+      @substitutions = []
+    end
+
+    # Register a +prefix+ to collapse to +label+. The prefix is expanded
+    # (so "~" and relative paths resolve), and re-registering a prefix
+    # replaces its previous label. Returns self for chaining.
+    def register(prefix, label)
+      expanded = File.expand_path(prefix.to_s)
+      @substitutions.reject! { |sub| sub.prefix == expanded }
+      @substitutions << Substitution.new(expanded, label.to_s)
+      self
+    end
+
+    # Remove every registered substitution. Returns self for chaining.
+    def clear
+      @substitutions.clear
+      self
+    end
+
+    # Collapse the longest matching prefix in +path+ to its label,
+    # returning the path unchanged when nothing matches.
+    def abbreviate(path)
+      str = path.to_s
+      best = @substitutions
+        .select { |sub| str == sub.prefix || str.start_with?("#{sub.prefix}/") }
+        .max_by { |sub| sub.prefix.length }
+      return str unless best
+
+      "#{best.label}#{str[best.prefix.length..]}"
+    end
+  end
+end

data/lib/ergane/runner.rb

@@ -0,0 +1,60 @@
+# frozen_string_literal: true
+
+module Ergane
+  class Runner
+    attr_reader :root, :argv
+
+    def initialize(root, argv)
+      @root = root
+      @argv = argv.dup
+    end
+
+    def execute
+      command_class, remaining, path = resolve(root, argv)
+
+      if help_requested?(remaining)
+        $stdout.puts HelpFormatter.new(command_class, command_path: path).format
+        return
+      end
+
+      if version_requested?(remaining) && command_class.respond_to?(:version) && command_class.version
+        $stdout.puts "#{command_class.command_name} #{command_class.version}"
+        return
+      end
+
+      instance = command_class.new(remaining)
+      instance.run(*instance.args)
+    end
+
+    private
+
+    def help_requested?(args)
+      args.include?("--help") || args.include?("-h")
+    end
+
+    def version_requested?(args)
+      args.include?("--version") || args.include?("-V")
+    end
+
+    def resolve(command_class, args, path = [])
+      path << (command_class.command_name || command_class.name || "command").to_s
+      return [command_class, args, path] if args.empty?
+
+      token = args.first
+      return [command_class, args, path] if token.start_with?("-")
+
+      sub = find_subcommand(command_class, token.to_sym)
+      if sub
+        args.shift
+        resolve(sub, args, path)
+      else
+        [command_class, args, path]
+      end
+    end
+
+    def find_subcommand(command_class, token)
+      command_class.subcommands[token] ||
+        command_class.subcommands.each_value.find { |cmd| cmd.terms.include?(token) }
+    end
+  end
+end

data/lib/ergane/tool.rb

@@ -1,116 +1,85 @@
-module Ergane
-  class Tool < CommandDefinition
-    attr_reader :title #capitalized :label
-    attr_reader :version
+# frozen_string_literal: true
 
-    def initialize(label, *paths)
-      super(label)
+module Ergane
+  class Tool < Command
+    self.abstract_class = true
+
+    class << self
+      def command_class(klass = nil)
+        if klass
+          @command_class = klass
+          wire_command_class(klass)
+        else
+          @command_class
+        end
+      end
 
-      @title = label.capitalize
-      @version = VERSION
+      def tool_name(name = nil)
+        name ? (self.command_name = name) : command_name
+      end
 
-      # Dogfood-ing
-      define do
-        description "Basic CLI Tool"
-        switches do
-          switch :help, default: false, kind: TrueClass, description: "Display this help block" do
-            raise Help
-          end
-          switch :version, default: false, kind: TrueClass, description: "Display the version" do
-            # TODO: Push ARGV into a variable at the command level that can be manipulated by flags/switches
-            # NOTE: This would allow a --version to morph into a version command and we could push all this logic to that.
-            # Additional logic for --version would be -1 or --short etc.
-            puts "#{@title} Version: #{Ergane::VERSION}"
-            exit
-          end
-          # switch verbose: FalseClass, short: :v, "Turn on verbose logging"
-        end
+      def version(ver = nil)
+        ver ? (@version = ver) : @version
+      end
 
-        run do
-          begin
-            command, args = self, []
-            Process.setproctitle(label.to_s)
-            command, args = self.parse_args(ARGV.dup)
+      def start(argv = ARGV)
+        Runner.new(self, argv.dup).execute
+      rescue Interrupt
+        $stderr.puts "\nAborted."
+        exit 130
+      rescue Ergane::Error => e
+        $stderr.puts e.message
+        exit 1
+      end
 
-            command.run(*args)
-            puts "Finished running #{label}"
-          rescue Interrupt
-            puts "\nOkay. Aborting."
-          rescue RuntimeError
-            puts "RuntimeError"
-            binding.pry
-          rescue Help
-            puts help(command, args)
-          ensure
-            system "printf '\033]0;\007'"
-          end
+      def load_commands(*patterns)
+        patterns.flatten.each do |pattern|
+          Dir[pattern].sort.each { |file| require file }
         end
       end
 
-      Pry.config.prompt_name = "#{title} ".light_blue
+      def inherited(subclass)
+        super
+        create_command_base(subclass) if self == Tool
+      end
 
-      load_commands(paths)
-    end
+      private
 
-    def help(command, args=[])
-      missing_args = command.arguments.product([false]).to_h.merge(args.product([true]).to_h).map do |arg, is_missing|
-        a = arg.to_s.light_black.underline.tap do |b|
-          b.blink if is_missing
-        end
-      end.join(' ')
-
-      command.switch_parser.banner = [].tap do |text|
-        text << "About: #{description}"
-        text << "Version:  #{version.to_s.light_blue}"
-        text << "Usage: #{([label] + chain).join(' ').light_red} #{'[options]'.light_cyan} "
-        if commands.any?
-          text.last << "[subcommand]".light_black.underline
-          text << ("    ┌" + ("─" * (text.last.uncolorize.length - 12)) + "┘").light_black
-          commands.each do |key, command|
-            # text << "    ├─┐".light_black + " #{(klass.terms.join(', ')).ljust(24, ' ')} ".send(Athena::Util.next_color) + klass.description.light_black
-            text << "    ├─┐".light_black + " #{key.to_s.ljust(24, ' ')} " + command.description.light_black
-          end
-          text << ("    └" + "─" * 64).light_black
-        else
-          # text.last << command.arguments(missing_args.keys)
-        end
-        # text << list_examples if examples.any?
-        text << "Options:".light_cyan
-      end.join("\n")
-      switch_parser
-    end
+      def command_base_for(_name)
+        command_class || self
+      end
 
-    def self.define(label, chain: [], &block)
-      c = CommandDefinition.define(label, chain: chain, &block)
+      def create_command_base(tool_subclass)
+        return if tool_subclass.command_class
 
-      parent_command = if chain.any?
-        Ergane.active_tool.dig(*chain)
-      else
-        Ergane.active_tool
+        base = Class.new(Ergane::Command)
+        base.abstract_class = true
+        tool_subclass.const_set(:Command, base)
+        tool_subclass.command_class(base)
       end
 
-      parent_command[label] = c
-    end
+      def wire_command_class(klass)
+        tool = self
+        klass.define_singleton_method(:tool) { tool }
 
-    def load_commands(paths)
-      activate_tool do
-        Ergane.logger.debug "Loading paths:"
-        Array.wrap(paths).each do |path|
-          Ergane.logger.debug "  - #{path}"
-          Dir[path].each do |path|
-            file = path.split('/').last
-            Ergane.logger.debug "  - loading #{path.split('/').last(4).join('/')}"
-            instance_eval(File.read(path), file)
+        klass.define_singleton_method(:inherited) do |subclass|
+          super(subclass)
+          cmd_name = subclass.command_name
+          if cmd_name && !subclass.abstract_class? && subclass.superclass.abstract_class?
+            subclass.instance_variable_set(:@_derived_name, cmd_name)
+            tool.subcommands[cmd_name] = subclass
           end
         end
-      end
-    end
 
-    private
-
-    def activate_tool(&block)
-      Ergane.activate_tool(self, &block)
+        klass.define_singleton_method(:inherited_command_name_set) do |subclass|
+          cmd_name = subclass.command_name
+          if cmd_name && !subclass.abstract_class? && subclass.superclass.abstract_class?
+            derived = subclass.instance_variable_get(:@_derived_name)
+            tool.subcommands.delete(derived) if derived && derived != cmd_name
+            tool.subcommands[cmd_name] = subclass
+          end
+        end
+      end
     end
-
   end
 end

data/lib/ergane/util/debug.rb

@@ -0,0 +1,24 @@
+# frozen_string_literal: true
+
+module Ergane
+  module Util
+    module Debug
+      def self.enabled?
+        !!$ergane_debug
+      end
+
+      def self.enable!
+        $ergane_debug = true
+      end
+
+      def self.disable!
+        $ergane_debug = false
+      end
+
+      def self.log(message)
+        return unless enabled?
+        $stderr.puts "[Ergane DEBUG] #{message}"
+      end
+    end
+  end
+end

data/lib/ergane/util/formatting.rb

@@ -0,0 +1,31 @@
+# frozen_string_literal: true
+
+module Ergane
+  module Util
+    module Formatting
+      extend self
+
+      COLORS = %i[light_red light_yellow light_green light_blue light_cyan light_magenta].freeze
+
+      def color_cycle
+        @color_cycle ||= COLORS.cycle
+      end
+
+      def next_color
+        color_cycle.next
+      end
+
+      def reset_colors!
+        @color_cycle = COLORS.cycle
+      end
+
+      def rainbow(string, delimiter = " ")
+        string.split(delimiter).map { |word| word.to_s.send(next_color) }.join(delimiter)
+      end
+
+      def colorize_list(items)
+        items.map { |item| item.to_s.send(next_color) }
+      end
+    end
+  end
+end

data/lib/ergane/version.rb

@@ -1,3 +1,5 @@
+# frozen_string_literal: true
+
 module Ergane
-  VERSION = '0.0.1'
+  VERSION = "0.1.0"
 end