pablo 1.0.3

data/lib/pablo/arguments.rb

@@ -0,0 +1,76 @@
+###### DON'T PANIC License 1.1 ###########
+#
+# Don't panic, this piece of software is
+# free, i.e. you can do with it whatever
+# you like, including, but not limited to:
+# 
+#   * using it
+#   * copying it
+#   * (re)distributing it
+#   * burning/burying/shredding it
+#   * eating it
+#   * using it to obtain world domination
+#   * and ignoring it
+# 
+# Under the sole condition that you
+# 
+#   * CONSIDER buying the author a strong
+#     brownian motion producer, say a nice
+#     hot cup of tea, should you ever meet
+#     him in person.
+#
+##########################################
+
+class Pablo
+    #
+    # Safely encapsules the arguments and provides means to
+    # manipulate them
+    class Arguments
+
+        # undef all instance methods so we can use this as
+        # a proxy to the underlying Array
+        instance_methods.each { |m| undef_method m unless m =~ /^__/ }
+
+        def method_missing sym, *args, &block
+            @slices[-1][:arr].send(sym, *args, &block)
+        end
+
+        def initialize arr
+            @slices = [{:idx => 0, :arr => arr}]
+        end
+
+        def consume idx
+            @slices[-1][:arr].delete_at idx
+        end
+
+        def consumed?
+            @slices[-1][:arr].empty?
+        end
+
+        def consume_all
+            @slices[-1][:arr].clear
+        end
+
+        #
+        # Constrain arguments on the subset +idx..-1+.
+        def slice idx
+            @slices << {
+                :idx => idx,
+                :arr => @slices[-1][:arr][idx..-1]
+            }
+        end
+
+        #
+        # Remove arguments constrain and reconcile arguments
+        # with slice.
+        def unslice
+            raise "cannot unslice fully unsliced Arguments" unless @slices.length > 1
+            idx, arr = @slices[-1][:idx], @slices[-1][:arr]
+            @slices[-2][:arr][idx..-1] = arr
+            @slices.delete_at(-1)
+        end
+
+    end
+
+end
+

data/lib/pablo/color.rb

@@ -0,0 +1,57 @@
+###### DON'T PANIC License 1.1 ###########
+#
+# Don't panic, this piece of software is
+# free, i.e. you can do with it whatever
+# you like, including, but not limited to:
+# 
+#   * using it
+#   * copying it
+#   * (re)distributing it
+#   * burning/burying/shredding it
+#   * eating it
+#   * using it to obtain world domination
+#   * and ignoring it
+# 
+# Under the sole condition that you
+# 
+#   * CONSIDER buying the author a strong
+#     brownian motion producer, say a nice
+#     hot cup of tea, should you ever meet
+#     him in person.
+#
+##########################################
+
+class Pablo
+
+    #
+    # Runs the given +block+, whenever something needs to be given color.
+    # The block will be given the following arguments:
+    # * The string to colorize
+    # * A symbol indicating the type of the String. The color should be
+    #   guessed from that. Can be any of:
+    #   * :h1 - First class heading
+    #   * :h2 - Second class heading
+    #   * :usage - Usage information
+    #   * :em - Highlighted word
+    def colorizing &block
+        raise "colorize expects a block" unless block_given?
+        @colorize = block
+    end
+
+    #
+    # Colorize the given +string+ of the given +type+.
+    # See Pablo#colorize for valid values of +type+.
+    # If no colorization function is given, the +string+ is returned
+    # uncolored.
+    def colorize string, type
+        if type == :text
+            string.gsub(/\$([^$]+)\$/ )do |match|
+                colorize(match[1..-2], :em)
+            end
+        else
+            @colorize.nil? ? string : (@colorize.call(string, type))
+        end
+    end
+
+end
+

data/lib/pablo/command.rb

@@ -0,0 +1,71 @@
+###### DON'T PANIC License 1.1 ###########
+#
+# Don't panic, this piece of software is
+# free, i.e. you can do with it whatever
+# you like, including, but not limited to:
+# 
+#   * using it
+#   * copying it
+#   * (re)distributing it
+#   * burning/burying/shredding it
+#   * eating it
+#   * using it to obtain world domination
+#   * and ignoring it
+# 
+# Under the sole condition that you
+# 
+#   * CONSIDER buying the author a strong
+#     brownian motion producer, say a nice
+#     hot cup of tea, should you ever meet
+#     him in person.
+#
+##########################################
+
+class Pablo
+
+    class Command < Pablo::Parser
+
+        def initialize *args, &block
+            super(*args, &block)
+            @opts[:consume_all] = @pablo.consume_all? if @opts[:consume_all].nil?
+        end
+
+        def parse args
+            name = nil
+            idx = args.zip((0...args.length).to_a).find_index { |(a,i)|
+                verifies?(a,i) and (name = matches?(a))
+            }
+
+            unless idx.nil?
+                args.consume idx
+                args.slice idx
+
+                @pablo.commands[name] = true
+
+                unless returning(consume?(name, args)) { run?(args) }
+                    args.consume_all if @toplevel and @opts[:consume_all]
+                end
+
+                args.unslice
+                true
+            else
+                false
+            end
+        end
+
+        #
+        # Format a command's names to be displayed to the user.
+        def names_to_user
+            @names.collect(&:to_s).join('|')
+        end
+
+        #
+        # Format a command's names to be used in a Regexp.
+        def names_to_rex
+            Regexp.new(names_to_user)
+        end
+
+    end
+
+end
+

