pione 0.3.2 → 0.4.0

data/lib/rootage/normalizer.rb

@@ -0,0 +1,184 @@
+module Rootage
+  # `Normalizer` is a utility module that normalizes values into normalization
+  # types. If values cannot normalize, this method raises
+  # `NormalizerValueError`. Normalization types are followings:
+  #
+  #  - boolean
+  #  - string
+  #  - integer
+  #  - positive_integer
+  #  - float
+  #  - date
+  #
+  # And array is treated as special type, this type means the value should be
+  # included in the array.
+  module Normalizer
+    class << self
+      # Normalize the value as the normalization type.
+      #
+      # @param type [Symbol]
+      #   normalization type
+      # @param val [Object]
+      #   source value
+      # @return [Object]
+      #   the normalized value
+      def normalize(type, val)
+        if respond_to?(type, true)
+          send(type, val)
+        else
+          raise NormalizerTypeError.new(type)
+        end
+      end
+
+      # Set normalization function.
+      #
+      # @param name [Symbol]
+      #   normalization type name
+      # @yieldparam val [Object]
+      #   source object
+      def set(name, &block)
+        singleton_class.instance_eval do
+          define_method(name, &block)
+        end
+      end
+
+      private
+
+      def boolean(val)
+        BooleanValue.of(val)
+      rescue => e
+        raise NormalizerValueError.new(:boolean, val, e.message)
+      end
+
+      def string(val)
+        val.to_s
+      rescue => e
+        raise NormalizerValueError.new(:string, val, e.message)
+      end
+
+      def symbol(val)
+        val.to_sym
+      rescue => e
+        raise NormalizerValueError.new(:symbol, val, e.message)
+      end
+
+      def symbol_downcase(val)
+        val.to_s.downcase.to_sym
+      rescue => e
+        raise NormalizerValueError.new(:symbol_downcase, val, e.message)
+      end
+
+      def symbol_uppercase(val)
+        val.to_s.uppercase.to_sym
+      rescue => e
+        raise NormalizerValueError.new(:symbol_uppercase, val, e.message)
+      end
+
+      def integer(val)
+        val.to_i
+      rescue => e
+        raise NormalizerValueError.new(:integer, val, e.message)
+      end
+
+      def positive_integer(val)
+        n = integer(val)
+        if n > 0
+          n
+        else
+          raise NormalizerValueError.new(:positive_integer, val, "It should be a positive integer.")
+        end
+      end
+
+      def float(val)
+        val.to_f
+      rescue => e
+        raise NormalizerValueError.new(:float, val, e.message)
+      end
+
+      def path(val)
+        if val.is_a?(Pathname)
+          val
+        else
+          Pathname.new(val)
+        end
+      rescue => e
+        raise NormalizerValueError.new(:path, val, e.message)
+      end
+
+      def date(val)
+        if val.is_a?(Date)
+          val
+        else
+          Date.iso8601(val)
+        end
+      rescue => e
+        raise NormalizerValueError.new(:date, val, e.message)
+      end
+
+      def uri(val)
+        URI.parse(val)
+      rescue => e
+        raise NormalizerValueError.new(:uri, val, e.message)
+      end
+    end
+  end
+
+  module BooleanValue
+    class << self
+      # Return boolean value of the object.
+      #
+      # @param val [Object]
+      #   target object
+      # @return [Boolean]
+      #   boolean of the object
+      def of(val)
+        case val
+        when NilClass
+          false
+        when TrueClass
+          true
+        when FalseClass
+          false
+        when String
+          of_string(val)
+        when Number
+          of_number(val)
+        else
+          raise ArgumentError.new(val)
+        end
+      end
+
+      private
+
+      # Return boolean value of the string. Ignoring letter cases, "true",
+      # "t", "yes", and "y" are true, and "false", "f", "no", and "n" are
+      # false. Ohterwise raise `ArgumentError`.
+      #
+      # @param val [String]
+      #   the string
+      # @return [Boolean]
+      #   boolean of the string
+      def of_string(val)
+        case val.downcase
+        when "true", "t", "yes", "y"
+          true
+        when "false", "f", "no", "n"
+          false
+        else
+          raise ArgumentError.new(val)
+        end
+      end
+
+      # Return boolean value of the number. Return true if the number is
+      # greater than 0.
+      #
+      # @param val [Numeric]
+      #   the number
+      # @return [Boolean]
+      #   boolean of the number
+      def of_number(val)
+        val > 0
+      end
+    end
+  end
+end

data/lib/rootage/option.rb

