shellopts 2.0.0.pre.14 → 2.0.2

data/lib/shellopts/grammar/analyzer.rb

@@ -1,76 +0,0 @@
-
-module ShellOpts
-  module Grammar
-    class Analyzer
-      def self.analyze(commands)
-        @program = commands.shift
-        @commands = commands
-        build_options
-        link_up
-        @program
-      end
-
-    private
-      def self.error(mesg, command)
-        mesg += " in #{command.path}" if !command.program?
-        raise CompileError, mesg
-      end
-
-      def self.program() @program end
-      def self.commands() @commands end
-
-      # Initialize Command#options
-      def self.build_options
-        ([program] + commands).each { |command|
-          command.opts.each { |opt|
-            opt.names.each { |name|
-              !command.options.key?(name) or 
-                  error "Duplicate option name '#{name}'", command
-              command.options[name] = opt
-            }
-
-            !command.options.key?(opt.ident) or 
-                error "Duplicate option identifier '#{opt.ident}'", command
-            command.options[opt.ident] = opt
-          }
-        }
-      end
-
-      # Initialize Command#commands
-      def self.link_up
-        # Hash from path to command
-        cmds = { "" => program }
-
-        # Add placeholders for actual commands and virtual commands for empty parent commands
-        commands.sort.each { |cmd|
-          # Place holder for actual command
-          cmds[cmd.path] = nil
-
-          # Add parent virtual commands 
-          curr = cmd
-          while !cmds.key?(curr.parent_path)
-            curr = cmds[curr.parent_path] = VirtualCommand.new(curr.parent_path)
-          end
-        }
-
-        # Add actual commands
-        commands.sort.each { |cmd|
-          !cmds[cmd.path] or 
-              error "Duplicate command name '#{cmd.name}'", cmds[cmd.parent_path]
-          cmds[cmd.path] = cmd
-        }
-
-        # Link up
-        cmds.values.each { |cmd|
-          next if cmd == program
-          cmd.instance_variable_set(:@parent, cmds[cmd.parent_path])
-          cmd.parent.commands[cmd.name] = cmd
-          cmd.parent.cmds << cmd
-          !cmd.parent.commands.key?(cmd.ident) or 
-              error "Duplicate command identifier '#{cmd.ident}'", cmd.parent
-          cmd.parent.commands[cmd.ident] = cmd
-        }
-      end
-    end
-  end
-end

data/lib/shellopts/grammar/command.rb

@@ -1,87 +0,0 @@
-module ShellOpts
-  module Grammar
-    # TODO: Command aliases: list.something!,list.somethingelse!
-    class Command
-      # Parent command. nil for the program-level Command object. Initialized
-      # by the analyzer
-      attr_reader :parent
-
-      # Name of command. nil for the program-level Command object
-      attr_reader :name
-
-      # Ident of command. nil for the program-level Command object
-      attr_reader :ident
-
-      # Path of command. The empty string for the program-level Command object
-      attr_reader :path
-
-      # Path of parent command. nil for the program-level Command object. This
-      # is the same as #parent&.path but is available before #parent is
-      # intialized. It is used to build the command hierarchy in the analyzer
-      attr_reader :parent_path
-
-      # List of comments. Initialized by the parser
-      attr_reader :text 
-
-      # List of options. Initialized by the parser
-      attr_reader :opts 
-
-      # List of sub-commands. Initialized by the parser
-      attr_reader :cmds 
-
-      # List of arguments. Initialized by the parser
-      attr_reader :args
-
-      # Hash from name/identifier to option. Note that each option has at least
-      # two entries in the hash: One by name and one by identifier. Option
-      # aliases are also keys in the hash. Initialized by the analyzer
-      attr_reader :options 
-
-      # Hash from name to sub-command. Note that each command has two entries in
-      # the hash: One by name and one by identifier. Initialized by the analyzer
-      attr_reader :commands 
-
-      def initialize(path, virtual: false)
-        if path == ""
-          @path = path
-        else
-          @path = path.sub(/!$/, "")
-          components = @path.split(".")
-          @name = components.pop
-          @parent_path = components.join(".")
-          @ident = @name.gsub(/-/, "_").to_sym
-        end
-        @virtual = virtual
-        @text = []
-        @opts = []
-        @cmds = []
-        @args = []
-
-        @options = {}
-        @commands = {}
-      end
-
-      # True if this is the program-level command
-      def program?() @path == "" end
-
-      # True if this is a virtual command that cannot be called without a
-      # sub-command
-      def virtual?() @virtual end
-
-      def <=>(other)
-        path <=> other.path
-      end
-    end
-
-    class Program < Command
-      def initialize(name) 
-        super("") 
-        @name = name
-      end
-    end
-
-    class VirtualCommand < Command
-      def initialize(path) super(path, virtual: true) end
-    end
-  end
-end

