shellopts 2.0.0.pre.1 → 2.0.0.pre.8

data/lib/shellopts/generator.rb

@@ -3,9 +3,9 @@ require 'shellopts/idr.rb'
 
 module ShellOpts
   module Idr
-    # Generates an Idr::Program from an Ast::Program object
-    def self.generate(ast, messenger)
-      Idr::Program.new(ast, messenger)
+    # Generates an Idr::Program from a ShellOpts object
+    def self.generate(shellopts)
+      Idr::Program.new(shellopts)
     end
   end
 end

data/lib/shellopts/grammar/command.rb

@@ -18,7 +18,7 @@ module ShellOpts
       attr_reader :option_list
 
       # List of commands in declaration order
-      attr_reader :command_list
+      attr_reader :subcommand_list
 
       # Multihash from option key or names (both short and long names) to option. This
       # means an option can occur more than once as the hash value
@@ -31,9 +31,9 @@ module ShellOpts
       # Sub-commands of this command. Is a multihash from sub-command key or
       # name to command object. Lazily constructed because subcommands are added
       # after initialization
-      def commands()
-        @command_multihash ||= @command_list.flat_map { |command| 
-          command.identifiers.map { |name| [name, command] }
+      def subcommands()
+        @subcommand_multihash ||= @subcommand_list.flat_map { |subcommand| 
+          subcommand.identifiers.map { |name| [name, subcommand] }
         }.to_h
       end
 
@@ -41,16 +41,15 @@ module ShellOpts
       # if this is the root object. name is the name of the command (without
       # the exclamation mark), and option_list a list of Option objects
       def initialize(parent, name, option_list)
-        super("#{name}!".to_sym)
-        @name = name
+        super("#{name}!".to_sym, name)
         parent.attach(self) if parent
         @option_list = option_list
-        @command_list = []
+        @subcommand_list = []
       end
 
       # Return key for the identifier
       def identifier2key(ident)
-        options[ident]&.key || commands[ident]&.key
+        options[ident]&.key || subcommands[ident]&.key
       end
 
       # Return list of identifiers for the command
@@ -65,16 +64,16 @@ module ShellOpts
           yield if block_given?
           puts "options:"
           indent { option_list.each { |opt| opt.dump } }
-          puts "commands: "
-          indent { command_list.each { |cmd| cmd.dump } }
+          puts "subcommands: "
+          indent { subcommand_list.each { |cmd| cmd.dump } }
         }
       end
       # :nocov:
 
     protected
-      def attach(command)
-        command.instance_variable_set(:@parent, self)
-        @command_list << command
+      def attach(subcommand)
+        subcommand.instance_variable_set(:@parent, self)
+        @subcommand_list << subcommand
       end
     end
   end

data/lib/shellopts/grammar/node.rb

@@ -10,14 +10,22 @@ module ShellOpts
       # Key (Symbol) of node. Unique within the enclosing command
       attr_reader :key
 
-      def initialize(key)
-        @key = key
+      # Name of node. The name of an option is without the prefixed '-' or
+      # '--', the name of a command is without the suffixed '!'. Note that name
+      # collisions can happen between options and commands names
+      attr_reader :name
+
+      def initialize(key, name)
+        @key, @name = key, name
       end
 
       # :nocov:
       def dump(&block) 
         puts key.inspect
-        indent { yield } if block_given?
+        indent { 
+          puts "name: #{name.inspect}"
+          yield if block_given?
+        }
       end
       # :nocov:
     end

data/lib/shellopts/grammar/option.rb

@@ -27,7 +27,8 @@ module ShellOpts
       # informal name of the option argument (eg. 'FILE') or nil if not present
       def initialize(short_names, long_names, flags, label = nil)
         @key_name = long_names.first || short_names.first
-        super(@key_name.sub(/^-+/, "").to_sym)
+        name = @key_name.sub(/^-+/, "")
+        super(name.to_sym, name)
         @short_names, @long_names = short_names, long_names
         @flags = flags.map { |flag| [flag, true] }.to_h
         @label = label

