pione 0.3.2 → 0.4.0

data/lib/pione/command/pione-action-exec.rb

@@ -0,0 +1,85 @@
+module Pione
+  module Command
+    # PioneActionExec is a command that executes action from outside of rule
+    # engine.
+    class PioneActionExec < BasicCommand
+      #
+      # command informations
+      #
+
+      define(:name, "exec")
+      define(:desc, "Execute an action rule in literate action document")
+
+      #
+      # arguments
+      #
+
+      argument(:location) do |item|
+        item.type    = :location
+        item.desc    = "Location of action document"
+        item.missing = "There are no action documents or packages."
+      end
+
+      argument(:name) do |item|
+        item.type    = :string
+        item.desc    = "Action name"
+        item.missing = "There is no action name."
+      end
+
+      #
+      # options
+      #
+
+      option CommonOption.color
+      option CommonOption.debug
+
+      option(:domain_dump) do |item|
+        item.type = :location
+        item.long = "--domain-dump"
+        item.arg  = "LOCATION"
+        item.desc = "Load the domain dump file"
+      end
+
+      option(:directory) do |item|
+        item.type  = :location
+        item.short = "-d"
+        item.long  = "--directory PATH"
+        item.desc  = "execute in the PATH"
+      end
+
+      #
+      # command lifecycle: setup phase
+      #
+
+      phase(:setup) do |item|
+        item << CommonAction.load_domain_dump
+      end
+
+      #
+      # command lifecycle: execution phase
+      #
+
+      phase(:execution) do |item|
+        item << :exec
+      end
+
+      execution(:exec) do |item|
+        item.desc = "Update pacakge info files"
+
+        item.process do
+          if action = LiterateAction::Document.load(model[:location]).find(model[:name])
+            action.execute(model[:domain_info], model[:directory])
+          else
+            cmd.abort("The action not found.")
+          end
+        end
+
+        item.exception(Location::NotFound) do |e|
+          cmd.abort(e)
+        end
+      end
+    end
+
+    PioneAction.define_subcommand("exec", PioneActionExec)
+  end
+end

data/lib/pione/command/pione-action-list.rb

@@ -7,43 +7,67 @@ module Pione
       # basic informations
       #
 
-      command_name "pione action:list"
-      command_banner "show list of action names in document"
-      PioneCommand.add_subcommand("action:list", self)
+      define(:name, "list")
+      define(:desc, "List action names in document")
 
       #
-      # options
+      # arguments
       #
 
-      use_option :color
+      argument(:location) do |item|
+        item.type    = :location
+        item.desc    = "Location of literate action document"
+        item.missing = "There is no action document."
+      end
 
       #
-      # command lifecycle: setup phase
+      # options
       #
 
-      setup :target
+      option CommonOption.color
 
-      # Setup location of literate action document and action name.
-      def setup_target
-        abort("There are no literate action documents or packages.")  if @argv[0].nil?
-        @location = Location[@argv[0]]
+      option(:compact) do |item|
+        item.type    = :boolean
+        item.long    = "--compact"
+        item.desc    = "one-line list"
+        item.default = false
       end
 
       #
       # command lifecycle: execution phase
       #
 
-      execute :show_list
+      phase(:execution) do |item|
+        item << :get_names
+        item << :show_list
+      end
+
+      execution(:get_names) do |item|
+        item.desc = "Get all action names"
+
+        item.assign(:names) do
+          LiterateAction::Document.load(model[:location]).action_names.sort
+        end
+
+        item.process do
+          test(model[:names].empty?)
+          cmd.abort("There are no action names in %{location}" % {location: model[:location]})
+        end
+      end
+
+      execution(:show_list) do |item|
+        item.desc = "Show list of action names"
 
-      # Show list of action names.
-      def execute_show_list
-        names = LiterateAction::Document.load(@location).action_names.sort
-        if names.empty?
-          abort("no action names in %s" % @location.address)
-        else
-          names.each {|name| puts name}
+        item.process do
+          if model[:compact]
+            puts model[:names].join(" ")
+          else
+            model[:names].each {|name| puts name}
+          end
         end
       end
     end
+
+    PioneAction.define_subcommand("list", PioneActionList)
   end
 end

data/lib/pione/command/pione-action-print.rb

