shu-san-scripts 0.1.0 → 0.1.1

data/lib/SANStore/cli/logger.rb

@@ -1,88 +0,0 @@
-# Copyright (c) 2009 Denis Defreyne, 2010-2011 David Love
-#
-# Permission to use, copy, modify, and/or distribute this software for 
-# any purpose with or without fee is hereby granted, provided that the 
-# above copyright notice and this permission notice appear in all copies.
-#
-# THE SOFTWARE IS PROVIDED "AS IS" AND THE AUTHOR DISCLAIMS ALL WARRANTIES 
-# WITH REGARD TO THIS SOFTWARE INCLUDING ALL IMPLIED WARRANTIES OF 
-# MERCHANTABILITY AND FITNESS. IN NO EVENT SHALL THE AUTHOR BE LIABLE FOR 
-# ANY SPECIAL, DIRECT, INDIRECT, OR CONSEQUENTIAL DAMAGES OR ANY DAMAGES 
-# WHATSOEVER RESULTING FROM LOSS OF USE, DATA OR PROFITS, WHETHER IN AN 
-# ACTION OF CONTRACT, NEGLIGENCE OR OTHER TORTIOUS ACTION, ARISING OUT OF 
-# OR IN CONNECTION WITH THE USE OR PERFORMANCE OF THIS SOFTWARE.
-#
-
-require 'singleton'
-require 'facets'
-
-module SANStore::CLI
-
-  # SANStore::CLI::Logger is a singleton class responsible for generating
-  # feedback in the terminal.
-  class Logger
-
-    # ANSI console codes (escape sequences) for highlighting particular
-    # log outputs.
-    ACTION_COLORS = {
-      :error          => "\e[1m" + "\e[31m", # bold + red
-      :warning        => "\e[1m" + "\e[33m", # bold + yellow
-      :info           => "\e[1m" + "\e[32m", # bold + green
-    }
-
-    include Singleton
-
-    # The log level, which can be :high, :low or :off (which will log all
-    # messages, only high-priority messages, or no messages at all,
-    # respectively).
-    attr_accessor :level
-
-    # Whether to use color in log messages or not
-    attr_accessor :color
-    alias_method :color?, :color
-
-    def initialize
-      @level = :high
-      @color = true
-    end
-
-    # Logs a messsage, using appropriate colours to highlight different
-    # levels.
-    #
-    # +level+:: The importance of this action. Can be :high or :low.
-    #
-    # +action+:: The kind of file action. Can be :create, :update or
-    #            :identical.
-    #
-    # +message+:: The identifier of the item the action was performed on.
-    def log_level(level, action, message)
-      log(
-        level,
-        '%s%12s%s:  %s' % [
-          color? ? ACTION_COLORS[action.to_sym] : '',
-          action.capitalize,
-          color? ? "\e[0m" : '',
-          message.word_wrap(60).indent(15).lstrip
-        ]
-      )
-    end
-
-    # Logs a message.
-    #
-    # +level+:: The importance of this message. Can be :high or :low.
-    #
-    # +message+:: The message to be logged.
-    #
-    # +io+:: The IO instance to which the message will be written. Defaults to
-    #        standard output.
-    def log(level, message, io=$stdout)
-      # Don't log when logging is disabled
-      return if @level == :off
-
-      # Log when level permits it
-      io.puts(message) if (@level == :low or @level == level)
-    end
-
-  end
-
-end

data/lib/SANStore/cri.rb

@@ -1,12 +0,0 @@
-module Cri
-
-  # The current Cri version.
-  CRI_VERSION = '1.0'
-
-end
-
-# Load Cri
-require 'SANStore/cri/base'
-require 'SANStore/cri/command'
-require 'SANStore/cri/core_ext'
-require 'SANStore/cri/option_parser'

data/lib/SANStore/cri/base.rb

