shellopts 2.0.0.pre.13 → 2.0.0.pre.14

data/lib/shellopts/idr.rb

@@ -1,236 +0,0 @@
-
-module ShellOpts
-  # Idr models the Internal Data Representation of a program. It is the native
-  # representation of a command
-  #
-  # The IDR should ideally be completely detached from the compile-time grammar
-  # and AST but they are only hidden from view in this implementation. Create
-  # a Shellopts object instead to access the compiler data
-  #
-  module Idr
-    # Base class for the Idr class hierarchy. It is constructed from an Ast
-    # object by #generate. Node is modelled as an element of a hash with a key
-    # and a value. Options have their (optional) argument as value while
-    # commands use +self+ as value
-    class Node
-      # Parent node. nil for the top-level Program object
-      attr_reader :parent
-
-      # Unique key (within context) for the option or command. nil for the
-      # top-level Program object
-      attr_reader :key
-
-      # Name of command or option as used on the command line
-      attr_reader :name
-
-      # Value of node. This can be a simple value (String, Integer, or Float),
-      # an Array of values, or a Idr::Command object. Note that the value of a
-      # Command object is the object itself
-      #
-      # Repeated options are implemented as an Array with one element for each
-      # use of the option. The element is nil if the option doesn't take
-      # arguments or if an optional argument is missing. 
-      attr_reader :value
-
-      # The top-level Program object
-      def program() @program ||= (parent&.program || self) end
-
-    protected
-      # Copy arguments into instance variables
-      def initialize(parent, ast, key, name, value)
-        @parent, @ast, @key, @name, @value = parent, ast, key, name, value
-      end
-
-      # The AST node for this Idr object
-      attr_reader :ast
-
-      # Shorthand to the grammar node for this Idr object
-      def grammar() @ast.grammar end
-    end
-
-    # Base class for Options
-    class Option < Node
-    end
-
-    class SimpleOption < Option
-    protected
-      # Initialize with defauls from the Ast. +value+ is set to true if option
-      # doesn't take an argument
-      def initialize(parent, ast)
-        value = ast.grammar.argument? ? ast.value : true
-        super(parent, ast, ast.key, ast.name, value)
-      end
-    end
-
-    # An OptionGroup models repeated options collapsed into a single key. The
-    # name of the group should be set to the name of the key (eg. '--all' if
-    # the key is :all)
-    class OptionGroup < Option
-      # Array of names of the options
-      attr_reader :names
-
-      # Array of values of the options
-      alias :values :value
-
-      # Name is set to the key name and value to an array of option values
-      def initialize(parent, key, name, options)
-        @names = options.map(&:name)
-        super(parent, nil, key, name, options.map(&:value))
-      end
-    end
-
-    class Command < Node
-      # Hash from key to options with repeated option_list collapsed into a
-      # option group. It also include an entry for the subcommand.  Options are
-      # ordered by first use on the command line. The command entry will always
-      # be last
-      attr_reader :options
-
-      # List of command line options in the same order as on the command line
-      attr_reader :option_list
-
-      # Subcommand object. Possibly nil
-      attr_reader :subcommand
-
-      # True if ident is declared
-      def declared?(ident) option?(ident) || subcommand?(ident) end
-
-      # True if ident is declared as an option
-      def option?(ident) grammar.options.key?(ident) end
-
-      # True if ident is declared as a command
-      def subcommand?(ident) grammar.subcommands.key?(ident) end
-      
-      # True if ident is present
-      def key?(ident)
-        declared?(ident) or raise InternalError, "Undefined identifier: #{ident.inspect}"
-        key = grammar.identifier2key(ident)
-        @options.key?(key)
-      end
-
-      # Value of ident. Repeated options are collapsed into an OptionGroup object
-      def [](ident)
-        declared?(ident) or raise InternalError, "Undefined identifier: #{ident.inspect}"
-        key = grammar.identifier2key(ident)
-        if @options.key?(key)
-          @options[key].value
-        elsif option?(key)
-          false
-        else
-          nil
-        end
-      end
-
-      # Apply defaults recursively. Values can be lambdas that will be evaluated to
-      # get the default value. TODO
-      def apply(defaults = {}) raise InternalError, "Not implemented" end
-
-      # Return options and command as an array
-      def to_a() @ast.values end
-
-      # Return options and command as a hash. The hash also define the
-      # singleton method #subcommand that returns the key of the subcommand
-      #
-      # +key_type+ controls the type of keys used: +:key+ (the default) use the
-      # symbolic key, +:name+ use #name. Note that using +:name+ can cause
-      # name collisions between option and command names
-      #
-      # +aliases+ maps from key to replacement key (which could be any object).
-      # +aliases+ can be used to avoid name collisions between options and
-      # commands when using key_format: :name
-      #
-      # IDEA: Add a singleton methods to the hash with #name, #usage, etc.
-      #
-      def to_h(key_type: ::ShellOpts.default_key_type, aliases: {})
-        keys = map_keys(key_type, aliases)
-        value = {}
-        value.define_singleton_method(:subcommand) { nil }
-        options.values.each { |opt| # includes subcommand
-          key = keys[opt.key]
-          case opt
-            when Option
-              value[key] = opt.value
-            when Command
-              value[key] = opt.value.to_h(key_type: key_type, aliases: aliases[opt.key] || {})
-              value.define_singleton_method(:subcommand) { key } # Redefine
-          else
-            # :nocov:
-            raise InternalError, "Oops"
-            # :nocov:
-          end
-        }
-        value
-      end
-
-      # Return options and command as a struct
-      def to_struct(key_type: ::ShellOpts.default_key_type, aliases: {})
-        OptionStruct.new(self, key_type, aliases) 
-      end
-
-    protected
-      # Initialize an Idr::Command object and all dependent objects
-      def initialize(parent, ast)
-        super(parent, ast, ast.key, ast.name, self)
-        @option_list = ast.options.map { |node| SimpleOption.new(self, node) }
-        @subcommand = Command.new(self, ast.subcommand) if ast.subcommand
-        @options = @option_list.group_by { |option| option.key }.map { |key, option_list|
-          option = 
-              if ast.grammar.options[key].repeated?
-                OptionGroup.new(self, key, ast.grammar.options[key].key_name, option_list)
-              else
-                option_list.first
-              end
-          [key, option]
-        }.to_h
-        @options[subcommand.key] = @subcommand if @subcommand
-      end
-
-      # Internal-key to used-key map. Checks for reserved words and
-      # name-collisions
-      def map_keys(key_type, aliases, reserved_words = [])
-        keys = {}
-        used_keys = {}
-        (grammar.option_list + grammar.subcommand_list).each { |node|
-          internal_key = node.key
-          key = aliases[internal_key] || (key_type == :name ? node.name.to_sym : internal_key)
-          !reserved_words.include?(key) or
-              raise ::ShellOpts::ConversionError, "'#{key}' is a reserved word"
-          !used_keys.key?(key) or 
-              raise ::ShellOpts::ConversionError, "Name collision between '--#{key}' and '#{key}!'"
-          keys[internal_key] = key
-          used_keys[key] = true
-        }
-        keys
-      end
-    end
-
-    class Program < Command
-      # Name of program
-      def name() @shellopts.name end
-      def name=(name) @shellopts.name = name end
-
-      # Usage string
-      def usage() @shellopts.usage end
-      def usage=(usage) @shellopts.usage = usage end
-
-      # #key is nil for the top-level Program object
-      def key() nil end
-
-      # Remaining command line arguments
-      def args() @shellopts.args end
-
-      # Initialize the top-level Idr::Program object
-      def initialize(shellopts)
-        @shellopts = shellopts
-        super(nil, shellopts.ast)
-      end
-
-      # Emit error message and a usage description before exiting with status 1
-      def error(*args) @shellopts.error(*error_messages) end
-
-      # Emit error message before exiting with status 1
-      def fail(*args) @shellopts.fail(*error_messages) end
-    end
-  end
-end
-

