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

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.13"
+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.13
+  version: 2.0.0.pre.14
 platform: ruby
 authors:
 - Claus Rasmussen
 autorequire: 
 bindir: exe
 cert_chain: []
-date: 2020-11-25 00:00:00.000000000 Z
+date: 2021-02-10 00:00:00.000000000 Z
 dependencies:
 - !ruby/object:Gem::Dependency
   name: bundler
@@ -104,25 +104,23 @@ files:
 - bin/mkdoc
 - bin/setup
 - doc/stylesheet.css
-- lib/ext/array.rb
-- lib/main.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/main.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/main.rb

@@ -1 +0,0 @@
-hej

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

data/lib/shellopts/generator.rb

@@ -1,15 +0,0 @@
-
-require 'shellopts/idr.rb'
-
-module ShellOpts
-  module Idr
-    # Generates an Idr::Program from a ShellOpts object
-    def self.generate(shellopts)
-      Idr::Program.new(shellopts)
-    end
-  end
-end
-
-
-
-

data/lib/shellopts/grammar/node.rb

@@ -1,33 +0,0 @@
-module ShellOpts
-  module Grammar
-    # Root class for Grammar objects
-    #
-    # Node objects are created by ShellOpts::Grammar.compile that returns a
-    # Program object that in turn contains other node objects in a hierarchical
-    # structure that reflects the grammar of the program. Only
-    # ShellOpts::Grammar.compile should create node objects
-    class Node
-      # Key (Symbol) of node. Unique within the enclosing command
-      attr_reader :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 { 
-          puts "name: #{name.inspect}"
-          yield if block_given?
-        }
-      end
-      # :nocov:
-    end
-  end
-end

data/lib/shellopts/grammar/program.rb

@@ -1,65 +0,0 @@
-module ShellOpts
-  module Grammar
-    # Program is the root object of the grammar
-    class Program < Command
-      # Array of non-option litteral arguments (ie. what comes after the double dash ('+--+') in
-      # the usage definition). Initially empty but filled out during compilation
-      attr_reader :args
-
-      # Initialize a top-level Program object
-      def initialize(name, option_list)
-        super(nil, name, option_list)
-        @args = []
-      end
-
-      # Usage string to be used in error messages. The string is kept short by
-      # only listing the shortest option (if there is more than one)
-      def usage
-        (
-          render_options(option_list) + 
-          subcommand_list.map { |cmd| render_subcommand(cmd) } + 
-          args
-        ).flatten.join(" ")
-      end
-
-      # :nocov:
-      def dump(&block)
-        super { 
-          puts "args: #{args.inspect}" 
-          puts "usage: #{usage.inspect}"
-        }
-      end
-      # :nocov:
-
-    private
-      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)
-        options.map { |opt|
-          s = opt.names.first
-          if opt.argument?
-            arg_string = 
-                if opt.label
-                  opt.label
-                elsif opt.integer?
-                  "INT"
-                elsif opt.float?
-                  "FLOAT"
-                else
-                  "ARG"
-                end
-            if opt.optional?
-              s += "[=#{arg_string}]"
-            else
-              s += "=#{arg_string}"
-            end
-          end
-          s
-        }
-      end
-    end
-  end
-end