@@ -0,0 +1,79 @@
+module Pione
+  module Command
+    # `PioneActionPrint` is a command that prints action contents.
+    class PioneActionPrint < BasicCommand
+      #
+      # basic informations
+      #
+
+      define(:name, "print")
+      define(:desc, "Print action contents")
+
+      #
+      # arguments
+      #
+
+      argument(:location) do |item|
+        item.type    = :location
+        item.missing = "There are no action documents or packages."
+      end
+
+      argument(:name) do |item|
+        item.type    = :string
+        item.missing = "There is no action name."
+      end
+
+      #
+      # options
+      #
+
+      option CommonOption.color
+      option CommonOption.debug
+      option CommonOption.domain_dump_location
+
+      #
+      # command lifecycle: setup phase
+      #
+
+      phase(:setup) do |seq|
+        seq << CommonAction.load_domain_dump
+      end
+
+      #
+      # command lifecycle: execution phase
+      #
+
+      phase(:execution) do |seq|
+        seq << :find_action
+        seq << :print
+      end
+
+      execution(:find_action) do |item|
+        item.desc = "Find the action from the document"
+
+        item.assign(:action) do
+          LiterateAction::Document.load(model[:location]).find(model[:name])
+        end
+
+        item.process do
+          test(not(model[:action]))
+          cmd.abort("Action not found.")
+        end
+
+        item.exception(Location::NotFound) do |e|
+          cmd.abort(e)
+        end
+      end
+
+      execution(:print) do |item|
+        item.desc = "Print the action contents"
+
+        item.process do
+          puts model[:action].textize(model[:domain_dump])
+        end
+      end
+    end
+
+    PioneAction.define_subcommand("print", PioneActionPrint)
+  end
+end

data/lib/pione/command/pione-action.rb

@@ -7,77 +7,18 @@ module Pione
       # basic informations
       #
 
-      command_name "pione action"
-      command_banner "execute an action in literate action document"
-      PioneCommand.add_subcommand("action", self)
+      define(:name, "action")
+      define(:desc, "execute an action in literate action document")
 
       #
-      # options
+      # subcommands
       #
 
-      use_option :color
-      use_option :debug
-
-      define_option(:domain) do |item|
-        item.long = "--domain"
-        item.desc = "use the domain information file"
-        item.default = Location["./domain.dump"]
-        item.value = lambda {|b| b}
-      end
-
-      define_option(:show) do |item|
-        item.long = "--show"
-        item.desc = "show the action without execution"
-        item.value = lambda {|b| b}
-      end
-
-      define_option(:directory) do |item|
-        item.short = "-d"
-        item.long = "--directory PATH"
-        item.desc = "execute in the PATH"
-        item.value = lambda {|b| Location[b]}
-      end
-
-      #
-      # command lifecycle: setup phase
-      #
-
-      setup :target
-      setup :domain
-
-      # Setup location of literate action document and action name.
-      def setup_target
-        abort("There are no literate action documents or packages.")  if @argv[0].nil?
-        abort("Action name is needed.") if @argv[1].nil?
-        @location = Location[@argv[0]]
-        @name = @argv[1]
-      end
-
-      # Load a domain information file.
-      def setup_domain
-        if option[:domain].exist?
-          @domain_info = System::DomainInfo.read(option[:domain])
-        end
-      end
-
-      #
-      # command lifecycle: execution phase
-      #
-
-      execute :exec
-
-      # Update pacakge info files.
-      def execute_exec
-        if action = LiterateAction::Document.load(@location).find(@name)
-          if option[:show]
-            puts action.textize(@domain_info)
-          else
-            action.execute(@domain_info, option[:directory])
-          end
-        else
-          abort(e.message)
-        end
-      end
+      require 'pione/command/pione-action-exec'
+      require 'pione/command/pione-action-list'
+      require 'pione/command/pione-action-print'
     end
+
+    PioneCommand.define_subcommand("action", PioneAction)
   end
 end

data/lib/pione/command/pione-clean.rb

@@ -7,78 +7,81 @@ module Pione
       # basic informations
       #
 
-      command_name "pione-clean"
-      command_banner "remove PIONE's temporary files, cache, and etc."
-      PioneCommand.add_subcommand("clean", self)
+      define(:name, "pione-clean")
+      define(:desc, "Remove PIONE's temporary files, cache, and etc")
 
       #
       # options
       #
 
-      use_option :debug
+      option CommonOption.debug
 
-      # --older option
-      define_option(:older) do |item|
-        item.long = '--older=DATE'
+      option(:older) do |item|
+        item.type = :string
+        item.long = '--older'
+        item.arg  = 'DATE'
         item.desc = 'remove file older than the date'
-        item.default = false
-        item.value = proc do |str|
-          begin
-            Date.iso8601(str)
-          rescue ArgumentError
-            begin
-              Date.today - str.to_i
-            rescue
-              abort("invalid value of older option: %s" % str)
-            end
-          end
-        end
       end
 
-      # --type option
-      define_option(:type) do |item|
-        item.long = '--type=NAME'
+      option(:type) do |item|
+        item.type = :string
+        item.range = ["all", "temporary", "file-cache", "package-cache", "profile"]
+        item.long = '--type NAME'
         item.desc = 'remove only files of the type'