@@ -1,153 +0,0 @@
-module Cri
-
-  # Cri::Base is the central class representing a commandline tool. It has a
-  # list of commands.
-  class Base
-
-    # The CLI's list of commands (should also contain the help command)
-    attr_reader :commands
-
-    # The CLI's help command (required)
-    attr_accessor :help_command
-
-    # Creates a new instance of the commandline tool.
-    def initialize(tool_name)
-      @tool_name = tool_name
-
-      @commands = []
-    end
-
-    # Parses the given commandline arguments and executes the requested
-    # command.
-    def run(args)
-      # Check arguments
-      if args.length == 0
-        @help_command.run([], [])
-        exit 1
-      end
-
-      # Partition options
-      opts_before_command         = []
-      command_name                = nil
-      opts_and_args_after_command = []
-      stage = 0
-      args.each do |arg|
-        # Update stage if necessary
-        stage = 1 if stage == 0 && !is_option?(arg)
-
-        # Add
-        opts_before_command << arg         if stage == 0
-        command_name = arg                 if stage == 1
-        opts_and_args_after_command << arg if stage == 2
-
-        # Update stage if necessary
-        stage = 2 if stage == 1
-      end
-
-      # Handle options before command
-      begin
-        parsed_arguments = Cri::OptionParser.parse(opts_before_command, global_option_definitions)
-      rescue Cri::OptionParser::IllegalOptionError => e
-        $stderr.puts "illegal option -- #{e}"
-        exit 1
-      end
-      parsed_arguments[:options].keys.each do |option|
-        handle_option(option)
-      end
-
-      # Get command
-      if command_name.nil?
-        $stderr.puts "no command given"
-        exit 1
-      end
-      command = command_named(command_name)
-      if command.nil?
-        $stderr.puts "no such command: #{command_name}"
-        exit 1
-      end
-
-      # Parse arguments
-      option_definitions = command.option_definitions + global_option_definitions
-      begin
-        parsed_arguments = Cri::OptionParser.parse(opts_and_args_after_command, option_definitions)
-      rescue Cri::OptionParser::IllegalOptionError => e
-        $stderr.puts "illegal option -- #{e}"
-        exit 1
-      rescue Cri::OptionParser::OptionRequiresAnArgumentError => e
-        $stderr.puts "option requires an argument -- #{e}"
-        exit 1
-      end
-
-      # Handle global options
-      global_options = global_option_definitions.map { |o| o[:long] }
-      global_options.delete_if { |o| !parsed_arguments[:options].keys.include?(o.to_sym) }
-      global_options.each { |o| handle_option(o.to_sym) }
-
-      if parsed_arguments[:options].has_key?(:help)
-        # Show help for this command
-        show_help(command)
-      else
-        # Run command
-        command.run(parsed_arguments[:options], parsed_arguments[:arguments])
-      end
-    end
-
-    # Returns the command with the given name.
-    def command_named(name)
-      # Find by exact name or alias
-      command = @commands.find { |c| c.name == name or c.aliases.include?(name) }
-      return command unless command.nil?
-
-      # Find by approximation
-      commands = @commands.select { |c| c.name[0, name.length] == name }
-      if commands.length > 1
-        $stderr.puts "#{@tool_name}: '#{name}' is ambiguous:"
-        $stderr.puts "  #{commands.map { |c| c.name }.join(' ') }"
-        exit 1
-      elsif commands.length == 0
-        $stderr.puts "#{@tool_name}: unknown command '#{name}'\n"
-        show_help
-        exit 1
-      else
-        return commands[0]
-      end
-    end
-
-    # Shows the help text for the given command, or shows the general help
-    # text if no command is given.
-    def show_help(command=nil)
-      if command.nil?
-        @help_command.run([], [])
-      else
-        @help_command.run([], [ command.name ])
-      end
-    end
-
-    # Returns the list of global option definitionss.
-    def global_option_definitions
-      []
-    end
-
-    # Adds the given command to the list of commands. Adding a command will
-    # also cause the command's +base+ to be set to this instance.
-    def add_command(command)
-      @commands << command
-      command.base = self
-    end
-
-    # Handles the given optio
-    def handle_option(option)
-      false
-    end
-
-  private
-
-    # Returns true if the given string is an option (i.e. -foo or --foo),
-    # false otherwise.
-    def is_option?(string)
-      string =~ /^-/
-    end
-
-  end
-
-end

data/lib/SANStore/cri/command.rb

