pione 0.2.0 → 0.2.1

data/lib/pione/command/pione-tuple-space-receiver.rb

@@ -18,10 +18,20 @@ TXT
       end
 
       define_option do
-        use Option::PresenceNotifierOption
+        use :debug
+        use :color
+        use :my_ip_address
+        use :no_parent
+        use :parent_front
+        use :show_communication
+        use :show_presence_notifier
 
-        option("--presence-port=PORT", "set presence port number") do |data, port|
-          Global.presence_port = port.to_i
+        define(:presence_port) do |item|
+          item.long = "--presence-port=PORT"
+          item.desc = "set presence port number"
+          item.action = lambda do |option, port|
+            Global.presence_port = port.to_i
+          end
         end
       end
 

data/lib/pione/command/pione-tuple-space-viewer.rb

@@ -9,46 +9,65 @@ module Pione
       end
 
       define_option do
-        default :identifiers, []
-        default :exclusions, []
-
-        option('-i', '--identifier=NAME', 'show tuples that have the identifier') do |data, name|
-          data[:identifiers] << name
+        use :color
+        use :debug
+        use :show_communication
+
+        define(:identifiers) do |item|
+          item.short = '-i'
+          item.long = '--identifier=NAME'
+          item.desc = 'show tuples that have the identifier'
+          item.default = []
+          item.values = lambda {|name| name}
         end
 
-        option('-e', '--exclude=NAME', 'exclude the tuple identifier') do |data, name|
-          data[:exclusions] << name
+        define(:exclusions) do |item|
+          item.short = '-e'
+          item.long = '--exclude=NAME'
+          item.desc = 'exclude the tuple identifier'
+          item.default = []
+          item.values = lambda {|name| name}
         end
 
-        option('--package=NAME', 'show tuples which domain has the package name') do |data, name|
-          data[:package] = name
+        define(:package) do |item|
+          item.long = '--package=NAME'
+          item.desc = 'show tuples which domain has the package name'
+          item.value = lambda {|name| name}
         end
 
-        option('--rule=NAME', 'show tuples which domain has the rule name') do |data, name|
-          data[:rule] = name
+        define(:rule) do |item|
+          item.long = '--rule=NAME'
+          item.desc = 'show tuples which domain has the rule name'
+          item.value = lambda {|name| name}
         end
 
-        option('--rule-path=NAME', 'show tuples which domain has the rule path') do |data, path|
-          data[:rule_path] = path
+        define(:rule_path) do |item|
+          item.long = '--rule-path=NAME'
+          item.desc = 'show tuples which domain has the rule path'
+          item.value = lambda {|path| path}
         end
 
-        option('--data-name=NAME', 'show tuples that has the the name') do |data, name|
-          data[:data_name] = name
+        define(:data_name) do |item|
+          item.long = '--data-name=NAME'
+          item.desc = 'show tuples that has the the name'
+          item.value = lambda {|name| name}
         end
 
-        option(
-          '--type=TYPE',
-          'show the bag which has the type("bag", "read_waiter", or "take_waiter")'
-        ) do |data, bag_type|
-          data[:bag_type] = bag_type.to_sym
+        define(:bag_type) do |item|
+          item.long = '--type=TYPE'
+          item.desc = 'show the bag which has the type("bag", "read_waiter", or "take_waiter")'
+          item.value = lambda {|bag_type| bag_type.to_sym}
         end
 
-        option('--client=ADDRESS', 'druby address of target client process') do |data, address|
-          data[:address] = address
+        define(:address) do |item|
+          item.long = '--client=ADDRESS'
+          item.desc = 'druby address of target client process'
+          item.value = lambda {|address| address}
         end
       end
 
-      def initialize
+      def initialize(*argv)
+        super
         @tuple_space_servers = []
       end
 

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

@@ -1,24 +1,26 @@
 module Pione
   module Command
-    # PioneSyntaxChecker is a command for checking syntax tree and model of the
-    # PIONE document.
-    class PioneEval < BasicCommand
+    # PioneVal command enables you to get evaluation result of PIONE expressions from out of PIONE system.
+    class PioneVal < BasicCommand
       define_info do
         set_name "pione-val"
         set_banner "Get the evaluation result value of the PIONE expression."
       end
 
       define_option do
-        default :domain_info, Location["./domain.dump"]
+        use :debug
 
-        option('--domain-info=LOCATION', 'location of Domain info file') do |data, location|
-          data[:domain_info] = Location[location]
+        define(:domain_info) do |item|
+          item.long = '--domain-info=LOCATION'
+          item.desc = 'location of Domain info file'
+          item.default = Location["./domain.dump"]
+          item.value = lambda {|location| Location[location]}
         end
       end
 
       start do
         # get expression string
-        str = ARGV[0] || abort("no expressions")
+        str = @argv.first || abort("no expressions")
 
         # setup domain info
         domain_info = nil
@@ -30,6 +32,12 @@ module Pione
           # evaluate it and print the result
           $stdout.puts Pione.val(str, domain_info)
           exit
