pione 0.3.2 → 0.4.0

data/lib/pione/command/pione-package-add.rb

@@ -0,0 +1,137 @@
+module Pione
+  module Command
+    # `PionePackageAdd` is a subcommand that adds PIONE package to package
+    # database in your system.
+    class PionePackageAdd < BasicCommand
+      #
+      # informations
+      #
+
+      define(:name, "add")
+      define(:desc, "Add the package to package database")
+
+      #
+      # arguments
+      #
+
+      argument(:target) do |item|
+        item.type = :location
+        item.desc = "the package to add in package database"
+        item.missing = "There are no PIONE documents or packages."
+      end
+
+      #
+      # options
+      #
+
+      option(:tag) do |item|
+        item.type = :string
+        item.long = "--tag"
+        item.arg  = "NAME"
+        item.desc = "Specify tag name"
+      end
+
+      #
+      # command lifecycle: setup phase
+      #
+
+      phase(:setup) do |seq|
+        seq << :handler
+        seq << :db
+      end
+
+      setup(:handler) do |item|
+        item.desc = "Create a package handler and get informations"
+
+        # create a package handler
+        item.assign(:handler) do
+          Package::PackageReader.read(model[:target])
+        end
+
+        # get package name
+        item.assign(:name) do
+          model[:handler].info.name
+        end
+
+        # get package editor
+        item.assign(:editor) do
+          model[:handler].info.editor
+        end
+
+        # get package tag
+        item.assign(:tag) do
+          test(not(model[:tag]))
+          model[:handler].info.tag
+        end
+
+        # get package digest
+        item.assign(:digest) do
+          model[:handler].digest
+        end
+      end
+
+      setup(:db) do |item|
+        item.desc = "Setup package database"
+
+        item.assign(:db) do
+          Package::Database.load
+        end
+      end
+
+      #
+      # command lifecycle: execution phase
+      #
+
+      phase(:execution) do |seq|
+        seq << :add_package
+        seq << :show
+      end
+
+      execution(:add_package) do |item|
+        item.desc = "Add the package to package database"
+
+        item.process do
+          model[:db].add(
+            name:   model[:name],
+            editor: model[:editor],
+            tag:    model[:tag],
+            digest: model[:digest]
+          )
+          model[:db].save
+        end
+      end
+
+      execution(:show) do |item|
+        item.desc = "Show the result"
+
+        item.assign(:additions) do
+          Array.new
+        end
+
+        item.process do
+          test(model[:editor])
+          model[:additions] << "editor: %s" % model[:editor]
+        end
+
+        item.process do
+          test(model[:tag])
+          model[:additions] << "tag: %s" % model[:tag]
+        end
+
+        item.assign(:info) do
+          model[:additions].size > 0 ? "(" + model[:additions].join(", ") + ")" : ""
+        end
+
+        # show log
+        item.process do
+          arg = {name: model[:name], info: model[:info]}
+          Log::SystemLog.info(
+            'Package "%{name}"%{info} was added to package database' % arg
+          )
+        end
+      end
+    end
+
+    PionePackage.define_subcommand("add", PionePackageAdd)
+  end
+end

data/lib/pione/command/pione-package-build.rb

@@ -0,0 +1,122 @@
+module Pione
+  module Command
+    # `PionePackageBuild` is a subcommand that builds PIONE archive package.
+    class PionePackageBuild < BasicCommand
+      #
+      # informations
+      #
+
+      define(:name, "build")
+      define(:desc, "Build PIONE archive package")
+
+      #
+      # arguments
+      #
+
+      argument(:source) do |item|
+        item.type = :location
+        item.desc = "the source package location"
+        item.missing = "There are no PIONE documents or packages."
+      end
+
+      #
+      # options
+      #
+
+      option CommonOption.color
+      option CommonOption.debug
+
+      option(:output) do |item|
+        item.type  = :location
+        item.short = "-o"
+        item.long  = "--output"
+        item.arg   = "LOCATION"
+        item.desc  = "Output file or directory location"
+        item.init  = "./"
+      end
+
+      option(:tag) do |item|
+        item.type = :string
+        item.long = "--tag"
+        item.arg  = "NAME"
+        item.desc = "Specify tag name"
+      end
+
+      option(:hash_id) do |item|
+        item.type = :string
+        item.long = "--hash-id"
+        item.arg  = "HASH"
+        item.desc = "Specify git hash ID"
+      end
+
+      option_post(:check_output_directory) do |item|
+        item.desc = "Check output location is directory"
+
+        item.process do
+          test(not(model[:output].directory?))
+          cmd.abort("Output location should be a directory: %s" % model[:output])
+        end
+      end
+
+      #
+      # command lifecycle: setup phase
+      #
+
+      phase(:setup) do |seq|
+        seq << :source_locations
+      end
+
+      setup(:source_locations) do |item|
+        item.desc = "Setup source locations"
+
+        item.assign(:source_locations) do
+          source = model[:source].address
+          [Location[git: source], Location[data: source]]
+        end
+      end
+
+      #
+      # command lifecycle: execution phase
+      #
+
+      phase(:execution) do |seq|
+        seq << :build_package
+      end
+
+      execution(:build_package) do |item|
+        item.desc = "Build a PPG package"
+
+        item.process do
+          model[:source_locations].each do |location|
+            if ppg = try_to_archive(location)
+              Log::SystemLog.info("Package build suceeded: %s" % ppg.address)
+              cmd.terminate
+            end
+          end
+
+          cmd.abort("Package build has failed to archive.")
+        end
+      end
+    end
+
+    # `PionePackageBuildContext` is a context for `pione package build`.
+    class PionePackageBuildContext < Rootage::CommandContext
+      def try_to_archive(location)
+        handler = Package::PackageReader.read(location)
+        cache_location = Package::PackageCache.directory_cache(handler.digest)
+
+        # make archiver
+        archiver = Package::PackageArchiver.new(cache_location)
+
+        # archive
+        return archiver.archive(model[:output], false)
+      rescue => e
+        Log::Debug.system("PIONE failed to archive %s: %s" % [location, e.message])
+      end
+    end
+
+    PionePackageBuild.define(:process_context_class, PionePackageBuildContext)
+
+    PionePackage.define_subcommand("build", PionePackageBuild)
+  end
+end

