pione 0.1.4 → 0.2.0

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

@@ -65,7 +65,7 @@ module Pione
       start do
         # print each bags
         @tuple_space_servers.each do |address, tuple_space_server|
-          puts "TupleSpaceServer: %s" % Terminal.red(address)
+          puts "TupleSpaceServer: %s" % address.color(:red)
           puts "-"*78
           if option[:bag_type] == :bag or option[:bag_type].nil?
             puts "*** bag ***"
@@ -157,8 +157,8 @@ module Pione
 
           # show
           res = PP.pp(tuple, "")
-          res.gsub!(/\:[a-z]\w+/) {|s| Terminal.red(s) }
-          res.gsub!(/\#<(\S+)/) {|s| "#<%s" % Terminal.green($1) }
+          res.gsub!(/\:[a-z]\w+/) {|s| s.color(:red) }
+          res.gsub!(/\#<(\S+)/) {|s| "#<%s" % $1.color(:green) }
           puts res
         end
       end

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

@@ -0,0 +1,40 @@
+module Pione
+  module Command
+    # PioneSyntaxChecker is a command for checking syntax tree and model of the
+    # PIONE document.
+    class PioneEval < 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"]
+
+        option('--domain-info=LOCATION', 'location of Domain info file') do |data, location|
+          data[:domain_info] = Location[location]
+        end
+      end
+
+      start do
+        # get expression string
+        str = ARGV[0] || abort("no expressions")
+
+        # setup domain info
+        domain_info = nil
+        if option[:domain_info].exist?
+          domain_info = System::DomainInfo.read(option[:domain_info])
+        end
+
+        begin
+          # evaluate it and print the result
+          $stdout.puts Pione.val(str, domain_info)
+          exit
+        rescue => e
+          abort("error: %s" % e)
+        end
+      end
+    end
+  end
+end
+

data/lib/pione/component.rb

@@ -0,0 +1,8 @@
+module Pione
+  module Component
+  end
+end
+
+require 'pione/component/rule'
+require 'pione/component/document'
+require 'pione/component/package'

data/lib/pione/{system → component}/document.rb

@@ -1,5 +1,5 @@
 module Pione
-  module System
+  module Component
     class Document < PioneObject
       # Add ruby shebang line.
       def ruby(str, charset=nil)
@@ -9,19 +9,21 @@ module Pione
       end
 
       # Load a rule document and return it.
-      def self.load(filepath)
-        parse(File.read(filepath))
+      def self.load(filepath, package_name="main")
+        filepath = Location[filepath] unless filepath.kind_of?(Location::BasicLocation)
+        parse(filepath.read, package_name)
       end
 
       # Parse a rule document string.
-      def self.parse(src)
+      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
+        transformer = Transformer::DocumentTransformer.new(package_name)
         toplevels = transformer.apply(parser.parse(src))
 
         # rules and assignments
-        rules = toplevels.select{|elt| elt.kind_of?(Rule)}
+        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)
@@ -41,11 +43,11 @@ module Pione
         end.to_params
 
         # set document parameters into rules
-        rules.each {|rule| rule.params.merge!(params)}
+        rules.each {|rule| rule.condition.params.merge!(params)}
 
         # make rule table
         table = rules.inject({}) do |tbl, rule|
-          tbl.tap{|x| x[rule.rule_path] = rule}
+          tbl.tap{|x| x[rule.path] = rule}
         end
         return new(table, params)
       end
@@ -65,7 +67,7 @@ module Pione
       #   rule path
       # @return [Pione::Model::Rule]
       def [](name)
-        @rules[name].params.merge!(@params)
+        @rules[name].condition.params.merge!(@params)
         @rules[name]
       end
 
@@ -73,7 +75,7 @@ module Pione
       # @return [Rule]
       #   main rule of main package
       def main
-        @rules["&main:Main"].params.merge!(@params)
+        @rules["&main:Main"].condition.params.merge!(@params)
         @rules["&main:Main"]
       end
 
@@ -83,7 +85,7 @@ module Pione
       # @return [RootRule]
       #   root rule
       def root_rule(params)
-        Rule::RootRule.new(main, @params.merge(params))
+        Component::RootRule.new(main, @params.merge(params))
       end
     end
   end

data/lib/pione/component/package.rb

@@ -0,0 +1,269 @@
+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, 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))
+      end
+
+      # Upload the package files to the location.
+      #
+      # @return [void]
+      def upload(dest)
+        if @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)
+        if name == :anything
+          @scenarios.first
+        else
+          @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
+        end
+      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)
+          end
+        end
+      end
+    end
+
+    # PackageReader is a reader for packages.
+    class PackageReader
+      # @param location [Location]
+      #   package location
+      def initialize(location)
+        @location = location
+      end
+
+      # Read the package.
+      #
+      # @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)
+      end
+
+      private
+
+      # 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_scenarios
+        if (@location + "scenario" + "scenario.yml").exist?
+          [PackageScenarioReader.read(@location + "scenario")]
+        else
+          if (@location + "scenario").exist? and (@location + "scenario").directory?
+            (@location + "scenario").entries.map do |scenario|
+              PackageScenarioReader.read(scenario)
+            end.compact
+          else
+            []
+          end
+        end
+      end
+
+      # Find documents from the packcage location.
+      #
+      # @return [Array<Document>]
+      #   documents
+      def find_documents(package_name)
+        @location.entries.select do |entry|
+          entry.file? and entry.path.extname == ".pione"
+        end.map {|entry| Document.load(entry, package_name) }
+      end
+    end
+
+    # PackageScenario is a class for expected scenario of rule's behavior.
+    class PackageScenario
+      include SimpleIdentity
+
+      attr_reader :location
+      attr_reader :info
+
+      forward_as_key :@info, "ScenarioName", :name
+
+      # @param location [BasicLocation]
+      #   scenario location
+      # @param info [Hash]
+      #   scenario information table
+      def initialize(location, info)
+        @location = location
+        @info = info
+      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 + "input"
+        input_location if input_location.exist?
+      end
+
+      # Return the output location.
+      #
+      # @return [BasicLocation]
+      #   the output location
+      def output
+        @location + "output"
+      end
+    end
+
+    # PackageScenarioReader is a reader for loading scenarios.
+    class PackageScenarioReader
+      def self.read(location)
+        new(location).read
+      end
+
+      # @param location [Location]
+      #   the scenario location
+      def initialize(location)
+        @location = location
+      end
+
+      # Read scenario files.
+      #
+      # @return [PackageScenario]
+      #   the scenario
+      def read
+        begin
+          info = read_scenario_informations
+          PackageScenario.new(@location, info)
+        rescue
+          nil
+        end
+      end
+
+      private
+
+      # Read scenario information table.
+      #
+      # @return [Hash]
+      #   scenario information table
+      def read_scenario_informations
+        path = @location + "scenario.yml"
+        if path.exist?
+          YAML.load(path.read)
+        else
+          {"ScenarioName" => @location.basename}
+        end
+      end
+    end
+  end
+end
+

