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

data/lib/shellopts/grammar/option.rb

@@ -1,66 +1,55 @@
 module ShellOpts
   module Grammar
-    # Models an Option
-    #
-    # Sets Node#key to the first long option name if present or else the first short option
-    class Option < Node
-      # List of short names (incl. '-')
-      attr_reader :short_names
-
-      # List of long names (incl. '--')
-      attr_reader :long_names
-
-      # Name of the key attribute (eg. if key is :all then key_name is '--all'
-      attr_reader :key_name
-
-      # List of flags (Symbol)
-      def flags() @flags.keys end
-
-      # Informal name of argument (eg. 'FILE'). nil if not present
-      attr_reader :label
-
-      # Initialize an option. Short and long names are arrays of the short/long
-      # option names (incl. the '-'/'--' prefix). It is assumed that at least
-      # one name is given. Flags is a list of symbolic flags. Allowed flags are
-      # :repeated, :argument, :optional, :integer, and :float. Note that
-      # there's no :string flag, it's status is inferred. label is the optional
-      # 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
-        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
-      end
-
-      # Array of option names with short names first and then the long names
-      def names() @short_names + @long_names end
-
-      # Array of names and the key
-      def identifiers() names + [key] end
-
-      # Return true if +ident+ is equal to any name or to key
-      def match?(ident) names.include?(ident) || ident == key end
-
-      # Flag query methods. Returns true if the flag is present and otherwise nil
-      def repeated?() @flags[:repeated] || false end
-      def argument?() @flags[:argument] || false end
-      def optional?() argument? && @flags[:optional] || false end
-      def string?() argument? && !integer? && !float? end
-      def integer?() argument? && @flags[:integer] || false end
-      def float?() argument? && @flags[:float] || false end
-
-      # :nocov:
-      def dump
-        super {
-          puts "short_names: #{short_names.inspect}"
-          puts "long_names: #{long_names.inspect}"
-          puts "flags: #{flags.inspect}"
-          puts "label: #{label.inspect}"
-        }
+    class Option
+      # Symbolic identifier. This is the name of the option with dashes ('-')
+      # replaced with underscores ('_')
+      attr_reader :ident
+
+      # Name of option. This is the name of the first long option or the name
+      # of the first short option if there is no long option name. It is used
+      # to compute #ident
+      attr_reader :name
+
+      # Long name of option or nil if not present
+      attr_reader :longname
+
+      # Short name of option or nil if not present
+      attr_reader :shortname
+
+      # List of all names
+      attr_reader :names
+
+      # Name of argument or nil if not present
+      attr_reader :argument_name
+
+      # Comment
+      attr_reader :text
+
+      def repeatable?() @repeatable end
+      def argument?() @argument end
+      def integer?() @integer end
+      def float?() @float end
+      def string?() !@integer && !@float end
+      def optional?() @optional end
+
+      def initialize(names, repeatable: nil, argument: nil, integer: nil, float: nil, optional: nil)
+        @names = names.dup
+        @longname = @names.find { |name| name.length > 1 } 
+        @shortname = @names.find { |name| name.length == 1 }
+        @name = @longname || @shortname
+        @ident = @name.gsub("-", "_").to_sym
+        @repeatable = repeatable || false
+        if argument
+          @argument = true
+          @argument_name = argument if argument.is_a?(String)
+        else
+          @argument = false
+        end
+        @integer = integer || false
+        @float = float || false
+        @optional = optional || false
+        @text = []
       end
-      # :nocov:
     end
   end
 end

data/lib/shellopts/grammar/parser.rb

@@ -0,0 +1,78 @@
+module ShellOpts
+  module Grammar
+    class Parser
+      def self.parse(program_name, exprs)
+        @commands = []
+        @commands << (@current = @cmd = Program.new(program_name))
+        @exprs = exprs.dup
+
+        while !@exprs.empty?
+          type, value = @exprs.shift
+          case type
+            when "OPT"
+              parse_option(value)
+            when "CMD"
+              parse_command(value)
+            when "ARG"
+              parse_argument(value)
+            when "TXT"
+              parse_text(value)
+          else
+            raise
+          end
+        end
+
+        @commands.each { |cmd| # Remove empty last-lines in comments and options
+          while cmd.text.last =~ /^\s*$/
+            cmd.text.pop
+          end
+          cmd.opts.each { |opt|
+            while opt.text.last =~ /^\s*$/
+              opt.text.pop
+            end
+          }
+        }
+
+        @commands
+      end
+
+      def self.parse_option_names(names)
+        names.split(",")
+      end
+
+      def self.parse_option(source)
+        OPTION_RE =~ source or raise CompilerError, "Illegal option: #{source}"
+        option_group = $1
+        argument = $4 || $2 && true
+        type = $3
+        optional = $5
+
+        option_group =~ /^(\+\+?|--?)(.*)/
+        repeatable = ($1 == '+' || $1 == '++' ? '+' : nil)
+        names = parse_option_names($2)
+
+        @cmd.opts << (@current = Option.new(
+            names, 
+            repeatable: repeatable, argument: argument, 
+            integer: (type == '#'), float: (type == '$'),
+            optional: optional))
+        !OPTION_RESERVED_WORDS.include?(@current.name) or 
+            raise CompilerError, "Reserved option name: #{@current.name}"
+      end
+
+      def self.parse_argument(source)
+        @cmd.args << source
+      end
+
+      def self.parse_command(value)
+        @commands << (@current = @cmd = Command.new(value))
+        !COMMAND_RESERVED_WORDS.include?(@current.name) or
+            raise CompilerError, "Reserved command name: #{@current.name}"
+      end
+
+      def self.parse_text(value)
+        @current.text << value
+      end
+    end
+  end
+end