@@ -0,0 +1,152 @@
+module Rootage
+  # Option is an option item for PIONE command.
+  class Option < Item
+    # `type` is a normalization type. The string user specified is normalized
+    # by this type.
+    member :type
+
+    # `range` is candidates of option values.
+    member :range
+
+    # `short` is an short option name. This requires first hyphen character
+    # and successful one character. For example, `"-q"` is a short option.
+    member :short
+
+    # `long` is a long option name. This requires first hyphen characters and
+    # any characters. For example, `"--quiet"` is a long option.
+    member :long
+
+    # `arg` is an option's argument. The notation of this follows
+    # "optarg.rb". For example, `"ARG"` is requisite argument, and `"[ARG]"`
+    # is optional argument.
+    member :arg
+
+    # Default value that the option is specified. This value is normalized by
+    # option type.
+    member :default
+
+    # Initial model value. This value is normalized by option type.
+    member :init
+
+    # This validates option's value. Validation is done after application of
+    # post process.
+    member :validator
+
+    # This flag is true, the option is requisite.
+    member :requisite
+
+    def define_validator(&b)
+      self.validator = b
+    end
+
+    # Setup an OptionParser's option by this item.
+    #
+    # @param opt [OptionParser]
+    #   option parser
+    # @param cmd [Command::PlainCommand]
+    #   command object
+    # @return [void]
+    def setup(opt, cmd)
+      # build OptionParser#on arguments
+      args = [short_for_optparse, long_for_optparse, desc].compact
+      # call #on with the argument
+      opt.on(*args) {|val| specify(cmd, val)}
+    end
+
+    private
+
+    # Return short option string for optparse.rb.
+    def short_for_optparse
+      (arg and long.nil?) ? ("%s %s" % [short, arg]) : short
+    end
+
+    # Return log option string for optparse.rb.
+    def long_for_optparse
+      (arg and not(long.nil?)) ? ("%s %s" % [long, arg]) : long
+    end
+
+    # Specify the option value.
+    #
+    # @param cmd [Command::PlainCommand]
+    #   command object
+    # @param val [Object]
+    #   option value
+    # @return [void]
+    def specify(cmd, val)
+      # set default value
+      if val.nil? and not(self.default.nil?)
+        val = self.default
+      end
+
+      # normalization
+      _val = Normalizer.normalize(type, val)
+
+      if range.nil? or range.include?(_val)
+        if processes.empty?
+          cmd.model.specify(key, _val)
+        else
+          execute(cmd, _val)
+        end
+      else
+        arg = {value: _val, range: range}
+        raise OptionError.new(cmd, '"%{value}" is out of %{range}' % arg)
+      end
+    end
+  end
+
+  # OptionCollection is a collection interface for options.
+  module OptionCollection
+    include CollectionInterface
+    set_item_class Option
+  end
+
+  # `OptionDefinition` is a class that holds command's option definitions.
+  class OptionDefinition < Sequence
+    include CollectionInterface
+    set_item_class Option
+
+    private
+
+    # Parse the command options.
+    #
+    # @param cmd [Command]
+    #   command object
+    # @return [void]
+    def execute_main(cmd)
+      # append help option
+      _list = list.clone
+      _list << HelpOption.help
+
+      _list.each do |item|
+        # merge init values
+        if item.init
+          cmd.model[item.name] = Normalizer.normalize(item.type, item.init)
+        end
+        # set process context class
+        if item.process_context_class.nil?
+          item.process_context_class = get_process_context_class(cmd)
+        end
+      end
+
+      # parse options
+      OptionParser.new do |opt|
+        _list.each {|item| item.setup(opt, cmd)}
+      end.send(cmd.has_subcommands? ? :order! : :parse!, cmd.argv)
+
+      # check option's validness
+      check(cmd)
+    rescue OptionParser::ParseError, NormalizerValueError => e
+      raise OptionError.new(cmd, e.message)
+    end
+
+    # Check validness of the command options.
+    def check(cmd)
+      # check requisite options
+      list.each do |item|
+        if item.requisite and not(cmd.model[item.key])
+          raise OptionError.new(cmd, 'option "%s" is requisite' % [item.long])
+        end
+      end
+    end
+  end
+end

data/lib/rootage/scenario-test-result.erb

@@ -0,0 +1,39 @@
+
+Scenario Result
+===============
+
+Scenario  : <%= scenario.is_a?(Rootage::Scenario) ? scenario.class : scenario %>
+Arguments : <%= args %>
+Result    : <%= success? ? "scenario succeeded" : "scenario failed" %>
+Time      : <%= Time.now %>
+<% if not(success?) %>
+
+Error Message
+-------------
+
+<%=  exception.message %>
+
+
+Backtrance
+----------
+
+<% exception.backtrace.each do |line| %>
+<%= line %>
+
+<% end %>
+<% end %>
+<% if stdout.string.size > 0 %>
+
+Stdout
+------
+
+<%= stdout.string %>
+<% end %>
+<% if stderr.string.size > 0 %>
+
+Stderr
+------
+
+<%= stderr.string %>
+<% end %>
+

