command_mapper-gen 0.1.0.pre1

data/lib/command_mapper/gen/cli.rb

@@ -0,0 +1,233 @@
+require 'command_mapper/gen/parsers'
+require 'command_mapper/gen/command'
+require 'command_mapper/gen/version'
+
+require 'optparse'
+
+module CommandMapper
+  module Gen
+    class CLI
+
+      PROGRAM_NAME = "command_mapper-gen"
+
+      PARSERS = {
+        'help' => Parsers::Help,
+        'man'  => Parsers::Man
+      }
+
+      BUG_REPORT_URL = "https://github.com/postmodern/command_mapper-gen/issues/new"
+
+      # The output file or `nil` for stdout.
+      #
+      # @return [File, nil]
+      attr_reader :output
+
+      # The parsers to run.
+      #
+      # @return [Array<Parsers::Help, Parsers::Man>]
+      attr_reader :parsers
+
+      # Specifies whether debug output should be printed.
+      #
+      # @return [Boolean, nil]
+      attr_reader :debug
+
+      # The parsed command.
+      #
+      # @return [Command]
+      attr_reader :command
+
+      # The command's option parser.
+      #
+      # @return [OptionParser]
+      attr_reader :option_parser
+
+      #
+      # Initializes the command.
+      #
+      def initialize
+        @output  = nil
+        @parsers = PARSERS.values
+        @debug   = false
+        @command = nil
+
+        @option_parser = option_parser
+      end
+
+      #
+      # Initializes and runs the command.
+      #
+      # @param [Array<String>] argv
+      #   Command-line arguments.
+      #
+      # @return [Integer]
+      #   The exit status of the command.
+      #
+      def self.run(argv=ARGV)
+        new().run(argv)
+      rescue Interrupt
+        # https://tldp.org/LDP/abs/html/exitcodes.html
+        return 130
+      rescue Errno::EPIPE
+        # STDOUT pipe broken
+        return 0
+      end
+
+      #
+      # Runs the command.
+      #
+      # @param [Array<String>] argv
+      #   Command-line arguments.
+      #
+      # @return [Integer]
+      #   The exit status of the command.
+      #
+      def run(argv=ARGV)
+        argv = begin
+                 @option_parser.parse(argv)
+               rescue OptionParser::ParseError => error
+                 print_error(error.message)
+                 return -1
+               end
+
+        if argv.empty?
+          print_error "expects a COMMAND_NAME"
+          return -1
+        end
+
+        begin
+          @command = Command.new(argv.first)
+
+          @parsers.each do |parser|
+            parse_command = ->(command) {
+              parser.run(command) do |line,parse_error|
+                print_parser_error(command,line,parse_error)
+              end
+
+              command.subcommands.each_value do |subcommand|
+                parse_command.call(subcommand)
+              end
+            }
+
+            parse_command.call(@command)
+          end
+        rescue Error => error
+          print_error(error.message)
+          return -1
+        end
+
+        if (@command.options.empty? &&
+            @command.arguments.empty? &&
+            @command.subcommands.empty?)
+          print_error "no options or arguments detected"
+          return -2
+        end
+
+        if @output then @command.save(@output)
+        else            puts command.to_ruby
+        end
+
+        return 0
+      rescue => error
+        print_backtrace(error)
+        return -1
+      end
+
+      #
+      # The option parser.
+      #
+      # @return [OptionParser]
+      #
+      def option_parser
+        OptionParser.new do |opts|
+          opts.banner = "usage: #{PROGRAM_NAME} [options] COMMAND_NAME"
+
+          opts.separator ""
+          opts.separator "Options:"
+
+          opts.on('-o','--output FILE','Saves the output to FILE') do |file|
+            @output = file
+          end
+
+          opts.on('-p','--parser=PARSER', PARSERS, 'Selects which parser to use (help or man)') do |parser|
+            @parsers = [parser]
+          end
+
+          opts.on('-d','--debug','Enables debugging output') do
+            @debug = true
+          end
+
+          opts.on('-V','--version','Print the version') do
+            puts "#{PROGRAM_NAME} #{VERSION}"
+            exit
+          end
+
+          opts.on('-h','--help','Print the help output') do
+            puts opts
+            exit
+          end
+
+          opts.separator ""
+          opts.separator "Examples:"
+          opts.separator "    #{PROGRAM_NAME} grep"
+          opts.separator ""
+        end
+      end
+
+      #
+      # Prints an error message to stderr.
+      #
+      # @param [String] error
+      #   The error message.
+      #
+      def print_error(error)
+        $stderr.puts "#{PROGRAM_NAME}: #{error}"
+      end
+
+      #
+      # Prints a parsing error to stderr.
+      #
+      # @param [Command] command
+      #   The command that was being populated.
+      #
+      # @param [String] string
+      #   The text that could not be parsed.
+      #
+      # @param [Parslet::ParseError] error
+      #   The parsing error.
+      #
+      def print_parser_error(command,string,error)
+        $stderr.puts "Failed to parse line in `#{command.command_string} --help`:"
+        $stderr.puts ""
+        $stderr.puts "  #{string}"
+        $stderr.puts
+
+        if @debug
+          error.parse_failure_cause.ascii_tree.each_line do |backtrace_line|
+            $stderr.puts "  #{backtrace_line}"
+          end
+        else
+          $stderr.puts error.message
+        end
+
+        $stderr.puts ""
+      end
+
+      #
+      # Prints a backtrace to stderr.
+      #
+      # @param [Exception] exception
+      #   The exception.
+      #
+      def print_backtrace(exception)
+        $stderr.puts "Oops! Looks like you've found a bug!"
+        $stderr.puts "Please report the following to: #{BUG_REPORT_URL}"
+        $stderr.puts
+        $stderr.puts "```"
+        $stderr.puts "#{exception.full_message}"
+        $stderr.puts "```"
+      end
+
+    end
+  end
+end