@@ -1,104 +0,0 @@
-module Cri
-
-  # Cri::Command represents a command that can be executed on the commandline.
-  # It is an abstract superclass for all commands.
-  class Command
-
-    attr_accessor :base
-
-    # Returns a string containing the name of thi command. Subclasses must
-    # implement this method.
-    def name
-      raise NotImplementedError.new("Command subclasses should override #name")
-    end
-
-    # Returns an array of strings containing the aliases for this command.
-    # Subclasses must implement this method.
-    def aliases
-      raise NotImplementedError.new("Command subclasses should override #aliases")
-    end
-
-    # Returns a string containing this command's short description, which
-    # should not be longer than 50 characters. Subclasses must implement this
-    # method.
-    def short_desc
-      raise NotImplementedError.new("Command subclasses should override #short_desc")
-    end
-
-    # Returns a string containing this command's complete description, which
-    # should explain what this command does and how it works in detail.
-    # Subclasses must implement this method.
-    def long_desc
-      raise NotImplementedError.new("Command subclasses should override #long_desc")
-    end
-
-    # Returns a string containing this command's usage. Subclasses must
-    # implement this method.
-    def usage
-      raise NotImplementedError.new("Command subclasses should override #usage")
-    end
-
-    # Returns an array containing this command's option definitions. See the
-    # documentation for Cri::OptionParser for details on what option
-    # definitions look like. Subclasses may implement this method if the
-    # command has options.
-    def option_definitions
-      []
-    end
-
-    # Executes the command. Subclasses must implement this method
-    # (obviously... what's the point of a command that can't be run?).
-    #
-    # +options+:: A hash containing the parsed commandline options. For
-    #             example, '--foo=bar' will be converted into { :foo => 'bar'
-    #             }. See the Cri::OptionParser documentation for details.
-    #
-    # +arguments+:: An array of strings representing the commandline arguments
-    #               given to this command.
-    def run(options, arguments)
-      raise NotImplementedError.new("Command subclasses should override #run")
-    end
-
-    # Returns the help text for this command.
-    def help
-      text = ''
-
-      # Append usage
-      text << usage + "\n"
-
-      # Append aliases
-      unless aliases.empty?
-        text << "\n"
-        text << "aliases: #{aliases.join(' ')}\n"
-      end
-
-      # Append short description
-      text << "\n"
-      text << short_desc + "\n"
-
-      # Append long description
-      text << "\n"
-      text << long_desc.wrap_and_indent(78, 4) + "\n"
-
-      # Append options
-      unless option_definitions.empty?
-        text << "\n"
-        text << "options:\n"
-        text << "\n"
-        option_definitions.sort { |x,y| x[:long] <=> y[:long] }.each do |opt_def|
-          text << sprintf("    -%1s --%-10s %s\n\n", opt_def[:short], opt_def[:long], opt_def[:desc].wrap_and_indent(78, 20).lstrip)
-        end
-      end
-
-      # Return text
-      text
-    end
-
-    # Compares this command's name to the other given command's name.
-    def <=>(other)
-      self.name <=> other.name
-    end
-
-  end
-
-end

data/lib/SANStore/cri/core_ext.rb

@@ -1,8 +0,0 @@
-module Cri::CoreExtensions
-end
-
-require 'SANStore/cri/core_ext/string'
-
-class String
-  include Cri::CoreExtensions::String
-end

data/lib/SANStore/cri/core_ext/string.rb

@@ -1,41 +0,0 @@
-module Cri::CoreExtensions
-
-  module String
-
-    # Word-wraps and indents the string.
-    #
-    # +width+:: The maximal width of each line. This also includes indentation,
-    #           i.e. the actual maximal width of the text is width-indentation.
-    #
-    # +indentation+:: The number of spaces to indent each wrapped line.
-    def wrap_and_indent(width, indentation)
-      # Split into paragraphs
-      paragraphs = self.split("\n").map { |p| p.strip }.reject { |p| p == '' }
-
-      # Wrap and indent each paragraph
-      paragraphs.map do |paragraph|
-        # Initialize
-        lines = []
-        line = ''
-
-        # Split into words
-        paragraph.split(/\s/).each do |word|
-          # Begin new line if it's too long
-          if (line + ' ' + word).length >= width
-            lines << line
-            line = ''
-          end
-
-          # Add word to line
-          line += (line == '' ? '' : ' ' ) + word
-        end
-        lines << line
-
-        # Join lines
-        lines.map { |l| ' '*indentation + l }.join("\n")
-      end.join("\n\n")
-    end
-
-  end
-
-end

data/lib/SANStore/cri/option_parser.rb