data/lib/shellopts/grammar/program.rb

@@ -17,7 +17,7 @@ module ShellOpts
       def usage
         (
           render_options(option_list) + 
-          command_list.map { |cmd| render_command(cmd) } + 
+          subcommand_list.map { |cmd| render_subcommand(cmd) } + 
           args
         ).flatten.join(" ")
       end
@@ -32,9 +32,9 @@ module ShellOpts
       # :nocov:
 
     private
-      def render_command(command)
-        [command.name] + render_options(command.option_list) + 
-            command.command_list.map { |cmd| render_command(cmd) }.flatten
+      def render_subcommand(subcommand)
+        [subcommand.name] + render_options(subcommand.option_list) + 
+            subcommand.subcommand_list.map { |cmd| render_subcommand(cmd) }.flatten
       end
 
       def render_options(options)

data/lib/shellopts/idr.rb

@@ -13,15 +13,14 @@ module ShellOpts
     # 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
-      #
-      # It is usually the first long option if present and else the first short
-      # option turned into a Symbol by first removing prefixed dashed, eg.
-      # '--all' becomes :all
       attr_reader :key
 
-      # Name of command and option as used on the command line
+      # 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),
@@ -33,10 +32,13 @@ module ShellOpts
       # 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(ast, key, name, value)
-        @ast, @key, @name, @value = ast, key, name, value
+      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
@@ -54,9 +56,9 @@ module ShellOpts
     protected
       # Initialize with defauls from the Ast. +value+ is set to true if option
       # doesn't take an argument
-      def initialize(ast)
+      def initialize(parent, ast)
         value = ast.grammar.argument? ? ast.value : true
-        super(ast, ast.key, ast.name, value)
+        super(parent, ast, ast.key, ast.name, value)
       end
     end
 
@@ -71,9 +73,9 @@ module ShellOpts
       alias :values :value
 
       # Name is set to the key name and value to an array of option values
-      def initialize(key, name, options)
+      def initialize(parent, key, name, options)
         @names = options.map(&:name)
-        super(nil, key, name, options.map(&:value))
+        super(parent, nil, key, name, options.map(&:value))
       end
     end
 
@@ -91,13 +93,13 @@ module ShellOpts
       attr_reader :subcommand
 
       # True if ident is declared
-      def declared?(ident) option?(ident) || command?(ident) end
+      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 command?(ident) grammar.commands.key?(ident) end 
+      def subcommand?(ident) grammar.subcommands.key?(ident) end
       
       # True if ident is present
       def key?(ident)
@@ -120,8 +122,8 @@ module ShellOpts
       end
 
       # Apply defaults recursively. Values can be lambdas that will be evaluated to
-      # get the default value
-      def apply(defaults = {}) end
+      # 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
@@ -129,49 +131,52 @@ module ShellOpts
       # Return options and command as a hash. The hash also define the
       # singleton method #subcommand that returns the key of the subcommand
       #
-      # +key+ controls the type of keys used: +:key+ (the default) use the
-      # symbolic key, +:name+ use key_name. Note that using +:name+ can cause name collisions between
-      # option and command names and that #to_s raises an exception if it detects a collision
+      # +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
+      # commands when using key_format: :name
       #
-      # IDEA: Make subcommand _not_ follow the +key+ setting so that setting key to
-      # IDEA: Add a singleton method #subcommand to the hash
+      # IDEA: Add a singleton methods to the hash with #name, #usage, etc.
       #