data/lib/command_mapper/gen/command.rb

@@ -0,0 +1,202 @@
+require 'command_mapper/gen/option'
+require 'command_mapper/gen/argument'
+require 'command_mapper/gen/types'
+
+module CommandMapper
+  module Gen
+    #
+    # Represents a mock `CommandMapper::Command` class that will be populated
+    # by the {Parsers} and written out to a file.
+    #
+    # @api private
+    #
+    class Command
+
+      # The command's name.
+      #
+      # @return [String]
+      attr_accessor :command_name
+
+      # The parent command of this sub-command.
+      #
+      # @return [Command, nil]
+      attr_reader :parent_command
+
+      # @return [Hash{String => Option}]
+      attr_reader :options
+
+      # @return [Hash{Symbol => Argument}]
+      attr_reader :arguments
+
+      # @return [Hash{String => Command}]
+      attr_reader :subcommands
+
+      #
+      # Initializes the parsed command.
+      #
+      # @param [String] command_name
+      #   The command name or path to the command.
+      #
+      def initialize(command_name,parent_command=nil)
+        @command_name   = command_name
+        @parent_command = parent_command
+
+        @options     = {}
+        @arguments   = {}
+        @subcommands = {}
+      end
+
+      #
+      # The command string to run the command.
+      #
+      # @return [String]
+      #
+      def command_string
+        if @parent_command
+          "#{@parent_command.command_string} #{@command_name}"
+        else
+          @command_name
+        end
+      end
+
+      #
+      # The man-page name for the command.
+      #
+      # @return [String]
+      #
+      def man_page
+        if @parent_command
+          "#{@parent_command.man_page}-#{@command_name}"
+        else
+          @command_name
+        end
+      end
+
+      #
+      # Defines an option for the command.
+      #
+      # @param [String] flag
+      #
+      # @param [Hash{Symbol => Object}] kwargs
+      #
+      def option(flag,**kwargs)
+        @options[flag] = Option.new(flag,**kwargs)
+      end
+
+      #
+      # Defines an argument for the command.
+      #
+      # @param [Symbol] name
+      #
+      # @param [Hash{Symbol => Object}] kwargs
+      #
+      def argument(name,**kwargs)
+        @arguments[name] = Argument.new(name,**kwargs)
+      end
+
+      #
+      # Defines a new sub-command.
+      #
+      # @param [String] name
+      #   The subcommand name.
+      #
+      # @return [Command]
+      #   The newly defined subcommand.
+      #
+      def subcommand(name)
+        @subcommands[name] = Command.new(name,self)
+      end
+
+      #
+      # The CamelCase class name derived from the {#command_name}.
+      #
+      # @return [String, nil]
+      #   The class name or `nil` if {#command_name} is also `nil`.
+      #
+      def class_name
+        @command_name.split(/[_-]+/).map(&:capitalize).join
+      end
+
+      #
+      # Converts the parsed command to Ruby source code.
+      #
+      # @return [String]
+      #   The generated ruby source code for the command.
+      #
+      def to_ruby
+        lines = []
+
+        if @parent_command.nil?
+          lines << "require 'command_mapper/command'"
+          lines << ""
+          lines << "#"
+          lines << "# Represents the `#{@command_name}` command"
+          lines << "#"
+
+          lines << "class #{class_name} < CommandMapper::Command"
+          lines << ""
+          lines << "  command #{@command_name.inspect} do"
+
+          indent = "    "
+        else
+          lines << "subcommand #{@command_name.inspect} do"
+
+          indent = "  "
+        end
+
+        unless @options.empty?
+          @options.each_value do |option|
+            lines << "#{indent}#{option.to_ruby}"
+          end
+        end
+
+        if (!@options.empty? && !@arguments.empty?)
+          lines << ''
+        end
+
+        unless @arguments.empty?
+          @arguments.each_value do |argument|
+            lines << "#{indent}#{argument.to_ruby}"
+          end
+        end
+
+        unless @subcommands.empty?
+          if (!@options.empty? || !@arguments.empty?)
+            lines << ''
+          end
+
+          @subcommands.each_value.each_with_index do |subcommand,index|
+            lines << '' if index > 0
+
+            subcommand.to_ruby.each_line do |line|
+              if line == $/
+                lines << ''
+              else
+                lines << "#{indent}#{line.chomp}"
+              end
+            end
+          end
+        end
+
+        if @parent_command.nil?
+          lines << "  end"
+          lines << ''
+        end
+
+        lines << "end"
+
+        return lines.join($/) + $/
+      end
+
+      #
+      # Saves the parsed command to the given file path.
+      #
+      # @param [String] path
+      #
+      def save(path)
+        File.write(path,to_ruby)
+      end
+
+    end
+  end
+end