data/lib/pione/command/pione-package-show.rb

@@ -0,0 +1,96 @@
+module Pione
+  module Command
+    class PionePackageShow < BasicCommand
+      #
+      # informations
+      #
+
+      define(:name, "show")
+      define(:desc, "Show the package informations")
+
+      #
+      # arguments
+      #
+
+      argument(:location) do |item|
+        item.type    = :location
+        item.desc    = "the package location that you want to show"
+        item.missing = "There are no PIONE documents or packages."
+      end
+
+      #
+      # options
+      #
+
+      option CommonOption.color
+      option CommonOption.debug
+
+      option(:advanced) do |item|
+        item.type  = :boolean
+        item.short = "-a"
+        item.long  = "--advanced"
+        item.desc  = "show advanced parameters"
+      end
+
+      #
+      # command lifecycle: execution phase
+      #
+
+      phase(:execution) do |seq|
+        seq << :print_list
+      end
+
+      execution(:print_list) do |item|
+        item.desc = "Print a list of parameters in the document"
+
+        item.process do
+          # read package
+          package_handler = Package::PackageReader.read(model[:location])
+          env = package_handler.eval(Lang::Environment.new)
+
+          # print a list
+          basic, advanced = Util::PackageParametersList.find(env, env.current_package_id)
+          if basic.empty? and advanced.empty?
+            puts "there are no user parameters in %s" % env.current_package_id
+          else
+            if not(basic.empty?)
+              print_by_block("Basic Parameters", basic, env)
+            end
+            if not(advanced.empty?) and model[:advanced]
+              print_by_block("Advanced Parameters", advanced, env)
+            end
+          end
+        end
+
+        item.exception(Package::InvalidPackage) do |e|
+          cmd.abort("Package error: " + e.message)
+        end
+
+        item.exception(Lang::ParserError) do |e|
+          cmd.abort("Pione syntax error: " + e.message)
+        end
+
+        item.exception(Lang::LangError) do |e|
+          cmd.abort("Pione language error: %s(%s)" % [e.message, e.class.name])
+        end
+      end
+    end
+
+    # `PionePackageShowContext` is a context for `pione package show`.
+    class PionePackageShowContext < Rootage::CommandContext
+      # Print parameters by block.
+      def print_by_block(header, params, env)
+        unless params.empty?
+          puts "%s:" % header
+          params.each do |param|
+            puts "  %s := %s" % [param.name, param.value.eval(env).textize]
+          end
+        end
+      end
+    end
+
+    PionePackageShow.define(:process_context_class, PionePackageShowContext)
+
+    PionePackage.define_subcommand("show", PionePackageShow)
+  end
+end

data/lib/pione/command/pione-package-update.rb

@@ -0,0 +1,59 @@
+module Pione
+  module Command
+    # `PionePackageUpdate` is a subcommand that updates PIONE package.
+    class PionePackageUpdate < BasicCommand
+      #
+      # informations
+      #
+
+      define(:name, "update")
+      define(:desc, "Update the package to package database")
+
+      #
+      # arguments
+      #
+
+      argument(:location) do |item|
+        item.type    = :location
+        item.desc    = "the package location that you want to update"
+        item.missing = "There are no PIONE documents or packages."
+      end
+
+      #
+      # options
+      #
+
+      option CommonOption.color
+      option CommonOption.debug
+
+      option(:force) do |item|
+        item.type    = :boolean
+        item.long    = "--force"
+        item.desc    = "update pacakge info files"
+        item.default = true
+      end
+
+      #
+      # command lifecycle: execution phase
+      #
+
+      phase(:execution) do |seq|
+        seq << :update
+      end
+
+      execution(:update) do |item|
+        item.desc = "Update update info files"
+
+        item.process do
+          Package::PackageHandler.write_info_files(model[:location], force: model[:force])
+        end
+
+        item.exception(Package::InvalidScenario) do |e|
+          cmd.abort(e)
+        end
+      end
+    end
+
+    PionePackage.define_subcommand("update", PionePackageUpdate)
+  end
+end

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