-      def to_h(use: :key, aliases: {})
+      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|
-          ident = aliases[opt.key] || (use == :key ? opt.key : opt.ast.grammar.key_name)
-          !value.key?(ident) or raise ConversionError, "Duplicate key: #{ident.inspect}"
+        options.values.each { |opt| # includes subcommand
+          key = keys[opt.key]
           case opt
             when Option
-              value[ident] = opt.value
+              value[key] = opt.value
             when Command
-              value[ident] = opt.value.to_h
-              value.define_singleton_method(:subcommand) { ident } # Redefine
+              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 = :key, aliases = {}) OptionStruct.new(self, key, aliases) end
+      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(ast)
-        super(ast, ast.key, ast.name, self)
-        @option_list = ast.options.map { |node| SimpleOption.new(node) }
-        @subcommand = Command.new(ast.command) if ast.command
+      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(key, ast.grammar.options[key].key_name, option_list)
+                OptionGroup.new(self, key, ast.grammar.options[key].key_name, option_list)
               else
                 option_list.first
               end
@@ -179,30 +184,52 @@ module ShellOpts
         }.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() @ast.arguments end
-
-      # Messenger object that is used to emit error messages. It should
-      # implement #error(*args) and #fail(*args)
-      attr_reader :messenger
+      def args() @shellopts.args end
 
       # Initialize the top-level Idr::Program object
-      def initialize(ast, messenger)
-        @messenger = messenger
-        super(ast)
+      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) messenger.error(*error_messages) end
+      def error(*args) @shellopts.error(*error_messages) end
 
       # Emit error message before exiting with status 1
-      def fail(*args) messenger.fail(*error_messages) end
+      def fail(*args) @shellopts.fail(*error_messages) end
     end
   end
 end

data/lib/shellopts/main.rb

@@ -0,0 +1,10 @@
+
+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

@@ -3,88 +3,8 @@ require 'shellopts/shellopts.rb'
 require 'shellopts/idr'
 
 module ShellOpts
