pione 0.3.2 → 0.4.0

data/lib/pione/util/completion.rb

@@ -0,0 +1,111 @@
+module Pione
+  module Util
+    class Completion
+      def self.compile(source, target)
+        context = self.new.context
+        target.write(ERB.new(source.read, nil, "-").result(context))
+      end
+
+      attr_reader :completion_command
+      attr_reader :completion_exec
+      attr_reader :name2
+      attr_reader :name3
+
+      def toplevel_commands(mod)
+        mod.constants.map{|c| mod.const_get(c)}.select do |c|
+          c.is_a?(Class) and c < Command::BasicCommand and c.toplevel?
+        end.map {|cmd| [cmd.scenario_name, cmd]}
+      end
+
+      def context
+        binding
+      end
+
+      def descendants(keys, cmd)
+        if cmd.subcommand.empty?
+          [[keys, cmd]]
+        else
+          cmd.subcommand.inject([[keys, cmd]]) do |list, (key, child)|
+            _keys = keys + [key]
+            if child.subcommand.empty?
+              list << [_keys, child]
+            else
+              list.concat(descendants(_keys, child))
+            end
+          end
+        end
+      end
+    end
+
+    class BashCompletion < Completion
+      def initialize
+        @completion_command = "complete"
+        @completion_exec = "complete -F"
+        @name2 = "${COMP_WORDS[1]}"
+        @name3 = "${COMP_WORDS[2]}"
+      end
+
+      def fun_subcommands(cmd)
+        compreply(make_subcommands(cmd))
+      end
+
+      def fun_options(cmd)
+        compreply(make_options(cmd))
+      end
+
+      private
+
+      def compreply(options)
+	'COMPREPLY=($(compgen -W "%s" -- "${COMP_WORDS[COMP_CWORD]}"));' % options
+      end
+
+      def make_subcommands(cmd)
+        cmd.subcommand.keys.join(" ")
+      end
+
+      def make_options(cmd)
+        items = cmd.option_definition.table.values
+        items.sort{|a, b| a.long <=> b.long}.map{|item| item.long}.join(" ")
+      end
+    end
+
+    class ZshCompletion < Completion
+      def initialize
+        @completion_command = "compdef"
+        @completion_exec = "compdef"
+        @name2 = "${words[2]}"
+        @name3 = "${words[3]}"
+      end
+
+      def fun_subcommands(cmd)
+        describe(cmd)
+      end
+
+      def fun_options(cmd)
+        arguments(cmd)
+      end
+
+      private
+
+      def describe(cmd)
+        "list=(%s) _describe -t common-commands 'common commands' list;" % make_subcommands(cmd)
+      end
+
+      def arguments(cmd)
+	"_arguments -s -S %s '*:file:_files' && return 0;" % make_options(cmd)
+      end
+
+      def make_subcommands(cmd)
+        cmd.subcommand.map{|key, val| '%s:"%s"' % [key, val.desc]}.join(" ")
+      end
+
+      def make_options(cmd)
+        items = cmd.option_definition.table.values
+        items.sort{|a, b| a.long <=> b.long}.map do |item|
+          name = item.long.gsub("[", "\\[").gsub("]", "\\]")
+          "\"%s[%s]\"" % [name, item.desc]
+        end.join(" ")
+      end
+    end
+  end
+end

data/lib/pione/util/evaluatable.rb

@@ -6,14 +6,13 @@ module Pione
       # Evaluate the string as a PIONE expression and get the result value as model object.
       #
       # @param str [String]