@@ -1,152 +1,24 @@
 module Pione
   module Command
-    # PionePackage is a command body of "pione-package".
+    # `PionePackage` is a subcommand that provides package utility tools.
     class PionePackage < BasicCommand
       #
-      # basic informations
+      # informations
       #
 
-      command_name "pione-package"
-      command_banner "PIONE package utility."
+      define(:name, "package")
+      define(:desc, "PIONE package utility")
 
       #
-      # options
+      # requirements
       #
 
-      use_option :color
-      use_option :debug
-
-      option_default :output, Location["./"]
-
-      define_option(:add) do |item|
-        item.long = '--add'
-        item.desc = 'add the package to package database'
-        item.action = lambda do |_, option, location|
-          option[:action_mode] = :add
-        end
-      end
-
-      define_option(:build) do |item|
-        item.long = '--build'
-        item.desc = 'build PIONE archive file(*.ppg)'
-        item.action = lambda do |_, option, location|
-          option[:action_mode] = :build
-        end
-      end
-
-      define_option(:write_info) do |item|
-        item.long = '--write-info'
-        item.desc = 'write package and scenario info files'
-        item.action = lambda do |_, option, location|
-          option[:action_mode] = :write_info
-        end
-      end
-
-      define_option(:output) do |item|
-        item.short = "-o"
-        item.long = "--output=LOCATION"
-        item.desc = "output file or directory location"
-        item.value = lambda {|val| Location[val]}
-      end
-
-      define_option(:tag) do |item|
-        item.long = "--tag=NAME"
-        item.desc = "specify tag name"
-        item.value = :as_is
-      end
-
-      define_option(:hash_id) do |item|
-        item.long = "--hash-id=HASH"
-        item.desc = "specify git hash id"
-        item.value = :as_is
-      end
-
-      validate_option do |option|
-        unless option[:output].directory?
-          abort("output location should be a directory: %s" % option[:output])
-        end
-      end
-
-      #
-      # command lifecycle: setup phase
-      #
-
-      setup :target
-
-      # Check archiver target location.
-      def setup_target
-        abort("There are no PIONE documents or packages.")  if @argv.first.nil?
-        @target = @argv.first
-      end
-
-      #
-      # command lifecycle: execution phase
-      #
-
-      execute :add => :add_package
-
-      # Add the package to package database.
-      def execute_add_package
-        handler = Package::PackageReader.read(Location[@target])
-        tag = option[:tag] || handler.info.tag
-        db = Package::Database.load
-        db.add(name: handler.info.name, editor: handler.info.editor, tag: tag, digest: handler.digest)
-        db.save
-
-        # show log
-        args = []
-        args << "editor: " + handler.info.editor if handler.info.editor
-        args << "tag: " + handler.info.tag if handler.info.tag
-        _args = args.size > 0 ? "(" + args.join(", ") + ")" : ""
-        Log::SystemLog.info(
-          "package \"%s\"%s was added to package database" % [handler.info.name, _args]
-        )
-      end
-
-      execute :build => :build_package
-
-      # Build a PPG package.
-      def execute_build_package
-        if ppg = try_to_archive(Location[git: @target], Location[data: @target])
-          Log::SystemLog.info("pione-package suceeded to build %s" % ppg.address)
-        else
-          abort("pione-package faild to archive.")
-        end
-      end
-
-      execute :write_info => :write_info
-
-      # Update update info files.
-      def execute_write_info
-        Package::PackageHandler.write_info_files(Location[@target])
-      rescue Package::InvalidScenario => e
-        abort(e.message)
-      end
-
-      #
-      # helper methods
-      #
-
-      private
-
-      def try_to_archive(*locations)
-        locations.each do |location|
-          begin
-            handler = Package::PackageReader.read(location)
-            cache_location = Package::PackageCache.directory_cache(handler.digest)
-
-            # make archiver
-            archiver = Package::PackageArchiver.new(cache_location)
-
-            # archive
-            return archiver.archive(option[:output], false)
-          rescue => e
-            p e
-            Log::Debug.system("pione-package failed to archive %s: %s" % [location, e.message])
-          end
-        end
-        return false
-      end
+      require 'pione/command/pione-package-add'
+      require 'pione/command/pione-package-build'
+      require 'pione/command/pione-package-show'
+      require 'pione/command/pione-package-update'
     end
+
+    PioneCommand.define_subcommand("package", PionePackage)
   end
 end