data/lib/pablo/errors.rb

@@ -0,0 +1,68 @@
+###### DON'T PANIC License 1.1 ###########
+#
+# Don't panic, this piece of software is
+# free, i.e. you can do with it whatever
+# you like, including, but not limited to:
+# 
+#   * using it
+#   * copying it
+#   * (re)distributing it
+#   * burning/burying/shredding it
+#   * eating it
+#   * using it to obtain world domination
+#   * and ignoring it
+# 
+# Under the sole condition that you
+# 
+#   * CONSIDER buying the author a strong
+#     brownian motion producer, say a nice
+#     hot cup of tea, should you ever meet
+#     him in person.
+#
+##########################################
+
+class Pablo
+
+    class MissingArgumentError < RuntimeError
+        def initialize name, arg = nil
+            @name, @arg = name, arg
+        end
+
+        def to_s
+            @arg ?
+                "Missing argument '#{@arg}' for '#{@name}'." :
+                "Missing argument for '#{@name}'."
+        end
+    end
+
+    class WrongArgumentError < RuntimeError
+        def initialize name, arg = nil, type = nil
+            @name, @arg, @type = name, arg, type
+        end
+
+        def to_s
+            (@arg ?
+                "Wrong argument '#{@arg}' for '#{@name}'." :
+                "Wrong argument for '#{@name}'.") +
+            (@type ?
+                " Expected #{@type}." :
+                '')
+        end
+    end
+
+    #
+    # Displays a message about a missing argument
+    # and exits parsing.
+    def missing_argument *args
+        raise MissingArgumentError.new @cur.last_match, *args
+    end
+
+    #
+    # Displays a message about a wrong argument (format)
+    # and exits parsing.
+    def wrong_argument *args
+        raise WrongArgumentError.new @cur.last_match, *args
+    end
+
+end
+

data/lib/pablo/expansion.rb

@@ -0,0 +1,58 @@
+###### DON'T PANIC License 1.1 ###########
+#
+# Don't panic, this piece of software is
+# free, i.e. you can do with it whatever
+# you like, including, but not limited to:
+# 
+#   * using it
+#   * copying it
+#   * (re)distributing it
+#   * burning/burying/shredding it
+#   * eating it
+#   * using it to obtain world domination
+#   * and ignoring it
+# 
+# Under the sole condition that you
+# 
+#   * CONSIDER buying the author a strong
+#     brownian motion producer, say a nice
+#     hot cup of tea, should you ever meet
+#     him in person.
+#
+##########################################
+
+class Pablo
+
+    #
+    # Whether or not the given +type+ is subject to expansion.
+    def expands? type
+        @opts[:expand] == true or @opts[:expand] == type
+    end
+
+    #
+    # Expands the given +arg+ument if possible.
+    def expand! arg
+        arr = @expand.find_all { |e| e.start_with?(arg) }
+
+        case arr.length
+        when 1 then arr[0]
+        when 0 then arg
+        else
+            @ambiguity.call(arg, arr) unless @ambiguity.nil?
+            arg
+        end
+    end
+
+    #
+    # The block given to this method will be called each time an
+    # argument could not be expanded because there were multiple
+    # parsers that matched it.
+    # The block will be passed the argument and an Array containing
+    # the matching parser names as parameters.
+    def ambiguity &block
+        raise "Pablo#ambiguity needs a block to do something sensible" unless block_given?
+        @ambiguity = block
+    end
+
+end
+

data/lib/pablo/help.rb

