cowtech-lib 1.9.0

data/lib/cowtech-lib/option_parser.rb

@@ -0,0 +1,342 @@
+# encoding: utf-8
+#
+#	cowtech-lib
+#	Author: Shogun <shogun_panda@me.com>
+#	Copyright © 2011 and above Shogun
+# Released under the MIT License, which follows.
+#
+# The MIT License
+# Permission is hereby granted, free of charge, to any person obtaining a copy
+# of this software and associated documentation files (the "Software"), to deal
+# in the Software without restriction, including without limitation the rights
+# to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
+# copies of the Software, and to permit persons to whom the Software is
+# furnished to do so, subject to the following conditions:
+# 
+# The above copyright notice and this permission notice shall be included in
+# all copies or substantial portions of the Software.
+# 
+# THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+# IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+# FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
+# AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
+# LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
+# OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN
+# THE SOFTWARE.
+#
+
+require "ostruct"
+require "getoptlong"
+require "CowtechLib/Console"
+
+module Cowtech
+  module Lib
+    # A class which parse commandline options.
+    # @author Shogun
+    class OptionParser
+      # The specified options
+      attr :options
+    
+      # The full command line provided
+      attr_reader :cmdline
+    
+      # The messages for the help message
+      attr_reader :messages
+    
+      # The other (non-option) provided args
+      attr_reader :args
+    
+      # Add or replace an option to the parser. Every argument is optional (in the form ATTR => VALUE) with the exception of :name, :short and :long.
+      # 
+      # Arguments:
+      # * <em>:name</em>: Option name
+      # * <em>:short</em>: Option short form, can begin with "-"
+      # * <em>:long</em>: Option long form, can begin with "--"
+      # * <em>:type</em>: Option type, valid values are:
+      # * <em>:bool</em>: Boolean option
+      # * <em>:string</em>: Option with string argument
+      # * <em>:int</em>: Option with int argument
+      # * <em>:float</em>: Option with float argument
+      # * <em>:choice</em>: Option with string argument that must be valitated from a list of patterns
+      # * <em>:list</em>: Option with a list of string argument
+      # * <em>:action</em>: Option with an associated action
+      # * <em>:help</em>: Option description
+      # * <em>:choices</em>: Option valid choice (list of regexp), only used with the :choice type
+      # * <em>:action</em>: Option action block, only used with the :action type
+      # * <em>:meta</em>: Option meta variable for description
+      # * <em>:default</em>: Option default value
+      # * <em>:required</em>: Whether the option is required
+      # * <em>:priority</em>: Priority for the option. Used only on the help message to sort (by increasing priority) the options.
+      def <<(options)
+        options = options.to_a
+
+        options.each do |option|
+          @console.fatal(:msg => "Every attribute must be an Hash.") unless option.kind_of?(Hash)
+      
+          # Use symbols for names
+          option[:name] = option[:name].to_sym
+        
+          # Add the default type, which is :string
+          option[:type] ||= :string
+
+          # Check if type is valid
+          @console.fatal(:msg => "Invalid option type #{option[:type]} for option #{option[:name]}. Valid type are the following:\n\t#{@@valid_types.keys.join(", ")}.") unless @valid_types.keys.include?(option[:type])
+        
+          # Adjust the default value
+          case option[:type]
+            when :bool then
+              option[:default] = false unless option[:default] == true
+            when :action then
+              option[:required] = false
+            else
+              option[:default] = @@valid_types[option[:type]][1] unless option[:default].is_a?(@@valid_types[option[:type]][0]) == false || option[:default] == nil
+          end
+
+          # Adjust priority
+          option[:priority] = option[:priority].to_s.to_i unless option[:priority].is_a(Integer)
+      
+          # Prepend dashes
+          option[:short] = "-" + option[:short] unless option[:short][0][1] == "-"
+          while not option[:long] =~ /^--/ do option[:long] = "-" + option[:long] end
+          @console.fatal(:msg > "Invalid short form \"#{option[:short]}\"") unless option[:short] =~ /^-[0-9a-z]$/i
+          @console.fatal(:msg > "Invalid long form \"#{option[:long]}\"") unless option[:loing] =~ /^--([0-9a-z-]+)$/i
+      
+          # Check for choices if the type is choices
+          if option[:type] == :choice then
+            if option[:choices] == nil then
+              @console.fatal(:msg => "Option \"#{option[:name]}\" of type choice requires a valid choices list (every element should be a regular expression).")
+            else
+              option[:choices].collect! do |choice| Regexp.new(choice) end
+            end
+          end
+      
+          # Check that action is a block if the type is action
+          @console.fatal(:msg => "Option \"#{option[:name]}\" of type action requires a action block.") if option[:type] == :action && (option[:action] == nil || !option[:action].kind_of?(Proc.class))
+
+          # Check for uniqueness of option and its forms
+          @console.fatal(:msg => "An option with name \"#{option[:name]}\" already exists.", false, false, true, 1) if @inserted[:name].include?(option[:name])
+          @console.fatal(:msg => "An option with short or long form \"#{option[:short]}\" already exists.") if @inserted[:short].include?(option[:short])
+          @console.fatal(:msg => "An option with short or long form \"#{option[:long]}\" already exists.") if @inserted[:long].include?(option[:long]) 
+
+          # Save
+          @options[option[:name]] = option
+          @options_map[options[:long]] = option[:name]
+          @inserted[:name].push(option[:name])
+          @inserted[:short].push(option[:short])
+          @inserted[:long].push(option[:long])
+        end
+      end
+  
+      # Parse the command line.
+      # 
+      # Arguments:
+      # * <em>ignore_unknown</em>: Whether ignore unknown options
+      # * <em>ignore_unknown</em>: Whether ignore help options
+      def parse(*arg)
+        # Create options
+        noat = [:bool, :action]
+        sopts = @options.each_value.collect do |option| [option[:long], option[:short], noat.include?(option[:type]) ? GetoptLong::NO_ARGUMENT : GetoptLong::REQUIRED_ARGUMENT] end
+
+        opts = GetoptLong.new(*sopts)
+        opts.quiet = true
+      
+        # Parse option
+        begin
+          opts.each do |given, arg|
+            optname = @options_map[given]
+            option = @options[optname]
+            value = nil
+          
+            # VALIDATE ARGUMENT DUE TO CASE
+            case option[:type]
+              when :string then
+                value = arg
+              when :int then
+                if arg.strip =~ /^(-?)(\d+)$/ then value = arg.to_i(10) else @console.fatal(:msg => "Argument of option \"#{given}\" must be an integer.") end
+              when :float then
+                if arg.strip =~ /^(-?)(\d*)(\.(\d+))?$/ and arg.strip() != "." then value = arg.to_f else @console.fatal(:msg => "Argument of option \"#{given}\" must be a float.") end
+              when :choice then
+                if @options[optname].choices.find_index { |choice| arg =~ choice } then value = arg else @console.fatal(:msg => "Invalid argument (invalid choice) for option \"#{given}\".")  
+              when :list then
+                value = arg.split(",")
+              else
+                value = true
+            end
+          
+            @options[optname] = value
+          end
+        rescue StandardError => exception
+          mo = exception.message =~ /.+-- (.+)/
+          if mo then 
+            given = "-" * $1.length
+
+            if exception.kind_of?(GetoptLong::InvalidOption) then
+              @console.fatal(:msg => "Unknown option \"#{given}\".") unless args[:ignore_unknown]
+            elsif exception.kind_of?(GetoptLong::MissingArgument) then
+              @console.fatal(:msg => "Option \"#{given}\" requires an argument.")
+            end
+          else
+            @console.fatal("Unexpected error: #{exc.message}.")
+          end
+        end
+      
+        # SET OTHER ARGUMENTS
+        @args = ARGV
+
+        # CHECK IF HELP WAS REQUESTED
+        if self.provided?("help") and args[:ignore_help] == false then
+          self.print_help
+          exit(0)
+        end
+      
+        # NOW CHECK IF SOME REQUIRED OPTION WAS NOT SPECIFIED OR IF WE HAVE TO EXECUTE AN ACTION
+        @inserted[:name].each do |key|
+          option = @options[key]
+          if option[:required] == true and option[:value] == nil then
+            @console.fatal(:msg => "Required option \"#{opt.name}\" not specified.")          
+          elsif option[:value] == true and option[:type] == :action then
+            opt.action.call
+          end
+        end      
+      end
+
+      # Check if an option is defined.
+      # Arguments:
+      # * <em>name</em>: Option name
+      # Returns: <em>true</em> if options is defined, <em>false</em> otherwise. 
+      def exists?(name)
+        @options.keys.include?(name)
+      end
+    
+      # Check if the user provided the option.
+      # Arguments:
+      # * <em>name</em>: Option name
+      # Returns: <em>true</em> if options was provided, <em>false</em> otherwise. 
+      def provided?(name)
+        @options[:name][:value] != nil
+      end
+
+      # Get a list of value for the requested options.
+      # Arguments:
+      # * <em>name</em>: Options name
+      # * <em>name</em>: Default value if option was not provided.
+      # Returns: The option value
+      def get(name, default = nil)
+        name = name.to_sym
+      
+        if @options[name][:value] != nil then
+          @options[name][:value]
+        elsif default != nil then
+          default
+        else
+          @options[name][:default]
+        end
+      end
+    
+      # Get a list of value for the requested options.
+      # Arguments:
+      # * <em>options</em>: Options list
+      # Returns: If a single argument is provided, only a value is returned, else an hash (name => value). If no argument is provided, return every option
+      def [](*options)
+        options = [options] unless options.kind_of?(Array)
+        options = @options.keys if opts.length == 0
+
+        if options.length == 1 then
+          self.get(options[0])
+        else
+          rv = {}
+          options.each do |option|
+            rv[option] = self.get(option) if self.exists?(option)
+          end
+          rv
+        end
+      end
+
+      # Returns option and non option provided arguments.
+      def fetch
+        [self.[], @args]
+      end
+    
+      # Prints the help message.
+      def print_help
+        # Print app name
+        if @app_name then
+          print "#{@app_name}"
+          if @app_version > 0 then print " #{@app_version}" end
+          if @info then print " - #{@info}" end
+          print "\n"
+        end
+      
+        # Print usage
+        if @messages["pre_usage"] then print "#{@messages["pre_usage"]}\n" end
+        print "#{if @usage then @usage else "Usage: #{$0} [OPTIONS]" end}\n"
+
+        # Print pre_options
+        if @messages["pre_options"] then print "#{@messages["pre_options"]}\n" end
+        print "\nValid options are:\n"
+      
+        # Order options for printing
+        @sorted_opts = @inserted[0].sort do |first, second|
+          @options[first].priority != @options[second].priority ? @options[first].priority <=> @options[second].priority : @inserted[0].index(first) <=> @inserted[0].index(second) end
+        end
+      
+        # Add options, saving max length
+        popts = {}
+        maxlen = -1
+        @sorted_opts.each do |key|
+          opt = @options[key]
+        
+          popt = "#{[opt.short, opt.long].join(", ")}"
+          popt += ("=" + (if opt.meta then opt.meta else "ARG" end)) unless opt.opt_type == :bool or opt.opt_type == :action
+
+          popts[key] = popt
+          maxlen = popt.length if popt.length > maxlen
+        end
+
+        # Print options
+        @sorted_opts.each do |key|
+          val = popts[key]
+          print "\t#{val}#{" " * (5 + (maxlen - val.length))}#{@options[key].help}\n"
+        end
+      
+        # Print post_options
+        if @messages["post_options"] then print "#{@messages["post_options"]}\n" end
+      end
+    
+      #Creates a new OptionParser.
+      #
+      # Arguments:
+      # * <em>name</em>: Application name
+      # * <em>version</em>: Application version
+      # * <em>name</em>: Application description
+      # * <em>name</em>: Application usage
+      # * <em>messages</em>: Application message for help switch. Supported keys are
+      #   * <em>:pre_usage</em>: Message to print before the usage string
+      #   * <em>:pre_options</em>: Message to print before the options list
+      #   * <em>:post_options</em>: Message to print after the options list
+      def initialize(*args)
+  			msgs = if msgs.length > 0 then msgs[0] else {} end
+
+        # Initialize types
+        @@valid_types = {:bool => [], :string => [String, ""], :int => [Integer, 0], :float => [Float, 0.0], :choice => [String, ""], :list => [Array, []], :action => []}
+        
+        # Copy arguments
+        @app_name = args[:name] 
+        @app_name = args[:version]
+        @info = args[:info]
+        @usage = args[:usage]
+        if msgs.kind_of?(Hash) then @messages = args[:messages] else @console.fatal(:msg => "CowtechLib::OptionParser::initialize msgs argument must be an hash.") end
+      
+        # Initialize variables
+        @console = CowtechLib::Console.new
+        @inserted = {:name => [], :short => [], :long => []]      
+        @options = {}
+        @options_map = {}
+        @args = []
+        @cmdline = ARGV.clone
+      
+        self << {:name => "help", :short => "-h", :long => "--help", :type => :bool, :help => "Show this message.", :priority => 1000}
+      end
+    end
+  end
+end