data/lib/shellopts/main.rb

@@ -1,10 +0,0 @@
-
-module ShellOpts
-  # Gives access to the ruby main object
-  module Main
-    CALLER_RE = /^.*:in `<main>'$/
-    def self.main() TOPLEVEL_BINDING.eval("self") end
-  end
-end
-
-

data/lib/shellopts/option_struct.rb

@@ -1,148 +0,0 @@
-
-require 'shellopts/shellopts.rb'
-require 'shellopts/idr'
-
-module ShellOpts
-  # FIXME: Outdated
-  #
-  # Struct representation of options. Usually created by ShellOpts::to_struct
-  #
-  # OptionStruct objects give easy access to configuration option values but
-  # meta data are more circuitously accessed through class methods with an
-  # explicit instance argument
-  #
-  # Option values are accessed through a member methods named after the key of
-  # the option. Repeated options have an Array value with one element (possibly
-  # nil) for each use of the option. A query method with a '?' suffixed to the
-  # name returns true or false depending on whether the option was used or not
-  #
-  #   option   - Value of option. Either an object or an Array if the option can
-  #              be repeated
-  #   option?  - True iff option was given
-  #
-  # Command methods return a nested OptionStruct object while the special
-  # #command method returns the key of actual command (if any). Use
-  # +strukt.send(strukt.command)+ to get the subcommand of a OptionStruct. It
-  # is possible to rename #command method to avoid name collisions 
-  #
-  #   name!   - Command. An OptionStruct or nil if not given on the command line
-  #   subcommand - Key of command. Can be renamed
-  #
-  # ---------------------------------
-  #   name!   - Command. An OptionStruct or nil if not given on the command line
-  #
-  #   key!    - Key of command
-  #   value!  - Value of command (a subcommand). Can be renamed
-  #
-  # Note: There is no command query method because option and command names
-  # live in seperate namespaces and could cause colllisions. Check +name!+ for
-  # nil to detect if a command was given
-  #
-  # Meta data are extracted through class methods to avoid polluting the object
-  # namespace. OptionStruct use an OptionsHash object internally and
-  # implements a subset of its meta methods by forwarding to it. The
-  # OptionsHash object can be accessed through the #options_hash method
-  #
-  # Note that #command is defined as both an instance method and a class
-  # method. Use the class method to make the code work with all OptionStruct
-  # objects even if #command has been renamed
-  #
-  # +ShellOpts+ is derived from +BascicObject+ that reserves some words for
-  # internal use (+__id__+, +__send__+, +instance_eval+, +instance_exec+,
-  # +method_missing+, +singleton_method_added+, +singleton_method_removed+,
-  # +singleton_method_undefined+). ShellOpts also define two reserved words of
-  # its own (+__options_hash__+ and +__command__+). ShellOpts raise an
-  # ShellOpts::ConversionError if an option collides with one of the
-  # reserved words or with the special #command method
-  #
-  class OptionStruct < BasicObject
-    # Create a OptionStruct object recursively from an Idr::Command object
-    def self.new(idr, key_type, aliases = {})
-      # Shorthands
-      ast = idr.instance_variable_get("@ast")
-      grammar = ast.grammar
-
-      # Get key map
-      keys = idr.send(:map_keys, key_type, aliases, RESERVED_WORDS)
-
-      # Allocate OptionStruct instance
-      instance = allocate
-
-      # Set reference to Idr object. Is currently unused
-      set_variable(instance, "@__idr__", idr)
-
-      # Generate general option accessor methods
-      grammar.option_list.each { |option|
-        key = keys[option.key]
-        instance.instance_eval("def #{key}() @#{key} end")
-        instance.instance_eval("def #{key}?() false end")
-      }
-
-      # Generate accessor method for present options
-      idr.option_list.each { |option|
-        key = keys[option.key]
-        set_variable(instance, "@#{key}", idr[option.key])
-        instance.instance_eval("def #{key}?() true end")
-      }
-
-      # Generate general #subcommand methods
-      if !idr.subcommand
-        instance.instance_eval("def subcommand() nil end")
-        instance.instance_eval("def subcommand?() false end")
-        instance.instance_eval %(
-            def subcommand!(*msgs)
-              $stderr.puts "in subcommand!"
-              ::Kernel.raise ::ShellOpts::UserError, (msgs.empty? ? 'No command' : msgs.join)
-            end
-        )
-      end
-
-      # Generate individual subcommand methods
-      grammar.subcommand_list.each { |subcommand|
-        key = keys[subcommand.key]
-        if subcommand.key == idr.subcommand&.key
-          struct = OptionStruct.new(idr.subcommand, key_type, aliases[idr.subcommand.key] || {})
-          set_variable(instance, "@subcommand", struct)
-          instance.instance_eval("def #{key}() @subcommand end")
-          instance.instance_eval("def subcommand() :#{key} end")
-          instance.instance_eval("def subcommand?() true end")
-          instance.instance_eval("def subcommand!(*msgs) :#{key} end")
-        else
-          instance.instance_eval("def #{key}() nil end")
-        end
-      }
-
-      instance
-    end
-
-  private
-    # Return class of object. #class is not defined for BasicObjects so this
-    # method provides an alternative way of getting the class
-    def self.class_of(object) 
-      # https://stackoverflow.com/a/18621313/2130986
-      ::Kernel.instance_method(:class).bind(object).call 
-    end
-
-    # Class method implementation of ObjectStruct#instance_variable_set that is
-    # not defined in a BasicObject
-    def self.set_variable(this, var, value)
-      # https://stackoverflow.com/a/18621313/2130986
-      ::Kernel.instance_method(:instance_variable_set).bind(this).call(var, value)
-    end
-
-    # Class method implementation of ObjectStruct#instance_variable_get that is
-    # not defined in a BasicObject
-    def self.get_variable(this, var)
-      # https://stackoverflow.com/a/18621313/2130986
-      ::Kernel.instance_method(:instance_variable_get).bind(this).call(var)
-    end
-
-    BASIC_OBJECT_RESERVED_WORDS = %w(
-         __id__ __send__ instance_eval instance_exec method_missing
-         singleton_method_added singleton_method_removed
-         singleton_method_undefined).map(&:to_sym)
-    OPTIONS_STRUCT_RESERVED_WORDS = %w(__idr__ subcommand).map(&:to_sym)
-    RESERVED_WORDS = BASIC_OBJECT_RESERVED_WORDS + OPTIONS_STRUCT_RESERVED_WORDS
-  end
-end
-

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