data/lib/shellopts/grammar/dump.rb

@@ -1,56 +0,0 @@
-module ShellOpts
-  module Grammar
-    class Command
-      def dump
-        print (path ? "#{path}!" : 'nil')
-        print " (virtual)" if virtual?
-        print " [PROGRAM]" if program?
-        puts
-        indent {
-          puts "name: #{name.inspect}"
-          puts "ident: #{ident.inspect}"
-          puts "path: #{path.inspect}"
-          puts "parent_path: #{parent_path.inspect}"
-          if !text.empty?
-            puts "text"
-            indent { text.each { |txt| puts txt } }
-          end
-          if !opts.empty?
-            puts "opts"
-            indent { opts.each(&:dump) }
-          end
-          if !cmds.empty?
-            puts "cmds (#{cmds.size})"
-            indent { cmds.each(&:dump) }
-          end
-          if !args.empty?
-            puts "args"
-            indent { args.each { |arg| puts arg } }
-          end
-        }
-      end
-    end
-
-    class Option
-      def dump
-        puts name
-        indent {
-          if !text.empty?
-            puts "text"
-            indent { text.each { |txt| puts txt } }
-          end
-          puts "ident: #{ident.inspect}"
-          puts "names: #{names.join(', ')}"
-          puts "repeatable: #{repeatable?}"
-          puts "argument: #{argument?}"
-          if argument?
-            puts "argument_name: #{argument_name}" if argument_name
-            puts "integer: #{integer?}"
-            puts "float: #{float?}"
-            puts "optional: #{optional?}"
-          end
-        }
-      end
-    end
-  end
-end

data/lib/shellopts/grammar/lexer.rb

@@ -1,56 +0,0 @@
-module ShellOpts
-  module Grammar
-    class Lexer
-      def self.lex(source)
-        lines = source.split("\n").map(&:strip)
-
-        # Skip initial blank lines
-        lines = lines.drop_while { |line| line == "" }
-
-        # Split lines into command, option, argument, or text
-        res = []
-        while line = lines.shift
-          if line =~ SCAN_RE
-            # Collect following comments
-            txts = []
-            while lines.first && lines.first !~ SCAN_RE
-              txts << lines.shift
-            end
-
-            words = line.split(/\s+/)
-            while word = words.shift
-              type = 
-                  case word
-                    when OPTION_RE
-                      "OPT"
-                    when COMMAND_PATH_RE
-                      "CMD"
-                    when ARGUMENT_EXPR_RE
-                      args = [word]
-                      # Scan arguments
-                      while words.first =~ ARGUMENT_EXPR_RE
-                        args << words.shift
-                      end
-                      word = args.join(" ")
-                      "ARG"
-                    when /^[a-z0-9]/
-                      raise CompileError, "Illegal argument: #{word} (should be uppercase)"
-                    else
-                      raise CompileError, "Illegal syntax: #{line}"
-                  end
-              res << [type, word]
-              txts.each { |txt| res << ["TXT", txt] } # Add comments after first command or option
-              txts = []
-            end
-          elsif line =~ /^-|\+/
-            raise CompileError, "Illegal short option name: #{line}"
-          else
-            res << ["TXT", line]
-          end
-        end
-        res
-      end
-    end
-  end
-end
-

data/lib/shellopts/grammar/option.rb

@@ -1,55 +0,0 @@
-module ShellOpts
-  module Grammar
-    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
-    end
-  end
-end

data/lib/shellopts/grammar/parser.rb

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