data/lib/shellopts/version.rb

@@ -1,3 +1,3 @@
-module Shellopts
-  VERSION = "2.0.0.pre.7"
+module ShellOpts
+  VERSION = "2.0.0.pre.14"
 end

data/shellopts.gemspec

@@ -5,7 +5,7 @@ require "shellopts/version"
 
 Gem::Specification.new do |spec|
   spec.name          = "shellopts"
-  spec.version       = Shellopts::VERSION
+  spec.version       = ShellOpts::VERSION
   spec.authors       = ["Claus Rasmussen"]
   spec.email         = ["claus.l.rasmussen@gmail.com"]
 

metadata

@@ -1,14 +1,14 @@
 --- !ruby/object:Gem::Specification
 name: shellopts
 version: !ruby/object:Gem::Version
-  version: 2.0.0.pre.7
+  version: 2.0.0.pre.14
 platform: ruby
 authors:
 - Claus Rasmussen
 autorequire: 
 bindir: exe
 cert_chain: []
-date: 2020-10-06 00:00:00.000000000 Z
+date: 2021-02-10 00:00:00.000000000 Z
 dependencies:
 - !ruby/object:Gem::Dependency
   name: bundler
@@ -104,23 +104,23 @@ files:
 - bin/mkdoc
 - bin/setup
 - doc/stylesheet.css
-- lib/ext/array.rb
+- lib/ext/algorithm.rb
+- lib/ext/ruby_env.rb
 - lib/shellopts.rb
 - lib/shellopts/args.rb
 - lib/shellopts/ast/command.rb
-- lib/shellopts/ast/node.rb
+- lib/shellopts/ast/dump.rb
 - lib/shellopts/ast/option.rb
-- lib/shellopts/ast/program.rb
-- lib/shellopts/compiler.rb
-- lib/shellopts/generator.rb
+- lib/shellopts/ast/parser.rb
+- lib/shellopts/constants.rb
+- lib/shellopts/exceptions.rb
+- lib/shellopts/formatter.rb
+- lib/shellopts/grammar/analyzer.rb
 - lib/shellopts/grammar/command.rb
-- lib/shellopts/grammar/node.rb
+- lib/shellopts/grammar/dump.rb
+- lib/shellopts/grammar/lexer.rb
 - lib/shellopts/grammar/option.rb
-- lib/shellopts/grammar/program.rb
-- lib/shellopts/idr.rb
-- lib/shellopts/option_struct.rb
-- lib/shellopts/parser.rb
-- lib/shellopts/shellopts.rb
+- lib/shellopts/grammar/parser.rb
 - lib/shellopts/version.rb
 - shellopts.gemspec
 homepage: http://github.com/clrgit/shellopts

data/lib/ext/array.rb

@@ -1,9 +0,0 @@
-
-module XArray
-  refine Array do
-    # Find and return first duplicate. Return nil if not found
-    def find_dup
-      detect { |e| rindex(e) != index(e) }
-    end
-  end
-end

data/lib/shellopts/ast/node.rb

@@ -1,37 +0,0 @@
-module ShellOpts
-  module Ast
-    class Node
-      # The associated Grammar::Node object
-      attr_reader :grammar
-
-      # Key of node. Shorthand for grammar.key
-      def key() @grammar.key end
-
-      # Name of node (either program, command, or option name)
-      attr_reader :name
-
-      # Initialize an +Ast::Node+ object. +grammar+ is the corresponding
-      # grammar object (+Grammar::Node+) and +name+ is the name of the option
-      # or sub-command
-      def initialize(grammar, name)
-        @grammar, @name = grammar, name
-      end
-
-      # Return a name/value pair
-      def to_tuple
-        [name, values]
-      end
-
-      # Return either a value (option value), an array of values (command), or
-      # nil (option without a value). It must be defined in sub-classes of Ast::Node
-      def values() raise end
-
-      # :nocov:
-      def dump(&block)
-        puts key.inspect
-        indent { yield } if block_given?
-      end
-      # :nocov:
-    end
-  end
-end

data/lib/shellopts/ast/program.rb