data/lib/cowtech-lib/script.rb

@@ -0,0 +1,122 @@
+# encoding: utf-8
+#
+#	cowtech-lib
+#	Author: Shogun <shogun_panda@me.com>
+#	Copyright © 2011 and above Shogun
+# Released under the MIT License, which follows.
+#
+# The MIT License
+# Permission is hereby granted, free of charge, to any person obtaining a copy
+# of this software and associated documentation files (the "Software"), to deal
+# in the Software without restriction, including without limitation the rights
+# to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
+# copies of the Software, and to permit persons to whom the Software is
+# furnished to do so, subject to the following conditions:
+# 
+# The above copyright notice and this permission notice shall be included in
+# all copies or substantial portions of the Software.
+# 
+# THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+# IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+# FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
+# AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
+# LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
+# OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN
+# THE SOFTWARE.
+#
+
+require "pp"
+require "rexml/document"
+require "rubygems"
+require "open4"
+require "find"
+require "CowtechLib/Console"
+require "CowtechLib/OptionParser"
+
+module Cowtech
+  module Lib
+    # Class which implements a script to execute general tasks.
+    # @author Shogun 
+    class Script
+      # Console object
+      attr_reader :console
+    
+      # Shell object
+      attr_reader :shell
+      
+      # Options parser
+      attr_reader :options_parser
+    
+      # Creates a new script.
+      # 
+      # Arguments:
+      # * <em>name</em>: Script name
+      # * <em>version</em>: Script version
+      # * <em>name</em>: Script description
+      # * <em>name</em>: Script usage
+      # * <em>name</em>: Script message for help switch. Supported keys are
+      #   * <em>pre_usage</em>: Message to print before the usage string
+      #   * <em>pre_options</em>: Message to print before the options list
+      #   * <em>post_options</em>: Message to print after the options list
+      def initialize(*args)
+        @console = Console.new
+        @shell = Console.new(@console)
+        @options_parser = OptionParser.new(*args)
+
+        self.add_options()
+        @options_parser << [
+          {:name => "command-echo", :short => "-z", :long => "--command-echo", :type => :bool, :help => "Show executed commands."}
+          {:name => "command-show", :short => "-V", :long => "--command-show", :type => :bool, :help => "Show executed commands' output."}
+          {:name => "command-skip", :short => "-Z", :long => "--command-skip", :type => :bool, :help => "Don't really execut commands, only print them."}
+        ]
+
+        @options_parser.parse()
+
+        @console.show_commands = @options_parser["command-echo"]
+        @console.show_outputs = @options_parser["command-show"]
+        @console.skip_commands = @options_parser["command-skip"]
+
+        self.run()
+      end
+    
+      # Execute a task, showing a message.
+      # 
+      # Arguments:
+      # * <em>msg</em>: The message to show
+      # * <em>show_message</em>: If show task description
+      # * <em>show_end</em>: If show message exit status
+      # * <em>go_up</em>: If go up one line to show exit status
+      # * <em>dots</em>: If show dots after message
+      def task(*args)
+        if args[:show_msg] then
+          @console.msg(:msg => msg, :dots => args[:dots], :begin => true) if args[:show_msg]
+          @console.indent(3)
+        end
+      
+        # Run the block
+        rv = yield || :ok
+      
+        # Show the result
+        @console.result(:result = rv.try("[]", 0) || rv, :fatal => rv.try("[]", 1) == nil ? true : rv.try("[]", 1)) if args[:show_result]
+        @console.indent(-3)
+      end
+
+      # Run the script. 
+      #<b> MUST BY OVERRIDEN BY SUBCLASSES!</b>
+      def run
+        self.console.fatal("Script::run() must be overidden by subclass")
+      end
+    
+      # Adds the command line options.
+      # <b>MUST BE OVERRIDEN BY SUBCLASSES!</b>
+      def add_options 
+        self.console.fatal("Cowtech::Lib::Script::add_options must be overidden by subclass.")
+      end
+      
+      # Executes the script
+      def self.execute!
+        self.new.run
+      end
+    end
+  end
+end