data/lib/rootage/scenario.rb

@@ -0,0 +1,362 @@
+module Rootage
+  # ScenarioDefinition is an information table for Scenario class.
+  class ScenarioDefinition
+    # Create a new information table.
+    def initialize(table=Hash.new)
+      @table = table
+      self[:name] ||= "anonymous"
+    end
+
+    # define forwarding messages
+    forward :@table, :has_key?
+
+    # Define a scenario information that associates key and value.
+    #
+    # @param key [Symbol]
+    #   key name
+    # @param val [Object]
+    #   item's value
+    # @param args_block [Proc]
+    #   value's arguments
+    # @return [void]
+    def define(key, val=nil, &block)
+      if val.nil? and not(block_given?)
+        raise ArgumentError.new("Cannot define %{key} with no data." % {key: key})
+      end
+      @table[key] = {value: val, block: block}
+    end
+
+    # Return the item value of the key.
+    #
+    # @param key [Object]
+    #   the key
+    # @return [Object]
+    #   the value
+    def value_of(key)
+      if @table.has_key?(key)
+        @table[key][:value]
+      end
+    end
+    alias :[] :value_of
+
+    # Return the item block of the key.
+    #
+    # @param key [Object]
+    #   the key
+    # @return [Object]
+    #   the block
+    def block_of(key)
+      if @table.has_key?(key)
+        @table[key][:block]
+      end
+    end
+
+    def []=(key, val)
+      define(key, val)
+    end
+
+    def scenario_name
+      self[:name]
+    end
+
+    def desc
+      self[:desc]
+    end
+
+    def clone
+      self.class.new(@table.clone)
+    end
+  end
+
+  # ScenarioInterface provides basic methods for Scenario.
+  module ScenarioInterface
+    def define(*args)
+      @info.define(*args)
+    end
+
+    def scenario_name
+      @info.scenario_name
+    end
+
+    def desc
+      @info.desc
+    end
+
+    # Return a process context class.
+    #
+    # @return [Class]
+    #   process context class
+    def process_context_class
+      @info[:process_context_class]
+    end
+
+    # Return a phase class used for this scnario.
+    def phase_class
+      @info[:phase_class]
+    end
+
+    # Define a phase.
+    #
+    # @raise [ArgumentError]
+    #   if there is same name phase already
+    # @param name [String]
+    #   phase name
+    # @yieldparam phase [Phase]
+    #   phase object
+    # @return [void]
+    def define_phase(name, &block)
+      if @__phase__.has_key?(name)
+        raise ArgumentError.new('Phase "%{name}" has been defined already.' % {name: name})
+      end
+
+      @__phase__[name] = phase_class.new(name)
+
+      if block_given?
+        block.call(@__phase__[name])
+      end
+    end
+
+    # Find a phase object by the name.
+    #
+    # @param name [Symbol]
+    #   the phase name
+    # @return [Command::Phase]
+    #   a phase object
+    def phase(name, &block)
+      unless @__phase__.has_key?(name)
+        raise ArgumentError.new('Unknown phase name: "%s"' % name)
+      end
+
+      if block_given?
+        block.call(@__phase__[name])
+      end
+
+      @__phase__[name]
+    end
+  end
+
+  # Scenario is a class that controls flows and handles sequencial actions.
+  class Scenario
+    # import basic methods for object
+    include ScenarioInterface
+
+    # initial settings
+    @requirements = Array.new
+    @info = ScenarioDefinition.new
+    @__phase__ = Hash.new
+
+    class << self
+      # import basic methods for class
+      include ScenarioInterface
+
+      attr_accessor :requirements
+      attr_accessor :info
+      attr_accessor :__phase__
+
+      def inherited(subclass)
+        # subclass inherits superclass's requirements
+        subclass.requirements = @requirements.clone
+
+        # subclass inherits superclass's info
+        subclass.info = @info.clone
+
+        # subclass inherits superclass's phases
+        subclass.__phase__ = Hash.new
+        @__phase__.each do |key, val|
+          subclass.__phase__[key] = val.copy
+        end
+      end
+
+      def scenario_name
+        @info[:name]
+      end
+
+      # Make a new scenario class.
+      #
+      # @yieldparam block [Class]
+      #   a new scenario class
+      def make(&block)
+        klass = Class.new(self)
+        klass.instance_exec(&block)
+        return klass
+      end
+
+      # Define a requirement of library. This is same as Kernel.require, but
+      # loads it when the scenario runs.
+      #
+      # @param path [String]
+      #   path that is required when the scenario runs
+      # @return [void]
+      def require(path)
+        @requirements << path
+      end
+
+      # Run the scenario with the arguments.
+      #
+      # @param args [Array<Object>]
+      #   scenario arguments
+      def run(*args)
+        self.new(*args).run
+      end
+
+      # Register the action to the phase.
+      #
+      # @param phase_name [Symbol]
+      #   phase name
+      # @param action [Symbol or Action]
+      #   action name or item
+      def define_action(phase_name, action, &b)
+        # setup action item
+        case action
+        when Symbol
+          item = Action.new(name: action)
+        when Action
+          item = action.copy
+        else
+          raise ArgumentError.new("%p is invalid action" % action)
+        end
+
+        # action customization
+        b.call(item) if b
+
+        # append it to the phase
+        @__phase__[phase_name].define(item)
+      end
+    end
+
+    # define default phase class
+    define(:phase_class, Phase)
+
+    # define default process context class
+    define(:process_context_class, ProcessContext)
+
+    attr_reader :args
+    attr_accessor :model
+    attr_accessor :info
+    attr_reader :current_phase
+    attr_accessor :exit_status
+    attr_reader :running_thread
+
+    forward! :class, :desc
+    alias :name :scenario_name
+
+    # Initialize a scenario object.
+    def initialize(*args)
+      # hold scenario arguments
+      @args = args
+
+      # copy requirements, info, phases from the class
+      @requirements = self.class.requirements.clone
+      @info = self.class.instance_variable_get(:@info).clone
+      @__phase__ = self.class.instance_variable_get(:@__phase__).clone
+
+      # setup scenario model
+      if self.class.info[:model]
+        @model = self.class.info[:model].new
+      else
+        @model = Model.new
+      end
+      @model[:scenario_name] = @info.scenario_name
+      @model[:scenario_desc] = @info.desc
+
+      # init
+      @current_phase = nil
+      @exit_status = true
+      @running_thread = nil
+    end
+
+    # Run the lifecycle of command. This fires sequencial actions in each phase.
+    #
+    # @return [void]
+    def run
+      # raise an error when running thread exists already
+      if @running_thread
+        raise ScenarioError.new("Running thread exists already.")
+      end
+
+      @running_thread = Thread.current
+      load_requirements
+      execute_phases
+      @running_thread = nil
+      return self
+    end
+
+    # Push the phase action to the scenario.
+    #
+    # @param object [Action]
+    #   action
+    # @return [void]
+    def <<(object)
+      if @__phase__.empty?
+        phase_name = :default
+        define_phase(phase_name)
+      else
+        phase_name = @__phase__.keys.last
+      end
+      phase(phase_name) << object
+    end
+
+    # Exit running scenario and return the status.
+    #
+    # @return [void]
+    def exit
+      Log.debug('"%{name}" exits with status "%{status}".' % {name: name, status: @exit_status})
+
+      if respond_to?(:exit_process, true)
+        exit_process
+      end
+    end
+
+    # Exit the running command and return failure status. Note that this
+    # method enters termination phase before it exits.
+    def abort(msg_or_exception, pos=caller(1).first)
+      # setup abortion message
+      msg = msg_or_exception.is_a?(Exception) ? msg_or_exception.message : msg_or_exception
+      Log.fatal(msg, pos)
+
+      # set exit status code
+      @exit_status = false
+
+      # do abort process
+      if respond_to?(:abort_process, true)
+        abort_process
+      end
+
+      # finally, exit the command
+      exit
+    end
+
+    private
+
+    # Load additional modules.
+    #
+    # @return [void]
+    def load_requirements
+      @requirements.each do |requirement|
+        Kernel.require(requirement)
+      end
+    end
+
+    # Enter the phase.
+    #
+    # @param phase_name [Symbol]
+    #   the phase name that is entered
+    # @return [void]
+    def enter_phase(phase_name)
+      Log.debug('"%{cmd}" has entered the phase "%{phase}".' % {cmd: name, phase: phase_name})
+      @__phase__[phase_name].execute(self)
+      Log.debug('"%{cmd}" has exited the phase "%{phase}".' % {cmd: name, phase: phase_name})
+    end
+
+    # Execute phases.
+    #
+    # @return [void]
+    def execute_phases
+      @__phase__.each do |phase_name, phase|
+        @current_phase = phase
+        enter_phase(phase_name)
+      end
+      @current_phase = nil
+    end
+  end
+end