pione 0.2.2 → 0.3.0

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

@@ -1,38 +0,0 @@
-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

@@ -1,276 +0,0 @@
-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

data/lib/pione/component/package.rb

@@ -1,199 +0,0 @@
-module Pione
-  module Component
-    # InvalidPackageError raises when the package is something bad.
-    class InvalidPackageError < StandardError
-      attr_reader :package
-
-      def initialize(package, msg)
-        @package = package
-        @msg = msg
-      end
-
-      def message
-        @msg
-      end
-    end
-
-    # Package is a container of rules, scripts, scenarios, and etc.
-    class Package < StructX
-      member :location
-      member :info, default: {}
-      member :bin
-      member :scenario_paths, default: []
-      member :documents, default: []
-
-      forward_as_key Proc.new{info}, "PackageName", :name
-      forward_as_key Proc.new{info}, "Edition", :edition
-      forward_as_key Proc.new{info}, "Tag", :tag
-      forward_as_key Proc.new{info}, "HashID", :hash_id
-      forward :@unified_document, :find, :find_rule
-      forward! :@unified_document, :rules, :create_root_rule, :params
-
-      def initialize(*args)
-        super(*args)
-        info["Edition"] = "origin" unless info["Edition"]
-        build_unified_document
-        validate
-      end
-
-      def scenarios
-        scenario_paths.map {|path| PackageScenarioReader.read(location, path)}
-      end
-
-      # Upload the package files to the location.
-      #
-      # @return [void]
-      def upload(dest)
-        if bin and bin.exist?
-          # upload bin files
-          bin.entries.each do |entry|
-            entry.copy(dest + name + "bin" + entry.basename)
-          end
-        end
-      end
-
-      # Find scenario that have the name.
-      #
-      # @param name [String]
-      #   scenario name
-      # @return [PackageScenario]
-      #   the scenario
-      def find_scenario(name)
-        scenario_paths.each do |path|
-          if name == :anything
-            return PackageScenarioReader.read(location, path)
-          else
-            scenario = PackageScenarioReader.read(location, path)
-            return scenario if scenario.name == name
-          end
-        end
-      end
-
-      private
-
-      # Build an unified document from all documents in the package.
-      def build_unified_document
-        rules = documents.map{|doc| doc.rules}.flatten
-        params = documents.inject(Model::Parameters.empty) do |_params, document|
-          _params.merge(document.params)
-        end
-        @unified_document = Component::Document.new(name, rules, params)
-      end
-
-      # Validate package consistency.
-      def validate
-        @unified_document.rules.map{|rule| rule.path}.sort.inject do |prev, elt|
-          if prev == elt
-            msg = "There are duplicated rules '%s' in the package '%s'"
-            raise InvalidPackage.new(self, msg % [name, package])
-          else
-            elt
-          end
-        end
-      end
-    end
-
-    # RehearsalResult represents error result of rehearsal test.
-    class RehearsalResult < StructX
-      member :key
-      member :name
-
-      # Create an error message.
-      def to_s
-        case key
-        when :different
-          "%s is different from expected result." % name
-        when :not_exist
-          "%s doesn't exist." % name
-        end
-      end
-    end
-
-    # PackageScenario is a class for expected scenario of rule's behavior.
-    class PackageScenario
-      include SimpleIdentity
-
-      attr_reader :location
-      attr_reader :package_path
-      attr_reader :info
-
-      forward_as_key :@info, "ScenarioName", :name
-      forward_as_key :@info, "Edition", :edition
-      forward_as_key :@info, "Version", :version
-      forward_as_key :@info, "Date", :date
-
-      # @param location [BasicLocation]
-      #   scenario location
-      # @param info [Hash]
-      #   scenario information table
-      def initialize(location, package_path, info)
-        @location = location
-        @package_path = package_path
-        @info = info
-        @package_path = package_path
-      end
-
-      # Return the input location. If the scenario doesn't have input location,
-      # return nil.
-      #
-      # @return [BasicLocation]
-      #   the input location
-      def input
-        input_location = @location + @package_path + "input"
-        input_location if input_location.exist?
-      end
-
-      # Return input file locations.
-      #
-      # @return [BasicLocation]
-      #   input file locations
-      def inputs
-        if info.has_key?("Inputs")
-          info["Inputs"].map {|name| @location + @package_path + "input" + name}
-        else
-          []
-        end
-      end
-
-      # Return the output location.
-      #
-      # @return [BasicLocation]
-      #   the output location
-      def output
-        @location + @package_path + "output"
-      end
-
-      # Return output file locations.
-      #
-      # @return [BasicLocation]
-      #   output file locations
-      def outputs
-        if info.has_key?("Outputs")
-          info["Outputs"].map {|name| @location + @package_path + "output" + name}
-        else
-          []
-        end
-      end
-
-      # Validate reheasal results.
-      def validate(result_location)
-        return [] unless output.exist?
-
-        errors = []
-        output.entries.each do |entry|
-          name = entry.basename
-          result = result_location + name
-          if result.exist?
-            if entry.read != result.read
-              errors << RehearsalResult.new(:different, name)
-            end
-          else
-            errors << RehearsalResult.new(:not_exist, name)
-          end
-        end
-        return errors
-      end
-    end
-  end
-end
-