-  class OptionStruct < BasicObject
-    # +key=:name+ cause command methods to be named without the exclamation
-    # mark. It doesn't change how options are named
-    def self.new(idr, key = :key, aliases = {})
-      ast = idr.instance_variable_get("@ast")
-      grammar = ast.grammar
-      instance = allocate
-
-      # Generate option accessor methods
-      grammar.option_list.each { |option|
-        key = alias_key(option.key, aliases)
-        instance.instance_eval("def #{key}() @#{key} end")
-        present = set_variable(instance, "@#{key}", idr[option.key])
-        instance.instance_eval("def #{key}?() #{present} end")
-      }
-
-      # Generate #subcommand default methods
-      if !idr.subcommand
-        instance.instance_eval("def subcommand() nil end")
-        instance.instance_eval("def subcommand?() false end")
-        instance.instance_eval("def subcommand!() nil end")
-      end
-
-      # Generate subcommand methods
-      grammar.command_list.each { |command|
-        key = alias_key(command.key, aliases)
-        if command.key == idr.subcommand&.key
-          struct = OptionStruct.new(idr.subcommand, 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!() @subcommand 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
-
-    # Replace key with alias and check against the list of reserved words
-    def self.alias_key(internal_key, aliases)
-      key = aliases[internal_key] || internal_key
-      !RESERVED_WORDS.include?(key.to_s) or
-        raise ::ShellOpts::ConversionError, "Can't create struct: '#{key}' is a reserved word"
-      key
-    end
-
-    # Shorthand helper method. Substitutes the undefined ObjectStruct#instance_variable_set
-    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
-
-    BASIC_OBJECT_RESERVED_WORDS = %w(
-         __id__ __send__ instance_eval instance_exec method_missing
-         singleton_method_added singleton_method_removed
-         singleton_method_undefined)
-    OPTIONS_STRUCT_RESERVED_WORDS = %w(subcommand)
-    RESERVED_WORDS = BASIC_OBJECT_RESERVED_WORDS + OPTIONS_STRUCT_RESERVED_WORDS
-  end
-end
-
-
-
-
-
-
-
-
-__END__
-
-module ShellOpts
+  # FIXME: Outdated
+  #
   # Struct representation of options. Usually created by ShellOpts::to_struct
   #
   # OptionStruct objects give easy access to configuration option values but
@@ -136,110 +56,93 @@ module ShellOpts
   # reserved words or with the special #command method
   #
   class OptionStruct < BasicObject
-    # Create a new OptionStruct instance from an AST. The optional
-    # +options_hash+ argument is used to create subcommands without creating a
-    # new options_hash argument. It is not meant for end-users. The
-    # +command_alias+ names the method holding the key for the subcommand (if
-    # any)
-    def self.new(ast, options_hash = OptionsHash.new(ast), command_alias: :command)
+    # 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_variable(instance, "@__options_hash__", options_hash)
 
-      # Check for reserved words and +command_alias+
-      options_hash.keys.each { |key| 
-        !RESERVED_WORDS.include?(key.to_s) or 
-          raise ::ShellOpts::ConversionError, "Can't create struct: '#{key}' is a reserved word"
-        key != command_alias or
-          raise ::ShellOpts::ConversionError, "Can't create struct: '#{key}' is the command alias"
-      }
+      # Set reference to Idr object. Is currently unused
+      set_variable(instance, "@__idr__", idr)
 
-      # Create accessor methods
-      ast.grammar.option_list.each { |option|
-        instance.instance_eval("def #{option.key}() @#{option.key} end")
-        instance.instance_eval("def #{option.key}?() false end")
+      # 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")
       }
-      ast.grammar.command_list.each { |command|
-        instance.instance_eval("def #{command.key}() nil 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")
       }
 
-      # Assign values
-      options_hash.each { |key, value|
-        if value.is_a?(OptionsHash)
-          set_variable(instance, "@__command__", OptionStruct.new(value.ast, value))
-          instance.instance_eval("def #{key}() @__command__ 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
-          set_variable(instance, "@#{key}", value)
-          instance.instance_eval("def #{key}?() true end")
+          instance.instance_eval("def #{key}() nil end")
         end
       }
 
-      # Command accessor method
-      instance.instance_eval("def #{command_alias}() @__options_hash__.command end")  
-
       instance
     end
 
-    # Return the OptionsHash object from the instance
-    def self.options_hash(instance)
-      get_variable(instance, "@__options_hash__")
-    end
-
+  private
     # Return class of object. #class is not defined for BasicObjects so this
-    # method provides an alternative way of getting the class a BasicObject
+    # 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
 
-    # Return the number of options and commands
-    def self.size(instance)
-      options_hash(instance).size
-    end
-
-    # Return the option and command keys. The keys are in order of occurrence
-    # on the command line. A subcommand will always be the last element
-    def self.keys(instance)
-      options_hash(instance).keys
-    end
-
-    # Return the actual option name used on the command line for +name+. Use
-    # +index+ to select between repeated options. Return the name of the
-    # program/subcommand if key is nil
-    def self.name(struct, key = nil, index = nil)
-      options_hash(struct).name(key, index)
-    end
-
-    # Return the AST node for the option key or the AST node for the
-    # OptionStruct if key is nil. Use +index+ to select between repeated
-    # options. Raise InternalError if key doesn't exists
-    def self.node(struct, key = nil, index = nil)
-      options_hash(struct).node(key, index)
-    end
-
-    # Return key of the command of the struct (possibly nil)
-    def self.command(struct)
-      options_hash(struct).command
-    end
-
-  private
-    BASIC_OBJECT_RESERVED_WORDS = %w(
-         __id__ __send__ instance_eval instance_exec method_missing
-         singleton_method_added singleton_method_removed
-         singleton_method_undefined)
-    OPTIONS_STRUCT_RESERVED_WORDS = %w(__options_hash__ __command__)
-    RESERVED_WORDS = BASIC_OBJECT_RESERVED_WORDS + OPTIONS_STRUCT_RESERVED_WORDS 
-
-    # Shorthand helper method. Substitutes the undefined ObjectStruct#instance_variable_set
+    # 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
 
-    # Shorthand helper method: Substitutes the undefined ObjectStruct#instance_variable_get
+    # 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 
+end