+        rescue Model::UnboundVariableError => e
+          if option[:domain_info].exist?
+            raise
+          else
+            abort("domain info file '%s' not found" % option[:domain_info].uri.to_s)
+          end
         rescue => e
           abort("error: %s" % e)
         end

data/lib/pione/component/document.rb

@@ -1,91 +1,70 @@
 module Pione
   module Component
-    class Document < PioneObject
-      # Add ruby shebang line.
-      def ruby(str, charset=nil)
-        res = "#!/usr/bin/env ruby\n"
-        res << "# -*- coding: #{charset} -*-\n" if charset
-        return res + str
+    class DuplicatedRuleError < StandardError
+      def initialize(rule_path)
+        @rule_path = rule_path
       end
 
-      # Load a rule document and return it.
-      def self.load(filepath, package_name="main")
-        filepath = Location[filepath] unless filepath.kind_of?(Location::BasicLocation)
-        parse(filepath.read, package_name)
+      def message
+        "There are duplicated rule %s in docuemtn" % @rule_path
       end
+    end
 
-      # Parse a rule document string.
-      def self.parse(src, package_name="main")
-        src = src.read if src.kind_of?(Location::BasicLocation)
-        # parse the document and build the model
-        parser = Parser::DocumentParser.new
-        transformer = Transformer::DocumentTransformer.new(package_name)
-        toplevels = transformer.apply(parser.parse(src))
-
-        # rules and assignments
-        rules = toplevels.select{|elt| elt.kind_of?(Component::Rule)}
-        assignments = toplevels.select{|elt| elt.kind_of?(Assignment)}
-        assignments.each {|assignment| assignment.set_toplevel(true)}
-        user_params = Naming::ParamLine.values(toplevels)
-        Naming::ParamBlock.values(toplevels).each do |elts|
-          user_params += elts
-        end
-        assignments += user_params.map do |param|
-          param.tap do |x|
-            x.set_toplevel(true)
-            x.set_user_param(true)
-          end
-        end
+    class Document < StructX
+      class << self
+        # Load a PIONE rule document.
+        #
+        # @param location [Location,String]
+        #   location of the PIONE document
+        # @return [Component::Document]
+        #   the document
+        def load(src, package_name="Main")
+          src = src.read if src.kind_of?(Location::BasicLocation)
 
-        # make document parameters
-        params = assignments.inject(VariableTable.empty) do |vtable, a|
-          vtable.tap{|t| t.set(a.variable, a.expr)}
-        end.to_params
+          # parse the document and build the model
+          parser = Parser::DocumentParser.new
+          transformer = Transformer::DocumentTransformer.new(package_name)
+          toplevels = transformer.apply(parser.parse(src))
 
-        # set document parameters into rules
-        rules.each {|rule| rule.condition.params.merge!(params)}
+          # rules and assignments
+          rules = toplevels.select{|elt| elt.kind_of?(Component::Rule)}
+          assignments = Naming[:AssignmentLine, :ParamLine, :ParamBlock].values(toplevels).flatten
 
-        # make rule table
-        table = rules.inject({}) do |tbl, rule|
-          tbl.tap{|x| x[rule.path] = rule}
-        end
-        return new(table, params)
-      end
+          # make document parameters
+          params = assignments.inject(VariableTable.empty) do |vtable, a|
+            vtable.tap{|t| t.set(a.variable, a.expr)}
+          end.to_params
 
-      attr_reader :rules
-      attr_reader :params
+          # set document parameters into rules
+          rules.each {|rule| rule.condition.params.merge!(params)}
 
-      # Creates a document.
-      def initialize(rules, params)
-        @rules = rules
-        @params = params
-        instance_eval(&b) if block_given?
+          return new(package_name, rules, params)
+        end
       end
 
-      # Returns the named rule.
-      # @param [String] name
-      #   rule path
-      # @return [Pione::Model::Rule]
-      def [](name)
-        @rules[name].condition.params.merge!(@params)
-        @rules[name]
-      end
+      member :package_name
+      member :rules
+      member :params
 
-      # Returns main rule of main package.
-      # @return [Rule]
-      #   main rule of main package
-      def main
-        @rules["&main:Main"].condition.params.merge!(@params)
-        @rules["&main:Main"]
+      # Find the named rule.
+      #
+      # @param name [String]
+      #   rule name
+      # @return [Component::Rule]
+      def find(name)
+        rules.find {|rule| rule.name == name}
       end
 
-      # Returns root rule.
+      # Create a root rule which calls the rule with the parameters.
+      #
+      # @param rule [Component::Rule]
+      #   rule that is called by the root rule
       # @param [Parameters] params
-      #   root root parameter
-      # @return [RootRule]
+      #   user parameters
+      # @return [Component::RootRule]
       #   root rule
-      def root_rule(params)
-        Component::RootRule.new(main, @params.merge(params))
+      def create_root_rule(rule, user_params)
+        Component::RootRule.new(rule, params.merge(user_params))
       end
     end
   end

data/lib/pione/component/package.rb