-      #   a PIONE expression string
-      # @param domain_info [DomainInfo]
-      #   domain info
-      # @return [BasicModel]
-      #   the result of evaluation
-      def val!(str, domain_info=nil)
-        domain_info = load_domain_info unless domain_info
-        env = domain_info.env
+      #   a PIONE expression
+      # @param domain_dump [DomainDump]
+      #   a domain dump object
+      # @return [Object]
+      #   the evaluation value
+      def val!(str, domain_dump=nil)
+        env = domain_dump ? domain_dump.env : Lang::Environment.new
         option = {package_name: env.current_package_id, filename: "pione-eval"}
         Lang::DocumentTransformer.new.apply(
           Lang::DocumentParser.new.expr.parse(str), option
@@ -23,27 +22,14 @@ module Pione
       # Evaluate the string as a PIONE expression and get the result value as a textized string.
       #
       # @param str [String]
-      #   a PIONE expression string
-      # @param domain_info [DomainInfo]
-      #   domain info
+      #   a PIONE expression
+      # @param domain_dump [DomainDump]
+      #   a domain dump object
       # @return [String]
       #   the result of evaluation as an embeddable string
-      def val(str, domain_info=nil)
-        domain_info = load_domain_info unless domain_info
-        env = domain_info.env
-        val!(str, domain_info).call_pione_method(env, "textize", []).first.value
-      end
-
-      private
-
-      # Load default domain info file.
-      def load_domain_info
-        location = Location["./.domain.dump"]
-        if location.exist?
-          System::DomainInfo.read(location)
-        else
-          System::DomainInfo.new(Lang::Environment.new)
-        end
+      def val(str, domain_dump=nil)
+        env = domain_dump ? domain_dump.env : Lang::Environment.new
+        val!(str, domain_dump).call_pione_method(env, "textize", []).first.value
       end
     end
   end

data/lib/pione/util/package-parameters-list.rb

@@ -1,34 +1,22 @@
 module Pione
   module Util
     module PackageParametersList
-      class << self
-        # Print parameter list of the package.
-        #
-        # @param package [Package::Package]
-        #   package
-        def print(env, package_id)
-          definition = env.package_get(Lang::PackageExpr.new(package_id: package_id))
-          params = definition.param_definition.values
-          if params.size > 0
-            group = params.group_by {|param| param.type}
-            print_params_by_block("Basic Parameters", group[:basic]) if group[:basic]
-            print_params_by_block("Advanced Parameters", group[:advanced]) if group[:advanced]
-          else
-            puts "there are no user parameters in %s" % env.current_package_id
-          end
-        end
+      # Find parameters in the the package.
+      #
+      # @param env [Lang::Environment]
+      #   language environment
+      # @param package_id [String]
+      #   package ID
+      # @return [Array<Array<Lang::ParameterDefinition>>]
+      #   basic parameters and advanced parameters
+      def self.find(env, package_id)
+        # get parameters of the package
+        definition = env.package_get(Lang::PackageExpr.new(package_id: package_id))
+        params = definition.param_definition.values
 
-        private
-
-        # Print parameters by block.
-        def print_params_by_block(header, target_params)
-          unless target_params.empty?
-            puts "%s:" % header
-            target_params.each do |param|
-              puts "  %s := %s" % [param.name, param.value.textize]
-            end
-          end
-        end
+        # summarize parameters as basic and advanced
+        group = params.group_by {|param| param.type}
+        return [(group[:basic] || []), (group[:advanced] || [])]
       end
     end
   end

data/lib/pione/util/zip.rb

@@ -24,9 +24,14 @@ module Pione
               if location.directory?
                 zip.mkdir(relpath)
               else
-                entry = zip.add(relpath, location.path.to_s)
-                entry.time = ::Zip::DOSTime.at(location.mtime)
-                entry.extra.delete("UniversalTime")
+                # expand only if it exists, e.g. broken symbolinks are ignored
+                if location.exist?
+                  entry = zip.add(relpath, location.path.to_s)
+                  entry.time = ::Zip::DOSTime.at(location.mtime)
+                  entry.extra.delete("UniversalTime")
+                else
+                  Log::Debug.system("Try to archive the file at %s, but it was ignored because of broken link." % location.address)
+                end
               end
             end
           end

data/lib/pione/version.rb

@@ -1,4 +1,4 @@
 module Pione
   # version of pione
-  VERSION = "0.3.2"
+  VERSION = "0.4.0"
 end

data/lib/rootage.rb

@@ -0,0 +1,20 @@
+require 'stringio'
+require 'erb'
+require 'timeout'
+require 'logger'
+
+require 'sys/proctable'
+require 'forwardablex'
+require 'structx'
+
+require 'rootage/exception'
+require 'rootage/log'
+require 'rootage/normalizer'
+require 'rootage/core'
+require 'rootage/action'
+require 'rootage/scenario'
+require 'rootage/argument'
+require 'rootage/option'
+require 'rootage/command'
+require 'rootage/help'
+

data/lib/rootage/action.rb

@@ -0,0 +1,114 @@
+module Rootage
+  # `Action` is an item for phase. This is a really rule, this means items
+  # consist by conditions and action, so you can control firing and other
+  # conditions.
+  class Action < Item
+    # Validator for the action item, command raises error if it is false.
+    member :validator
+
+    def validate(&b)
+      self.validator = b
+    end
+  end
+
+  # `Phase` is a sequence of action items.
+  class Phase < Sequence
+    set_item_class Action
+
+    # @param [Action] the current executing action item
+    member :current_action
+    member :option, :default => lambda {Hash.new}
+
+    def initialize(name=nil)
+      super()
+      self.name = name
+    end
+
+    # Execute all actions in this phase.
+    #
+    # @param scenario [Scenario]
+    #   a scenario owned this phase
+    # @return [void]
+    def execute(scenario)
+      err = PhaseTimeoutError.new(scenario.name, name)
+
+      catch(:rootage_sequence_quit) do
+        execute_pre(scenario)
+        Timeout.timeout(option[:timeout], err) do
+          execute_main(scenario) do |item|
+            self.current_action = item
+            err.action_name = item.name
+          end
+        end
+        execute_post(scenario)
+      end
+
+      self.current_action = nil
+    end
+  end
+
+  # `ActionCollection` is a collection of actions. Action collections should
+  # extend this module.
+  module ActionCollection
+    include CollectionInterface
+    set_item_class Action
+  end
+
+  # `InitAction` is a set of actions for PIONE commands initialization.
+  module InitAction
+    extend ActionCollection
+
+    define(:signal_trap) do |item|
+      item.desc = "Initialize signal trap actions"
+
+      # explicit exit for signal INT (exit status code: failure)
+      item.process do
+        Signal.trap(:INT) do
+          Signal.trap(:INT, "DEFAULT") # restore default trap
+          cmd.abort('"%{name}" is terminated by signal INT.' % {name: cmd.name})
+        end
+      end
+
+      # implicit abortion for signal TERM (exit status code: success)
+      item.process do
+        Signal.trap(:TERM) do
+          Signal.trap(:TERM, "DEFAULT") # restore default trap
+          Log.debug('"%{name}" is terminated by signal TERM.' % {name: cmd.name})
+          cmd.terminate
+        end
+      end
+    end
+
+    define(:option) do |item|
+      item.desc = "Initialize command options"
+
+      item.process do
+        cmd.option_definition.execute(cmd)
+      end
+
+      item.exception(OptionParser::ParseError, OptionError) do |e|
+        cmd.abort(e)
+      end
+    end
+
+    define(:argument) do |item|
+      item.desc = "Initialize arguments"
+
+      item.process do
+        cmd.argument_definition.execute(cmd)
+      end
+
+      item.exception(ArgvError) do |e|
+        cmd.abort(e)
+      end
+    end
+
+    define(:program_name) do |item|
+      item.desc = "Set the program name for `ps` command"
+
+      item.process do
+        $PROGRAM_NAME = cmd.program_name
+      end
+    end
+  end
+end

data/lib/rootage/argument.rb

@@ -0,0 +1,46 @@
+module Rootage
+  # `Argument` is an argument item for command.
+  class Argument < Item
+    # Normalization type.
+    member :type
+    # Name at heading in help.
+    member :heading
+    # The message to show if the argument is missing
+    member :missing
+
+    def validate(&b)
+      self.validator = b
+    end
+  end
+
+  module ArgumentCollection
+    include CollectionInterface
+    set_item_class Argument
+  end
+
+  class ArgumentDefinition < Sequence
+    include CollectionInterface
+    set_item_class Argument
+
+    private
+
+    # Parse the argument.
+    #
+    # @param cmd [Command]
+    #   command object
+    # @return [void]
+    def execute_main(cmd)
+      list.each_with_index do |item, i|
+        if cmd.argv[i].nil?
+          if item.missing
+            raise ArgvError.new(item.missing)
+          else
+            raise ArgvError.new("The argument <%{name}> required." % {name: item.heading || item.name})
+          end
+        else
+          cmd.model[item.key] = Normalizer.normalize(item.type, cmd.argv[i])
+        end
+      end
+    end
+  end
+end

data/lib/rootage/command.rb

@@ -0,0 +1,218 @@
+module Rootage
+  # CommandContext is a context used for action.
+  class CommandContext < ProcessContext
+    alias :cmd :scenario
+
+    # Stop the item.
+    def stop
+      throw :rootage_stop_item, false
+    end
+
+    # quite the sequecen.
+    def quit
+      throw :rootage_quit_sequence, false
+    end
+  end
+
+  # CommandPhase is a phase for command. Action items is this phase use CommandContext.
+  class CommandPhase < Phase; end
+
+  # Command is a scenario that has subcommands, options and arguments.
+  class Command < Scenario
+    define(:phase_class, CommandPhase)
+    define(:process_context_class, CommandContext)
+
+    # initial settings
+    @subcommand = Hash.new
+    @argument_definition = ArgumentDefinition.new
+    @option_definition = OptionDefinition.new
+
+    class << self
+      attr_accessor :subcommand
+      attr_accessor :argument_definition
+      attr_accessor :option_definition
+
+      def inherited(subclass)
+        super
+
+        subclass.subcommand = @subcommand.clone
+        subclass.argument_definition = @argument_definition.copy
+        subclass.option_definition = @option_definition.copy
+      end
+
+      forward :@argument_definition, :use     , :argument
+      forward :@argument_definition, :pre     , :argument_pre
+      forward :@argument_definition, :post    , :argument_post
+      forward :@argument_definition, :append  , :append_argument
+      forward :@argument_definition, :preppend, :preppend_argument
+      forward :@argument_definition, :item    , :argument_item
+
+      forward :@option_definition  , :use , :option
+      forward :@option_definition  , :pre , :option_pre
+      forward :@option_definition  , :post, :option_post
+      forward :@option_definition  , :item, :option_item
+
+      # Define an action to phase "init".
+      def init(action, &b)
+        define_action(:init, action, &b)
+      end
+
+      # Return true if the command is on toplevel.
+      #
+      # @return [Boolean]
+      #   true if the command is on toplevel
+      def toplevel?
+        @info.has_key?(:toplevel) ? @info[:toplevel] : false
+      end
+
+      # Define a subcommand.
+      #
+      # @param name [String]
+      #   subcommand name
+      # @param subcommand [Class]
+      #   subcommand class
+      def define_subcommand(name, subcommand)
+        @subcommand[name] = subcommand
+      end
+
+      # Return true if the command has subcommands.
+      #
+      # @return [Boolean]
+      #   true if the command has subcommands
+      def has_subcommands?
+        not(@subcommand.values.compact.empty?)
+      end
+    end
+
+    # initial phase
+    define_phase(:init) do |seq|
+      seq << InitAction.signal_trap
+      seq << InitAction.option
+      seq << InitAction.argument
+      seq << InitAction.program_name
+    end
+
+    forward! :class, :subcommand, :has_subcommands?
+
+    attr_reader :argv
+    attr_reader :option_definition
+    attr_reader :argument_definition
+
+    def initialize(*args)
+      super
+      @argv = args[0].clone
+      @parent_name = args[1]
+      @argument_definition = self.class.argument_definition.copy
+      @option_definition = self.class.option_definition.copy
+    end
+
+    def scenario_name
+      if @parent_name
+        "%s %s" % [@parent_name, super]
+      else
+        super
+      end
+    end
+    alias :name :scenario_name
+
+    def <<(object)
+      case object
+      when Argument
+        argument_definition << object
+      when Option
+        option_definition << object
+      else
+        super
+      end
+    end
+
+    # Run a lifecycle of the command.
+    #
+    # @return [void]
+    def run
+      load_requirements
+      if has_subcommands?
+        execute_subcommand
+      end
+      execute_phases
+      exit
+    end
+
+    # Exit running command and return the status.
+    def exit
+      super
+      Kernel.exit(exit_status)
+    end
+
+    def program_name
+      scenario_name
+    end
+
+    private
+
+    def enter_phase(phase_name)
+      Timeout.timeout(phase(phase_name).config[:timeout]) do
+        super
+      end
+    rescue PhaseTimeoutError => e
+      abort(e)
+    end
+
+    # Execute subcommand.
+    def execute_subcommand
+      if subcommand_name = argv.first
+        if subcommand.has_key?(subcommand_name)
+          # run the subcommand
+          return subcommand[subcommand_name].run(argv.drop(1), scenario_name)
+        else
+          unless subcommand_name[0] == "-"
+            abort("There is no such subcommand: %{name}" % {name: subcommand_name})
+          end
+        end
+      else
+        abort('"%{name}" requires a subcommand name.' % {name: scenario_name})
+      end
+    end
+  end
+
+  # StandardCommand provides 4 phase command scenario. These phases are "init",
+  # "setup", "execution", and "termination".
+  class StandardCommand < Command
+    # standard phases
+    define_phase :setup
+    define_phase :execution
+    define_phase :termination
+
+    class << self
+      # Define an action to phase "setup".
+      def setup(action, &b)
+        define_action(:setup, action, &b)
+      end
+
+      # Define an action to phase "execution".
+      def execution(action, &b)
+        define_action(:execution, action, &b)
+      end
+
+      # Define an action to phase "termination".
+      def termination(action, &b)
+        define_action(:termination, action, &b)
+      end
+    end
+
+    # Terminate the command. Note that this enters in termination phase first,
+    # and command exit.
+    def terminate
+      enter_phase(:termination)
+      self.exit # end with status code
+    end
+
+    private
+
+    def abort_process
+      unless current_phase == :termination
+        enter_phase(:termination)
+      end
+    end
+  end
+end