data/lib/pione/component/rule.rb

@@ -0,0 +1,206 @@
+module Pione
+  module Component
+    # RuleCondition represents rule condition.
+    class RuleCondition < StructX
+      include Util::VariableHoldable
+
+      member :inputs, default: []
+      member :outputs, default: []
+      member :params, default: Model::Parameters.empty
+      member :features, default: Model::Feature.empty
+      member :constraints, default: Model::Constraints.empty
+      member :input_ticket_expr, default: Model::TicketExprSequence.empty
+      member :output_ticket_expr, default: Model::TicketExprSequence.empty
+
+      hold_variables members
+    end
+
+    # Rule is a class for PIONE rule model.
+    class Rule < PioneObject
+      include SimpleIdentity
+      include Util::VariableHoldable
+
+      hold_variables :rule_expr, :condition, :body
+
+      class << self
+        attr_reader :rule_type
+        attr_reader :handler_class
+
+        # Declare rule type of the class.
+        #
+        # @param rule_type [Symbol]
+        #   rule type
+        # @return [void]
+        def set_rule_type(rule_type)
+          @rule_type = rule_type
+        end
+
+        # Declare rule handler class of the class.
+        #
+        # @param handler_class [Class]
+        #   handler class
+        # @return [void]
+        def set_handler_class(handler_class)
+          @handler_class = handler_class
+        end
+      end
+
+      forward! :class, :rule_type, :handler_class
+
+      attr_reader :package_name
+      attr_reader :name
+      attr_reader :condition
+      attr_reader :body
+
+      # Create a rule.
+      #
+      # @param package_name [String]
+      #   package name
+      # @param name [String]
+      #   rule name
+      # @param condition [RuleCondition]
+      #   rule condition
+      # @param [Block] body
+      #   rule body block
+      def initialize(package_name, name, condition, body)
+        @package_name = package_name
+        @name = name
+        @condition = condition
+        @body = body
+      end
+
+      # Return true if this is a kind of action rule.
+      #
+      # @return [Boolean]
+      #   true if this is a kind of action rule, or false
+      def action?
+        rule_type == :action
+      end
+
+      # Return true if this is a kind of flow rule.
+      #
+      # @return [Boolean]
+      #   true if this is a kind of flow rule, or false
+      def flow?
+        rule_type == :flow
+      end
+
+      def path
+        "&%s:%s" % [@package_name, @name]
+      end
+
+      # Make a task handler object for the rule.
+      #
+      # @param ts_server [TupleSpaceServer]
+      #   tuple space server
+      # @param inputs [Array<DataTuple, Array<DataTuple>>]
+      #   input tuples
+      # @param params [Parameters]
+      #   rule parameters
+      # @param call_stack [Array<String>]
+      #   call stack
+      # @return [RuleHandler]
+      #   rule handler object
+      def make_handler(ts_server, inputs, params, call_stack, opts={})
+        handler_class.new(ts_server, self, inputs, params, call_stack, opts)
+      end
+    end
+
+    # ActionRule is a rule that have some actions. This rule makes data
+    # processing.
+    class ActionRule < Rule
+      set_rule_type :action
+      set_handler_class RuleHandler::ActionHandler
+    end
+
+    # FlowRule is a rule that have flow elements. This rule makes processing flow.
+    class FlowRule < Rule
+      set_rule_type :flow
+      set_handler_class RuleHandler::FlowHandler
+    end
+
+    # EmptyRule is a rule that have no body. This rule is useful when you need
+    # no flows and no actions.
+    class EmptyRule < Rule
+      set_rule_type :action
+      set_handler_class RuleHandler::EmptyHandler
+    end
+
+    # RootRule is a hidden toplevel rule. This rule has same flow as the follow:
+    #   Rule Root
+    #     input  '*'.all
+    #     output '*'.all.except('{$INPUT[1]}')
+    #   Flow
+    #     rule &main:Main
+    #   End
+    class RootRule < Rule
+      set_rule_type :flow
+      set_handler_class RuleHandler::RootHandler
+
+      INPUT_DOMAIN = 'input'
+
+      # root domain has no digest and no package
+      ROOT_DOMAIN = 'Root'
+
+      attr_reader :main
+
+      # Make a root rule.
+      #
+      # @param main [Rule]
+      #   main rule
+      # @param params [Parameters]
+      #   main rule's parameters
+      def initialize(main, params=Parameters.empty)
+        @main = main
+        @params = params
+        @domain = ROOT_DOMAIN
+        rule_expr = RuleExpr.new(PackageExpr.new(main.package_name), main.name)
+        condition = RuleCondition.new(@main.condition.inputs, @main.condition.outputs)
+        block = FlowBlock.new(CallRule.new(rule_expr.set_params(@params)))
+        super("Root", "Root", condition, block)
+      end
+
+      def make_handler(ts_server)
+        # build parameter
+        params = @main.condition.params.merge(@params)
+
+        # find inputs
+        finder = DataFinder.new(ts_server, INPUT_DOMAIN)
+        results = finder.find(:input, @main.condition.inputs, params.as_variable_table)
+        if results.empty? and not(@main.condition.inputs.empty?)
+          return nil
+        end
+        inputs = @main.condition.inputs.empty? ? [] : results.first.combination
+
+        # make handler
+        handler_class.new(ts_server, self, inputs, params, [], domain: @domain)
+      end
+    end
+
+    # SystemRule represents built-in rule definition. System rules belong to
+    # 'system' package.
+    class SystemRule < Rule
+      set_rule_type :action
+      set_handler_class RuleHandler::SystemHandler
+
+      # Create a system rule model.
+      #
+      # @param name [String]
+      #   rule name
+      # @param [Proc] b
+      #   rule process
+      def initialize(name, &b)
+        condition = RuleCondition.new([Model::DataExpr.new('*').to_seq.set_all], [])
+        super('System', name, condition, b)
+      end
+    end
+
+    # &System:Terminate rule
+    SYSTEM_TERMINATE = SystemRule.new('Terminate') do |tuple_space_server|
+      user_message "!!! Terminate processing !!!"
+      tuple_space_server.write(Tuple[:command].new("terminate"))
+    end
+
+    SYSTEM_RULES = [ SYSTEM_TERMINATE ]
+  end
+end