@@ -0,0 +1,191 @@
+###### DON'T PANIC License 1.1 ###########
+#
+# Don't panic, this piece of software is
+# free, i.e. you can do with it whatever
+# you like, including, but not limited to:
+# 
+#   * using it
+#   * copying it
+#   * (re)distributing it
+#   * burning/burying/shredding it
+#   * eating it
+#   * using it to obtain world domination
+#   * and ignoring it
+# 
+# Under the sole condition that you
+# 
+#   * CONSIDER buying the author a strong
+#     brownian motion producer, say a nice
+#     hot cup of tea, should you ever meet
+#     him in person.
+#
+##########################################
+
+class Pablo
+
+    #
+    # The class that handles standard help displaying.
+    class HelpCommand < Pablo::Command
+        private
+
+        def run? args
+            super(args)
+            args.empty? ? @pablo.help() : @pablo.help(args[0])
+            throw :abort
+        end
+    end
+
+    #
+    # The class that handles standard version displaying.
+    class VersionCommand < Pablo::Command
+        private
+
+        def run? args
+            super(args)
+            @pablo.version()
+            throw :abort
+        end
+    end
+
+    #
+    # The class that handles standard License displaying.
+    class LicenseCommand < Pablo::Command
+        private
+
+        def run? args
+            super(args)
+            @pablo.license()
+            throw :abort
+        end
+    end
+
+    #
+    # Creates the standard license command.
+    def license_command options = {}, &block
+        desc('Shows the license of this program.') unless @pending[:desc]
+        longdesc("Displays information about the license of this program.") unless @pending[:longdesc]
+        exec(Pablo::LicenseCommand, :license, options, &block)
+    end
+
+    #
+    # Creates the standard version command.
+    def version_command options = {}, &block
+        desc('Shows the version of this program.') unless @pending[:desc]
+        longdesc("Displays information about the version of this program.") unless @pending[:longdesc]
+        exec(Pablo::VersionCommand, :version, options, &block)
+    end
+
+    #
+    # Creates the standard help command.
+    def help_command options = {}, &block
+        desc('Displays this message.') unless @pending[:desc]
+        longdesc("Shows a simple help message for this program.\n" +
+            "If a command is given as well, a more detailed message about that\n" +
+            "particular command is shown (such as this one).") unless @pending[:longdesc]
+        usage('[<command>]') unless @pending[:usage]
+        exec(Pablo::HelpCommand, :help, options, &block)
+    end
+
+    #
+    # Creates standard ambiguity output.
+    def ambiguity_command
+        ambiguity do |arg,arr|
+            $stdout.puts "Ambiguous argument '#{arg}'. Could be any of:"
+
+            arr.each do |name|
+                $stdout.puts "  * #{name}"
+            end
+
+            throw :abort
+        end
+    end
+
+    #
+    # Print the help screen.
+    # * command == nil: program help
+    # * else:           specific command's help
+    def help command = nil
+        if command.nil?
+            put_header
+
+            $stdout.puts "\n   #{colorize(@opts[:program], :em)} #{colorize(@opts[:usage], :usage)}\n" unless @opts[:usage].nil?
+            $stdout.puts "\n#{indent colorize(@opts[:longdesc], :text), 3}" unless @opts[:longdesc].nil?
+
+            cmdlen = @registered.collect(&:names_to_user).max_by(&:length).length
+
+            [:commands, :options].each do |type|
+                parsers = @registered.find_all { |p| p.klass_to_sym == type }
+
+                unless parsers.empty?
+                    $stdout.puts
+                    $stdout.puts ' ' + colorize("#{type.to_s.capitalize}:", :h2)
+
+                    parsers.each { |p|
+                        p.desc ?
+                            $stdout.puts("   #{colorize(p.names_to_user.ljust(cmdlen), :em)}  :  #{colorize(p.desc, :text)}") :
+                            $stdout.puts('   ' + colorize(p.names_to_user.ljust(cmdlen), :em))
+                    }
+                end
+            end
+
+            tokens = @registered.find_all { |p| p.is_a? Pablo::Token and not p.desc.nil? }
+            unless tokens.empty?
+                $stdout.puts
+                $stdout.puts ' ' + colorize("Tokens:", :h2)
+
+                tokens.each { |t|
+                    $stdout.puts "   #{colorize(t.names_to_user.ljust(cmdlen), :em)}  :  #{t.desc}"
+                }
+            end
+        else
+            command = expand!(command)
+            found = @registered.find do |item|
+                if not item.names_to_rex.nil? and item.names_to_rex =~ command
+                    put_header
+
+                    $stdout.print "\n   " + colorize(item.names_to_user, :em)
+                    $stdout.print ' ' + colorize(item.usage, :usage) unless item.usage.nil?
+                    $stdout.puts "\n\n"
+                    $stdout.puts indent(colorize(item.longdesc, :text), 1) unless item.longdesc.nil?
+                    true
+                else false
+                end
+            end
+
+            if found.nil?
+                $stdout.puts "Sorry, but I don't know '#{colorize(command, :em)}'."
+                $stdout.puts "Try running '#{colorize('help', :em)}' without parameters to get a list of all the commands, options etc."
+            end
+        end
+    end
+
+    #
+    # Print version screen and stop processing.
+    def version
+        $stdout.puts colorize("#{@opts[:program]} #{@opts[:version]}", :h1)
+        $stdout.puts @opts[:capabilities].join(' ') unless @opts[:capabilities].nil?
+    end
+
+    #
+    # Print license and stop processing. Nothing else.
+    def license
+        if File.exist? @opts[:license].to_s
+            open(@opts[:license]) { |f| $stdout.puts f.read }
+        else
+            $stdout.puts colorize(@opts[:license], :text)
+        end
+    end
+
+    #
+    # Prints the standard header for most Pablo output.
+    def put_header
+        unless @opts[:program].nil?
+            str = "#{@opts[:program]}"
+            str << " #{@opts[:version]}" unless @opts[:version].nil?
+            str << " - #{@opts[:desc]}" unless @opts[:desc].nil?
+            $stdout.puts ' ' + colorize(str, :h1)
+        end
+    end
+
+end
+