@@ -1,14 +0,0 @@
-module ShellOpts
-  module Ast
-    class Program < Command
-      # Command line arguments. Initially nil but assigned by the parser. This array
-      # is the same as the argument array returned by Ast.parse
-      attr_accessor :arguments
-
-      def initialize(grammar) 
-        super(grammar, grammar.name) 
-        @arguments = nil
-      end
-    end
-  end
-end

data/lib/shellopts/compiler.rb

@@ -1,128 +0,0 @@
-require "ext/array.rb"
-
-require 'shellopts/grammar/node.rb'
-require 'shellopts/grammar/option.rb'
-require 'shellopts/grammar/command.rb'
-require 'shellopts/grammar/program.rb'
-
-module ShellOpts
-  module Grammar
-    # Compiles an option definition string and returns a Grammar::Program
-    # object. name is the name of the program and source is the 
-    # option definition string
-    def self.compile(name, source)
-      name.is_a?(String) or raise Compiler::Error, "Expected String argument, got #{name.class}"
-      source.is_a?(String) or raise Compiler::Error, "Expected String argument, got #{source.class}"
-      Compiler.new(name, source).call
-    end
-
-    # Service object for compiling an option definition string. Returns a 
-    # Grammar::Program object
-    #
-    # Compiler implements a recursive descend algorithm to compile the option
-    # string. The algorithm uses state variables and is embedded in a
-    # Grammar::Compiler service object 
-    class Compiler
-      class Error < RuntimeError; end
-
-      # Initialize a Compiler object. source is the option definition string
-      def initialize(name, source)
-        @name, @tokens = name, source.split(/\s+/).reject(&:empty?)
-
-        # @subcommands_by_path is an hash from subcommand-path to Command or Program
-        # object. The top level Program object has nil as its path.
-        # @subcommands_by_path is used to check for uniqueness of subcommands and to
-        # link sub-subcommands to their parents
-        @subcommands_by_path = {}
-      end
-
-      def call
-        compile_program
-      end
-
-    private
-      using XArray # For Array#find_dup
-
-      # Returns the current token
-      def curr_token() @tokens.first end
-
-      # Returns the current token and advance to the next token
-      def next_token() @tokens.shift end
-
-      def compile_program
-        program = @subcommands_by_path[nil] = Grammar::Program.new(@name, compile_options)
-        while curr_token && curr_token != "--"
-          compile_subcommand
-        end
-        program.args.concat(@tokens[1..-1]) if curr_token
-        program
-      end
-
-      def compile_subcommand
-        path = curr_token[0..-2]
-        ident_list = compile_ident_list(path, ".")
-        parent_path = ident_list.size > 1 ? ident_list[0..-2].join(".") : nil
-        name = ident_list[-1]
-
-        parent = @subcommands_by_path[parent_path] or
-            raise Compiler::Error, "No such subcommand: #{parent_path.inspect}"
-        !@subcommands_by_path.key?(path) or raise Compiler::Error, "Duplicate subcommand: #{path.inspect}"
-        next_token
-        @subcommands_by_path[path] = Grammar::Command.new(parent, name, compile_options)
-      end
-
-      def compile_options
-        option_list = []
-        while curr_token && curr_token != "--" && !curr_token.end_with?("!")
-          option_list << compile_option
-        end
-        dup = option_list.map(&:names).flatten.find_dup and 
-            raise Compiler::Error, "Duplicate option name: #{dup.inspect}"
-        option_list
-      end
-
-      def compile_option
-        # Match string and build flags
-        flags = []
-        curr_token =~ /^(\+)?(.+?)(?:(=)(\$|\#)?(.*?)(\?)?)?$/
-        flags << :repeated if $1 == "+"
-        names = $2
-        flags << :argument if $3 == "="
-        flags << :integer if $4 == "#"
-        flags << :float if $4 == "$"
-        label = $5 == "" ? nil : $5
-        flags << :optional if $6 == "?"
-
-        # Build names
-        short_names = []
-        long_names = []
-        ident_list = compile_ident_list(names, ",")
-        (dup = ident_list.find_dup).nil? or 
-            raise Compiler::Error, "Duplicate identifier #{dup.inspect} in #{curr_token.inspect}"
-        ident_list.each { |ident|
-          if ident.size == 1
-            short_names << "-#{ident}"
-          else
-            long_names << "--#{ident}"
-          end
-        }
-
-        next_token
-        Grammar::Option.new(short_names, long_names, flags, label)
-      end
-
-      # Compile list of option names or a subcommand path
-      def compile_ident_list(ident_list_str, sep)
-        ident_list_str.split(sep, -1).map { |str| 
-          !str.empty? or 
-              raise Compiler::Error, "Empty identifier in #{curr_token.inspect}"
-          !str.start_with?("-") or 
-              raise Compiler::Error, "Identifier can't start with '-' in #{curr_token.inspect}"
-          str !~ /([^\w\d#{sep}-])/ or 
-              raise Compiler::Error, "Illegal character #{$1.inspect} in #{curr_token.inspect}"
-          str
-        }
-      end
-    end
-  end
-end