pione 0.2.1 → 0.2.2

data/lib/pione/component.rb

@@ -6,3 +6,8 @@ end
 require 'pione/component/rule'
 require 'pione/component/document'
 require 'pione/component/package'
+require 'pione/component/package-filename'
+require 'pione/component/package-reader'
+require 'pione/component/package-archiver'
+require 'pione/component/package-expander'
+

data/lib/pione/component/document.rb

@@ -12,15 +12,31 @@ module Pione
 
     class Document < StructX
       class << self
-        # Load a PIONE rule document.
+        # Load a PIONE rule document as file.
         #
-        # @param location [Location,String]
+        # @param location [BasicLocation]
         #   location of the PIONE document
+        # @param package_name [String]
+        #   package name
+        # @param package_path [String]
+        #   relative path of the document in package
         # @return [Component::Document]
         #   the document
-        def load(src, package_name="Main")
-          src = src.read if src.kind_of?(Location::BasicLocation)
+        def load(src, package_name="Main", package_path="Unknown.pione")
+          parse(src.read, package_name, package_path)
+        end
 
+        # Parse a PIONE rule document as string.
+        #
+        # @param location [String]
+        #   PIONE document
+        # @param package_name [String]
+        #   package name
+        # @param path [String]
+        #   relative path of the document
+        # @return [Component::Document]
+        #   the document as Ruby object
+        def parse(src, package_name="Main", package_path="Unknown.pione")
           # parse the document and build the model
           parser = Parser::DocumentParser.new
           transformer = Transformer::DocumentTransformer.new(package_name)
@@ -38,13 +54,14 @@ module Pione
           # set document parameters into rules
           rules.each {|rule| rule.condition.params.merge!(params)}
 
-          return new(package_name, rules, params)
+          return new(package_name, rules, params, package_path)
         end
       end
 
       member :package_name
       member :rules
       member :params
+      member :package_path
 
       # Find the named rule.
       #

data/lib/pione/component/package-archiver.rb

@@ -0,0 +1,92 @@
+module Pione
+  module Component
+    # PackageArchiver makes PPG file as PIONE archive.
+    class PackageArchiver
+      attr_reader :location
+
+      # @param location [BasicLoaction]
+      #   the location of package
+      def initialize(location, option={})
+        if location.location_type == :git_repository
+          location = location + option
+        end
+        @package = PackageReader.read(location)
+        @location = @package.location
+        @tag = option[:tag]
+        @branch = option[:branch]
+      end
+
+      # Create a package archive file.
+      #
+      # @param output_location [BasicLocation]
+      #   the location of output directory
+      def archive(output_location)
+        output = output_location + filename
+        path = Temppath.create
+        Zip::Archive.open(path.to_s, Zip::CREATE) do |ar|
+          archive_package_info(ar)
+          archive_documents(ar)
+          archive_scenarios(ar)
+        end
+        Location[path].copy(output)
+        return output
+      end
+
+      private
+
+      def filename
+        PackageFilename.new(
+          package_name: @package.name,
+          edition: @package.edition,
+          tag: @tag || @branch || @package.tag,
+          hash_id: @package.hash_id
+        ).to_s
+      end
+
+      def archive_package_info(ar)
+        ar.add_buffer("package.yml", (@location + "package.yml").read)
+      end
+
+      def archive_documents(ar)
+        @package.documents.each do |doc|
+          ar.add_buffer(doc.package_path, (@location + doc.package_path).read)
+        end
+      end
+
+      def archive_scenarios(ar)
+        @package.scenarios.each do |scenario|
+          ar.add_dir(scenario.package_path)
+          archive_scenario_info(ar, scenario)
+          archive_scenario_inputs(ar, scenario)
+          archive_scenario_outputs(ar, scenario)
+        end
+      end
+
+      def archive_scenario_info(ar, scenario)
+        package_path = File.join(scenario.package_path, "scenario.yml")
+        location = @location + scenario.package_path + "scenario.yml"
+        ar.add_buffer(package_path, location.read)
+      end
+
+      def archive_scenario_inputs(ar, scenario)
+        if not(scenario.inputs.empty?)
+          ar.add_dir(File.join(scenario.package_path, "input"))
+          scenario.inputs.each do |input|
+            package_path = File.join(scenario.package_path, "input", input.basename)
+            ar.add_buffer(package_path, input.read)
+          end
+        end
+      end
+
+      def archive_scenario_outputs(ar, scenario)
+        if not(scenario.outputs.empty?)
+          ar.add_dir(File.join(scenario.package_path, "output"))
+         scenario.outputs.each do |output|
+            package_path = File.join(scenario.package_path, "output", output.basename)
+            ar.add_buffer(package_path, output.read)
+          end
+        end
+      end
+    end
+  end
+end