@@ -1,186 +0,0 @@
-module Cri
-
-  # Cri::OptionParser is used for parsing commandline options.
-  class OptionParser
-
-    # Error that will be raised when an unknown option is encountered.
-    class IllegalOptionError < RuntimeError ; end
-
-    # Error that will be raised when an option without argument is
-    # encountered.
-    class OptionRequiresAnArgumentError < RuntimeError ; end
-
-    # Parses the commandline arguments in +arguments_and_options+, using the
-    # commandline option definitions in +definitions+.
-    #
-    # +arguments_and_options+ is an array of commandline arguments and
-    # options. This will usually be +ARGV+.
-    #
-    # +definitions+ contains a list of hashes defining which options are
-    # allowed and how they will be handled. Such a hash has three keys:
-    #
-    # :short:: The short name of the option, e.g. +a+. Do not include the '-'
-    #          prefix.
-    #
-    # :long:: The long name of the option, e.g. +all+. Do not include the '--'
-    #         prefix.
-    #
-    # :argument:: Whether this option's argument is required (:required),
-    #             optional (:optional) or forbidden (:forbidden).
-    #
-    # A sample array of definition hashes could look like this:
-    #
-    #     [
-    #       { :short => 'a', :long => 'all',  :argument => :forbidden },
-    #       { :short => 'p', :long => 'port', :argument => :required  },
-    #     ]
-    #
-    # During parsing, two errors can be raised:
-    #
-    # IllegalOptionError:: An unrecognised option was encountered, i.e. an
-    #                      option that is not present in the list of option
-    #                      definitions.
-    #
-    # OptionRequiresAnArgumentError:: An option was found that did not have a
-    #                                 value, even though this value was
-    #                                 required.
-    #
-    # What will be returned, is a hash with two keys, :arguments and :options.
-    # The :arguments value contains a list of arguments, and the :options
-    # value contains a hash with key-value pairs for each option. Options
-    # without values will have a +nil+ value instead.
-    #
-    # For example, the following commandline options (which should not be
-    # passed as a string, but as an array of strings):
-    #
-    #     foo -xyz -a hiss -s -m please --level 50 --father=ani -n luke squeak
-    #
-    # with the following option definitions:
-    #
-    #     [
-    #       { :short => 'x', :long => 'xxx',    :argument => :forbidden },
-    #       { :short => 'y', :long => 'yyy',    :argument => :forbidden },
-    #       { :short => 'z', :long => 'zzz',    :argument => :forbidden },
-    #       { :short => 'a', :long => 'all',    :argument => :forbidden },
-    #       { :short => 's', :long => 'stuff',  :argument => :optional  },
-    #       { :short => 'm', :long => 'more',   :argument => :optional  },
-    #       { :short => 'l', :long => 'level',  :argument => :required  },
-    #       { :short => 'f', :long => 'father', :argument => :required  },
-    #       { :short => 'n', :long => 'name',   :argument => :required  }
-    #     ]
-    #
-    # will be translated into:
-    #
-    #     {
-    #       :arguments => [ 'foo', 'hiss', 'squeak' ],
-    #       :options => {
-    #         :xxx    => true,
-    #         :yyy    => true,
-    #         :zzz    => true,
-    #         :all    => true,
-    #         :stuff  => true,
-    #         :more   => 'please',
-    #         :level  => '50',
-    #         :father => 'ani',
-    #         :name   => 'luke'
-    #       }
-    #     }
-    def self.parse(arguments_and_options, definitions)
-      # Don't touch original argument
-      unprocessed_arguments_and_options = arguments_and_options.dup
-
-      # Initialize
-      arguments = []
-      options   = {}
-
-      # Determines whether we've passed the '--' marker or not
-      no_more_options = false
-
-      loop do
-        # Get next item
-        e = unprocessed_arguments_and_options.shift
-        break if e.nil?
-
-        # Handle end-of-options marker
-        if e == '--'
-          no_more_options = true
-        # Handle incomplete options
-        elsif e =~ /^--./ and !no_more_options
-          # Get option key, and option value if included
-          if e =~ /^--([^=]+)=(.+)$/
-            option_key   = $1
-            option_value = $2
-          else
-            option_key    = e[2..-1]
-            option_value  = nil
-          end
-
-          # Find definition
-          definition = definitions.find { |d| d[:long] == option_key }
-          raise IllegalOptionError.new(option_key) if definition.nil?
-
-          if [ :required, :optional ].include?(definition[:argument])
-            # Get option value if necessary
-            if option_value.nil?
-              option_value = unprocessed_arguments_and_options.shift
-              if option_value.nil? || option_value =~ /^-/
-                if definition[:argument] == :required
-                  raise OptionRequiresAnArgumentError.new(option_key)
-                else
-                  unprocessed_arguments_and_options.unshift(option_value)
-                  option_value = true
-                end
-              end
-            end
-
-            # Store option
-            options[definition[:long].to_sym] = option_value
-          else
-            # Store option
-            options[definition[:long].to_sym] = true
-          end
-        # Handle -xyz options
-        elsif e =~ /^-./ and !no_more_options
-          # Get option keys
-          option_keys = e[1..-1].scan(/./)
-
-          # For each key
-          option_keys.each do |option_key|
-            # Find definition
-            definition = definitions.find { |d| d[:short] == option_key }
-            raise IllegalOptionError.new(option_key) if definition.nil?
-
-            if option_keys.length > 1 and definition[:argument] == :required
-              # This is a combined option and it requires an argument, so complain
-              raise OptionRequiresAnArgumentError.new(option_key)
-            elsif [ :required, :optional ].include?(definition[:argument])
-              # Get option value
-              option_value = unprocessed_arguments_and_options.shift
-              if option_value.nil? || option_value =~ /^-/
-                if definition[:argument] == :required
-                  raise OptionRequiresAnArgumentError.new(option_key)
-                else
-                  unprocessed_arguments_and_options.unshift(option_value)
-                  option_value = true
-                end
-              end
-
-              # Store option
-              options[definition[:long].to_sym] = option_value
-            else
-              # Store option
-              options[definition[:long].to_sym] = true
-            end
-          end
-        # Handle normal arguments
-        else
-          arguments << e
-        end
-      end
-
-      { :options => options, :arguments => arguments }
-    end
-
-  end
-
-end