shellopts 2.0.0.pre.7 → 2.0.0.pre.14

data/lib/shellopts/parser.rb

@@ -1,106 +0,0 @@
-
-require 'shellopts/ast/node.rb'
-require 'shellopts/ast/option.rb'
-require 'shellopts/ast/command.rb'
-require 'shellopts/ast/program.rb'
-
-module ShellOpts
-  module Ast
-    # Parse ARGV according to grammar. Returns a Ast::Program object
-    def self.parse(grammar, argv)
-      grammar.is_a?(Grammar::Program) or 
-          raise InternalError, "Expected Grammar::Program object, got #{grammar.class}"
-      argv.is_a?(Array) or
-          raise InternalError, "Expected Array object, got #{argv.class}"
-      Parser.new(grammar, argv).call
-    end
-
-  private
-    # Parse a subcommand line
-    class Parser
-      class Error < RuntimeError; end
-
-      def initialize(grammar, argv)
-        @grammar, @argv = grammar, argv.dup
-        @seen_options = {} # Used to keep track of repeated options
-      end
-
-      def call
-        program = Ast::Program.new(@grammar)
-        parse_subcommand(program)
-        program.arguments = @argv
-        program
-      end
-
-    private
-      def parse_subcommand(subcommand)
-        @seen_options = {} # Every new subcommand resets the seen options
-        while arg = @argv.first
-          if arg == "--"
-            @argv.shift
-            break
-          elsif arg.start_with?("-")
-            parse_option(subcommand)
-          elsif cmd = subcommand.grammar.subcommands[arg]
-            @argv.shift
-            subcommand.subcommand = Ast::Command.new(cmd, arg)
-            parse_subcommand(subcommand.subcommand)
-            break
-          else
-            break
-          end
-        end
-      end
-
-      def parse_option(subcommand)
-        # Split into name and argument
-        case @argv.first
-          when /^(--.+?)(?:=(.*))?$/
-            name, arg, short = $1, $2, false
-          when /^(-.)(.+)?$/
-            name, arg, short = $1, $2, true
-        end
-        @argv.shift
-
-        option = subcommand.grammar.options[name] or raise Error, "Unknown option '#{name}'"
-        !@seen_options.key?(option.key) || option.repeated? or raise Error, "Duplicate option '#{name}'"
-        @seen_options[option.key] = true
-
-        # Parse (optional) argument
-        if option.argument?
-          if arg.nil? && !option.optional?
-            if !@argv.empty?
-              arg = @argv.shift
-            else
-              raise Error, "Missing argument for option '#{name}'"
-            end
-          end
-          arg &&= parse_arg(option, name, arg)
-        elsif arg && short
-          @argv.unshift("-#{arg}")
-          arg = nil
-        elsif !arg.nil?
-          raise Error, "No argument allowed for option '#{name}'"
-        end
-
-        subcommand.options << Ast::Option.new(option, name, arg)
-      end
-
-      def parse_arg(option, name, arg)
-        if option.string?
-          arg
-        elsif arg == ""
-          nil
-        elsif option.integer?
-          arg =~ /^-?\d+$/ or raise Error, "Illegal integer in '#{name}' argument: '#{arg}'"
-          arg.to_i
-        else # option.float?
-          # https://stackoverflow.com/a/21891705/2130986
-          arg =~ /^[+-]?(?:0|[1-9]\d*)(?:\.(?:\d*[1-9]|0))?$/ or
-              raise Error, "Illegal float in '#{name}' argument: '#{arg}'"
-          arg.to_f
-        end
-      end
-    end
-  end
-end

data/lib/shellopts/shellopts.rb

@@ -1,116 +0,0 @@
-
-require "shellopts"
-
-require "shellopts/args.rb"
-
-# TODO
-#
-# PROCESSING
-#   1. Compile spec string and yield a grammar
-#   2. Parse the options using the grammar and yield an AST
-#   3. Construct the Program model from the AST
-#   4. Apply defaults to the model
-#   6. Run validations on the model
-#   5. Create representation from the model
-#
-
-module ShellOpts
-  # The command line processing object
-  class ShellOpts
-    # Name of program
-    attr_accessor :name
-
-    # Usage string. If #usage is nil, the auto-generated default is used
-    def usage() @usage || @grammar.usage end
-    def usage=(usage) @usage = usage end
-
-    # Specification of the command
-    attr_reader :spec
-
-    # Original argv argument
-    attr_reader :argv
-
-    # The grammar compiled from the spec string
-    attr_reader :grammar
-
-    # The AST parsed from the command line arguments
-    attr_reader :ast
-
-    # The IDR generated from the Ast
-    attr_reader :idr
-
-    # Compile a spec string into a grammar and use that to parse command line
-    # arguments
-    #
-    # +spec+ is the spec string, and +argv+ the command line (typically the
-    # global ARGV array). +name+ is the name of the program and defaults to the
-    # basename of the program
-    #
-    # Syntax errors in the spec string are caused by the developer and raise a
-    # +ShellOpts::CompilerError+ exception. Errors in the +argv+ arguments are
-    # caused by the user and terminates the program with an error message and a
-    # short description of its spec
-    #
-    # TODO: Change to (name, spec, argv, usage: nil) because
-    # ShellOpts::ShellOpts isn't a magician like the ShellOpts module
-    def initialize(spec, argv, name: ::ShellOpts.default_name, usage: ::ShellOpts.default_usage)
-      @name = name
-      @spec = spec
-      @usage = usage
-      @argv = argv
-      begin
-        @grammar = Grammar.compile(@name, @spec)
-        @ast = Ast.parse(@grammar, @argv)
-        @idr = Idr.generate(self)
-      rescue Grammar::Compiler::Error => ex
-        raise CompilerError.new(5, ex.message)
-      rescue Ast::Parser::Error => ex
-        raise UserError.new(ex.message)
-      end
-    end
-
-    # Return an array representation of options and commands in the same order
-    # as on the command line. Each option or command is represented by a [name,
-    # value] pair. The value of an option is be nil if the option didn't have
-    # an argument and else either a String, Integer, or Float. The value of a
-    # command is an array of its options and commands
-    def to_a() idr.to_a end
-
-    # Return a hash representation of the options. See {ShellOpts::OptionsHash}
-    def to_h(key_type: ::ShellOpts.default_key_type, aliases: {})
-      @idr.to_h(key_type: :key_type, aliases: aliases) 
-    end
-
-    # TODO
-    # Return OptionHash object
-    # def to_hash(...)
-
-    # Return a struct representation of the options. See {ShellOpts::OptionStruct}
-    def to_struct(key_type: ::ShellOpts.default_key_type, aliases: {}) 
-      @idr.to_struct(key_type: key_type, aliases: aliases) 
-    end
-
-    # List of remaining non-option command line arguments. Returns a Argv object
-    def args() Args.new(self, ast&.arguments) end
-
-    # Iterate options and commands as name/value pairs. Same as +to_a.each+
-    def each(&block) to_a.each(&block) end
-
-    # Print error messages and spec string and exit with status 1. This method
-    # should be called in response to user-errors (eg. specifying an illegal
-    # option)
-    def error(*msgs, exit: true)
-      msg = "#{name}: #{msgs.join}\n" + (@usage ? usage : "Usage: #{name} #{usage}")
-      $stderr.puts msg.rstrip
-      exit(1) if exit
-    end
-
-    # Print error message and exit with status 1. This method should called in
-    # response to system errors (like disk full)
-    def fail(*msgs, exit: true)
-      $stderr.puts "#{name}: #{msgs.join}"
-      exit(1) if exit
-    end
-  end
-end
-