data/lib/pione/component/package-expander.rb

@@ -0,0 +1,37 @@
+module Pione
+  module Component
+    # PackageExpander expands package files from archive.
+    class PackageExpander
+      attr_reader :location
+
+      # @param location [BasicLoaction]
+      #   package location
+      def initialize(location)
+        @location = location
+      end
+
+      def expand(output)
+        location = @location.local
+
+        # expand
+        Zip::Archive.open(location.path.to_s) do |ar|
+          ar.each do |file|
+            unless file.directory?
+              (output + file.name).write(file.read)
+            end
+          end
+        end
+      end
+
+      private
+
+      def valid_filename?
+        filename = @location.basename
+        if File.extname(filename) == ".ppg"
+          identifiers = filename.split("-")
+          identifiers[1]
+        end
+      end
+    end
+  end
+end

data/lib/pione/component/package-filename.rb

@@ -0,0 +1,38 @@
+module Pione
+  module Component
+    class PackageFilenameParser < Parslet::Parser
+      root(:filename)
+
+      rule(:filename) { package_name.maybe >> edition.maybe >> tag.maybe >> hash_id.maybe >> ext }
+
+      rule(:package_name) { ((str("(") | str(".") | str("+") | str("@")).absent? >> any).repeat(1).as(:package_name) }
+      rule(:edition) { str("(") >> (str(")").absent? >> any).repeat(1).as(:edition) >> str(")") }
+      rule(:tag) { str("+") >> ((ext | str("@")).absent? >> any).repeat(1).as(:tag) }
+      rule(:hash_id) { str("@") >>  match('[0-9a-fA-F]').repeat(1).as(:hash_id) }
+      rule(:ext) { str(".ppg") }
+    end
+
+    class PackageFilename < StructX
+      member :package_name
+      member :edition, default: "origin"
+      member :tag
+      member :hash_id
+
+      class << self
+        def parse(str)
+          new(PackageFilenameParser.new.parse(str))
+        end
+      end
+
+      def to_s
+        name = ""
+        name << package_name
+        name << "(%s)" % edition if edition and edition != "origin"
+        name << "+%s" % tag if tag
+        name << "@%s" % hash_id if hash_id
+        name + ".ppg"
+      end
+    end
+  end
+end
+

data/lib/pione/component/package-reader.rb