data/lib/command_mapper/gen/exceptions.rb

@@ -0,0 +1,9 @@
+module CommandMapper
+  module Gen
+    class Error < RuntimeError
+    end
+
+    class CommandNotInstalled < Error
+    end
+  end
+end

data/lib/command_mapper/gen/option.rb

@@ -0,0 +1,66 @@
+require 'command_mapper/gen/option_value'
+
+module CommandMapper
+  module Gen
+    #
+    # Represents a mock `CommandMapper::Option` class.
+    #
+    class Option
+
+      # The option flag for the option.
+      #
+      # @return [String]
+      attr_reader :flag
+
+      # @return [Boolean, :equals, nil]
+      attr_reader :equals
+
+      # @return [Boolean, nil]
+      attr_reader :repeats
+
+      # @return [OptionValue, nil]
+      attr_reader :value
+
+      #
+      # Initializes the parsed argument.
+      #
+      # @param [String] flag
+      #   The option flag.
+      #
+      # @param [Boolean, :optional, nil] equals
+      #
+      # @param [Boolean, nil] repeats
+      #
+      # @param [Hash{Symbol => Object}, nil] value
+      #
+      def initialize(flag, equals: nil, repeats: nil, value: nil)
+        @flag    = flag
+        @equals  = equals
+        @value   = OptionValue.new(**value) if value
+        @repeats = repeats
+      end
+
+      #
+      # Converts the parsed option to Ruby source code.
+      #
+      # @return [String]
+      #
+      def to_ruby
+        ruby = "option #{@flag.inspect}"
+        fixme = nil
+
+        if @flag =~ /^-[a-zA-Z0-9]/ && @flag.length <= 3
+          ruby << ", name: "
+          fixme = "name"
+        end
+
+        ruby << ", equals: #{@equals.inspect}"   unless @equals.nil?
+        ruby << ", repeats: #{@repeats.inspect}" unless @repeats.nil?
+        ruby << ", value: #{@value.to_ruby}" if @value
+        ruby << "\t# FIXME: #{fixme}" if fixme
+        ruby
+      end
+
+    end
+  end
+end

data/lib/command_mapper/gen/option_value.rb

@@ -0,0 +1,23 @@
+require 'command_mapper/gen/arg'
+require 'command_mapper/gen/types/str'
+
+module CommandMapper
+  module Gen
+    class OptionValue < Arg
+
+      #
+      # Converts the parsed option to Ruby source code.
+      #
+      # @return [String]
+      #
+      def to_ruby
+        ruby = super()
+
+        if ruby.empty? then "true"
+        else                "{#{ruby}}"
+        end
+      end
+
+    end
+  end
+end

data/lib/command_mapper/gen/parsers/common.rb

@@ -0,0 +1,49 @@
+require 'parslet'
+
+module CommandMapper
+  module Gen
+    module Parsers
+      class Common < Parslet::Parser
+
+        rule(:space)  { match[' '] }
+        rule(:spaces) { space.repeat(1) }
+        rule(:space?) { space.maybe }
+
+        rule(:ellipsis)  { str('...') }
+        rule(:ellipsis?) { (space? >> ellipsis.as(:repeats)).maybe }
+
+        rule(:lowercase_name) do
+          match['a-z'] >> match['a-z0-9'].repeat(0) >> (
+            match['_-'] >> match['a-z0-9'].repeat(1)
+          ).repeat(0)
+        end
+
+        rule(:uppercase_name) do
+          match['A-Z'] >> match['A-Z0-9'].repeat(0) >> (
+            match['_-'] >> match['A-Z0-9'].repeat(1)
+          ).repeat(0)
+        end
+
+        rule(:camelcase_name) do
+          match['a-z'] >> match['a-z0-9'].repeat(0) >> (
+            match['A-Z'] >> match['a-z0-9'].repeat(1)
+          ).repeat(1)
+        end
+
+        rule(:capitalized_name) do
+          match['A-Z'] >> match['a-z0-9'].repeat(1) >> (
+            match['_-'] >> match['a-z0-9'].repeat(1)
+          ).repeat(0)
+        end
+
+        rule(:short_flag) { str('-') >> match['a-zA-Z0-9#'] }
+        rule(:long_flag) do
+          str('--') >> match['a-zA-Z'] >> match['a-zA-Z0-9'].repeat(1) >> (
+            match['_-'] >> match['a-zA-Z0-9'].repeat(1)
+          ).repeat(0)
+        end
+
+      end
+    end
+  end
+end