-        item.default = false
-        item.value = proc do |name|
-          case name
-          when "temporary"
-            :temporary
-          when "file-cache"
-            :file_cache
-          when "package-cache"
-            :package_cache
-          when "profile"
-            :profile
-          else
-            abort("unknown type: %s" % str)
-          end
-        end
+        item.init = "all"
       end
 
       #
       # command lifecycle: setup phase
       #
 
-      setup :package_database
+      phase(:setup) do |item|
+        item << :older_date
+        item << :package_database
+      end
+
+      setup(:older_date) do |item|
+        item.desc = "Setup older date"
 
-      def setup_package_database
-        @db = Package::Database.load
+        item.assign(:older) do
+          Rootage::Normalizer.normalize(:date, model[:older])
+        end
+
+        item.exception do |e|
+          begin
+            model[:older] = Date.today - model[:older].to_i
+          rescue
+            cmd.abort("invalid value of older option: %s" % str)
+          end
+        end
+      end
+
+      setup(:package_database) do |item|
+        item.desc = "Load pakcage database"
+
+        item.assign(:db) do
+          Package::Database.load
+        end
       end
 
       #
       # command lifecycle: execution phase
       #
 
-      execute :remove_temporary
-      execute :remove_file_cache
-      execute :remove_package_cache
-      execute :remove_profile
+      phase(:execution) do |item|
+        item << :remove_temporary
+        item << :remove_file_cache
+        item << :remove_package_cache
+        item << :remove_profile
+      end
+
+      # This removes working files based on temporary directory's mtime.
+      execution(:remove_temporary) do |item|
+        item.desc = "Remove temporary files"
+
+        item.process do
+          test(type?("temprary"))
 
-      # Remove temporary files. This removes working files based on temporary
-      # directory's mtime.
-      def execute_remove_temporary
-        if type?(:temprary)
           Location[Global.my_temporary_directory].each_entry do |entry|
             if delete?(entry)
               FileUtils.remove_entry_secure(entry.path)
@@ -87,9 +90,13 @@ module Pione
         end
       end
 
-      # Remove file cache files. This removes it base on cache directory's mtime.
-      def execute_remove_file_cache
-        if type?(:file_cache)
+      # This removes file caches base on cache directory's mtime.
+      execution(:remove_file_cache) do |item|
+        item.desc = "Remove file cache files"
+
+        item.process do
+          test(type?("file-cache"))
+
           Location[Global.my_file_cache_directory].each_entry do |entry|
             if delete?(entry)
               FileUtils.remove_entry_secure(entry.path)
@@ -98,21 +105,28 @@ module Pione
         end
       end
 
-      # Remove package cache files.
-      def execute_remove_package_cache
-        if type?(:package_cache)
-          # remove PPG package
+      execution(:remove_package_cache) do |item|
+        item.desc = "Remove package cache files"
+
+        item.condition do
+          test(type?("package-cache"))
+        end
+
+        # remove PPG packages
+        item.process do
           Global.ppg_package_cache_directory.each_entry do |entry|
-            unless @db.has_digest?(Package::PackageFilename.parse(entry.basename).digest)
+            unless model[:db].has_digest?(Package::PackageFilename.parse(entry.basename).digest)
               if delete?(entry)
                 entry.delete
               end
             end
           end
+        end
 
-          # remove directory package
+        # remove directory packages
+        item.process do
           Global.directory_package_cache_directory.each_entry do |entry|
-            unless @db.has_digest?(entry.basename)
+            unless model[:db].has_digest?(entry.basename)
               if delete?(entry)
                 entry.delete
               end
@@ -121,9 +135,12 @@ module Pione
         end
       end
 
-      # Remove profile reports.
-      def execute_remove_profile
-        if type?(:profile)
+      execution(:remove_profile) do |item|
+        item.desc = "Remove profile reports"
+
+        item.process do
+          test(type?("profile"))
+
           Location[Global.profile_report_directory].each_entry do |entry|
             if delete?(entry)
               entry.delete
@@ -131,20 +148,23 @@ module Pione
           end
         end
       end
+    end
 
-      #
-      # helper methods
-      #
-
-      # Return true if the entry has the type.
+    # `PioneCleanContext` is a process context for `pione-clean-context`.
+    class PioneCleanContext < Rootage::CommandContext
+      # Return true if the type is matched.
       def type?(type)
-        option[:type].nil? or option[:type] == type
+        model[:type] == "all" or model[:type] == type
       end
 
       # Return true if the entry should be removed.
       def delete?(entry)
-        option[:older].nil? or option[:older] >= entry.mtime.to_date
+        not(entry.exist?) or model[:older].nil? or model[:older] >= entry.mtime.to_date
       end
     end
+
+    PioneClean.define(:process_context_class, PioneCleanContext)
+
+    PioneCommand.define_subcommand("clean", PioneClean)
   end
 end