@@ -0,0 +1,276 @@
+module Pione
+  module Component
+    module PackageTypeClassifier
+      class << self
+        # Distinguish the type of package based on the location.
+        #
+        # @param [BasicLocation]
+        #   location of the package
+        # @return [Symbol]
+        #   package type
+        def classify(location)
+          return :git if git?(location)
+          return :archive if archive?(location)
+          return :document if document?(location)
+          return :directory
+        end
+
+        private
+
+        # Return true if the location represents git package.
+        def git?(location)
+          location.location_type == :git_repository
+        end
+
+        # Return true if the location represents archive package.
+        def archive?(location)
+          location.file? and location.extname == ".ppg"
+        end
+
+        # Return true if the location represents document package.
+        def document?(location)
+          location.file? and location.extname == ".pione"
+        end
+      end
+    end
+
+    # PackageReader is a reader for packages.
+    class PackageReader
+      class << self
+        # Read a pacakge from the location.
+        #
+        # @param location [Location::BasicLocation]
+        #   location of package
+        # @return [Package]
+        #   the package
+        def read(location)
+          new(location).read
+        end
+      end
+
+      attr_reader :location
+      attr_reader :type
+
+      # @param location [BasicLocation]
+      #   package location
+      def initialize(location)
+        @location = location
+        @type = PackageTypeClassifier.classify(location)
+      end
+
+      def read
+        case @type
+        when :directory
+          read_directory
+        when :git
+          read_git
+        when :archive
+          read_archive
+        when :document
+          read_document
+        end
+      end
+
+      private
+
+      # Return the location of package information file.
+      def spec_location
+        @location + "package.yml"
+      end
+
+      # Read package directory.
+      #
+      # @return [Package]
+      #   the package
+      def read_directory
+        info = read_package_info
+        Package.new(
+          location: @location,
+          info: info,
+          bin: @location + "bin",
+          documents: find_documents(info["PackageName"], info["Documents"]),
+          scenario_paths: find_scenario_paths(info["Scenarios"])
+        )
+      end
+
+      # Read git package.
+      def read_git
+        GitPackageReader.read(@location)
+      end
+
+      # Read PIONE archive.
+      #
+      # @return [Package]
+      #   the package
+      def read_archive
+        self.class.read(ArchivePackageReader.read(@location))
+      end
+
+      # Read PIONE document.
+      #
+      # @return [Package]
+      #   the package
+      def read_document
+        info = {"PackageName" => "Main"}
+        document = Component::Document.load(@location, "Main")
+        Package.new(info: info, documents: [document])
+      end
+
+      # Read the informations from the package location.
+      #
+      # @return [Hash]
+      #   package information table
+      def read_package_info
+        YAML.load((@location + "package.yml").read)
+      rescue Location::NotFound
+        raise InvalidPackageError.new(self, "package.yml not found in %s" % @location.uri)
+      end
+
+      # Find scenarios from the package location.
+      #
+      # @return [Array<PackageScenario>]
+      #   scenarios
+      def find_scenario_paths(scenarios)
+        return [] if scenarios.nil?
+        scenarios.select do |path|
+          (@location + path + "scenario.yml").exist?
+        end.uniq.compact
+      end
+
+      # Find documents from the packcage location.
+      #
+      # @return [Array<Document>]
+      #   documents
+      def find_documents(package_name, document_names)
+        document_names.map do |name|
+          Document.load(@location + name, package_name, name)
+        end
+      end
+    end
+
+    # PackageScenarioReader is a reader for loading scenarios.
+    class PackageScenarioReader
+      # Read scenario from the location.
+      def self.read(location, package_path)
+        new(location, package_path).read
+      end
+
+      attr_reader :location
+      attr_reader :package_path
+
+      # @param location [Location]
+      #   the scenario location
+      def initialize(location, package_path)
+        @location = location
+        @package_path = package_path
+      end
+
+      # Return the location of scenario information file.
+      def info_location
+        @location + @package_path + "scenario.yml"
+      end
+
+      # Read scenario files.
+      #
+      # @return [PackageScenario]
+      #   the scenario
+      def read
+        begin
+          info = read_scenario_informations
+          PackageScenario.new(@location, @package_path, info)
+        rescue
+          nil
+        end
+      end
+
+      private
+
+      # Read scenario informations.
+      #
+      # @return [Hash]
+      #   scenario information table
+      def read_scenario_informations
+        path = info_location
+        if path.exist?
+          YAML.load(path.read)
+        else
+          {"ScenarioName" => (@location + @package_path).basename}
+        end
+      end
+    end
+
+    class GitPackageReader
+      class << self
+        def read(location)
+          new(location).read
+        end
+      end
+
+      def initialize(location, option={})
+        @location = location
+        @package_name = option[:package_name]
+        @edition = option[:edition] || "origin"
+        @branch = option[:branch]
+        @tag = option[:tag]
+        @hash_id = option[:hash_id]
+
+        @digest = Digest::SHA1.hexdigest(@location.address)
+      end
+
+      def read
+        if cache_location = find_cache_location
+          return PackageReader.read(cache_location)
+        else
+          Location[Temppath.mkdir].tap do |tmp|
+            @location.export(tmp)
+            _package = PackageReader.read(tmp)
+            cache_location = Global.git_package_directory + dirname(_package)
+            cache_location.mkdir
+            tmp.entries.each {|entry| entry.move(cache_location)}
+            return PackageReader.read(cache_location)
+          end
+        end
+      end
+
+      private
+
+      def find_cache_location
+        begin
+          Global.git_package_directory.entries.find do |entry|
+            entry.basename.to_s.split("_").last.include?(@location.compact_hash_id)
+          end
+        rescue Pione::Location::NotFound
+          return nil
+        end
+      end
+
+      # Return the cache directory name.
+      def dirname(package)
+        "%s(%s)_%s" % [package.name, package.edition, @location.compact_hash_id]
+      end
+    end
+
+    class ArchivePackageReader
+      class << self
+        def read(location)
+          new(location).expand
+        end
+      end
+
+      def initialize(location)
+        @location = location
+      end
+
+      def expand
+        cache = Global.archive_package_cache_dir + cache_name
+        PackageExpander.new(@location).expand(cache)
+        return cache
+      end
+
+      def cache_name
+        fname = PackageFilename.parse(@location.basename)
+        "%s(%s)_%s" % [fname.package_name, fname.edition, @location.sha1]
+      end
+    end
+  end
+end