@@ -14,72 +14,30 @@ module Pione
       end
     end
 
-    # Package is a container of rules, script, scenario, and etc.
-    class Package
-      include SimpleIdentity
-
-      attr_reader :info
-      attr_reader :bin
-      attr_reader :scenarios
-      attr_reader :documents
-      attr_reader :rules
-      attr_reader :params
-
-      forward_as_key :@info, "PackageName", :name
-
-      # @param info [Hash]
-      #   package information table
-      # @param bin [Location]
-      #   package bin directory
-      # @param scenarios [Array<PackageScenario>]
-      #   scenarios
-      # @param documents [Array<Document>]
-      #   PIONE documents
-      def initialize(info, bin, scenarios, documents)
-        @info = info
-        @bin = bin
-        @scenarios = scenarios
-        @documents = documents
-        build_rules
-        build_params
-      end
-
-      # Return the package entry rule.
-      #
-      # @return [Rule]
-      #   entry rule
-      def main
-        @rules["&%s:Main" % name].tap{|x| x.condition.params.merge!(@params)}
-      end
-
-      # Return the named rule.
-      #
-      # @param [String] name
-      #   rule path
-      # @return [Rule]
-      #   the rule
-      def [](name)
-        @rules[name].params.merge!(@params)
-        @rules[name]
-      end
-
-      # Return root rule.
-      #
-      # @param prams [Parameters]
-      #   root parameters
-      # @return [RootRule]
-      #   root rule
-      def root_rule(params)
-        Component::RootRule.new(main, @params.merge(params))
+    # Package is a container of rules, scripts, scenarios, and etc.
+    class Package < StructX
+      member :info, default: {}
+      member :bin
+      member :scenarios, default: []
+      member :documents, default: []
+
+      forward_as_key Proc.new{info}, "PackageName", :name
+      forward :@unified_document, :find, :find_rule
+      forward! :@unified_document, :rules, :create_root_rule, :params
+
+      def initialize(*args)
+        super(*args)
+        build_unified_document
+        validate
       end
 
       # Upload the package files to the location.
       #
       # @return [void]
       def upload(dest)
-        if @bin.exist?
+        if bin and bin.exist?
           # upload bin files
-          @bin.entries.each do |entry|
+          bin.entries.each do |entry|
             entry.copy(dest + name + "bin" + entry.basename)
           end
         end
@@ -93,34 +51,31 @@ module Pione
       #   the scenario
       def find_scenario(name)
         if name == :anything
-          @scenarios.first
+          scenarios.first
         else
-          @scenarios.find {|scenario| scenario.name == name}
+          scenarios.find {|scenario| scenario.name == name}
         end
       end
 
       private
 
-      # Build rules from all documents in the package.
-      def build_rules
-        @rules = {}
-        @documents.each do |doc|
-          doc.rules.each do |name, rule|
-            unless @rules[name]
-              @rules[name] = rule
-            else
-              raise InvalidPackage.new(self, "duplicated rules: %s" % name)
-            end
-          end
+      # 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
 
-      # Build parameters from all documents in the package.
-      def build_params
-        @params = Model::Parameters.empty
-        @documents.each do |doc|
-          doc.params.each do |param|
-            @params.merge!(param)
+      # 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
@@ -128,10 +83,26 @@ module Pione
 
     # 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 [Location]
       #   package location
       def initialize(location)
         @location = location
+        @type = check_package_type
       end
 
       # Read the package.
@@ -139,15 +110,51 @@ module Pione
       # @return [Package]
       #   the package
       def read
-        infos = read_package_info
-        bin = @location + "bin"
-        scenarios = find_scenarios
-        documents = find_documents(infos["PackageName"])
-        Package.new(infos, bin, scenarios, documents)
+        case @type
+        when :directory
+          return read_package_directory
+        when :pione_document_file
+          return read_pione_document_file
+        end
       end
 
       private
 
+      # Check package type.
+      #
+      # @return [Symbol]
+      #   package type
+      def check_package_type
+        return :directory if @location.directory?
+        if File.extname(@location.basename) == ".pione"
+          return :pione_document_file
+        end
+        raise ArgumentError.new(@location)
+      end
+
+      # Read package directory.
+      #
+      # @return [Package]
+      #   the package
+      def read_package_directory
+        info = read_package_info
+        Package.new(
+          info: info,
+          bin: @location + "bin",
+          scenarios: find_scenarios,
+          documents: find_documents(info["PackageName"])
+        )
+      end
+
+      # Read PIONE document.
+      #
+      # @return [Package]
+      #   the package
+      def read_pione_document_file
+        document = Component::Document.load(@location, "Main")
+        Package.new(info: {"PackageName" => "Main"}, documents: [document])
+      end
+
       # Read the informations from the package location.
       #
       # @return [Hash]
@@ -187,6 +194,22 @@ module Pione
       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
@@ -222,6 +245,25 @@ module Pione
       def output
         @location + "output"
       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
 
     # PackageScenarioReader is a reader for loading scenarios.