pione 0.1.0

data/lib/pione/system/identifier.rb

@@ -0,0 +1,61 @@
+module Pione
+  module System
+    # Identifier is a set of generators for id.
+    module Identifier
+      # Makes task id by input data names.
+      # @param [Array<Pione::Tuple::Data>] inputs
+      #   input data tuples
+      # @param [Pione::Model::Parameters] params
+      #   parameters object
+      # @return [String]
+      #   task's digest string
+      def task_id(inputs, params)
+        raise ArgumentError.new(params) unless params.kind_of?(Parameters)
+        # FIXME: inputs.flatten?
+        input_names = inputs.flatten.map{|t| t.name}
+        is = input_names.join("\000")
+        ps = params.data.map do |key, val|
+          "%s:%s" % [key.textize, val.textize]
+        end.join("\000")
+        Digest::MD5.hexdigest("#{is}\001#{ps}\001")
+      end
+      module_function :task_id
+
+      # Makes target domain name by module name, inputs, and outputs.
+      # @param [String] package_name
+      #   package name
+      # @param [String] rule_name
+      #   rule name
+      # @param [Array<Pione::Tuple::Data>] inputs
+      #   input data tuples
+      # @param [Pione::Model::Parameters] params
+      #   parameters object
+      # @return [String]
+      #   domain string
+      def domain_id(package_name, rule_name, inputs, params)
+        "%s-%s_%s" % [package_name, rule_name, task_id(inputs, params)]
+      end
+      module_function :domain_id
+
+      # Makes target domain name by module name, inputs, and outputs.
+      # @param [String] rule
+      #   package name
+      # @param [Array<Pione::Tuple::Data>] inputs
+      #   input data tuples
+      # @param [Pione::Model::] callee
+      #   parameters object
+      # @return [String]
+      #   domain string
+      def domain_id3(rule, inputs, callee)
+        package_name = rule.expr.package.name
+        rule_name = rule.expr.name
+        params = callee.expr.params
+        return domain_id(package_name, rule_name, inputs, params)
+      end
+      module_function :domain_id3
+    end
+  end
+
+  # Short name for Identifier.
+  ID = System::Identifier
+end

data/lib/pione/system/init.rb

@@ -0,0 +1,16 @@
+module Pione
+  module System
+    class Init
+      def init
+        # init globals
+        Global.init
+
+        # relay client database
+        Global.relay_client_db = Relay::RelayClientDB.new(Global.relay_client_db_path)
+
+        # relay account database
+        Global.relay_account_db = Relay::RelayAccountDB.new(Global.relay_account_db_path)
+      end
+    end
+  end
+end

data/lib/pione/system/object.rb

@@ -0,0 +1,35 @@
+module Pione
+  module System
+    # PioneObject is a base class for PIONE system.
+    class PioneObject
+      # Checks argument type. Raises a type error if the value is not kind of
+      # the type.
+      # @param [Object] val
+      #   check target
+      # @param [Class] klass
+      #   expected type
+      # @return [void]
+      def check_argument_type(val, klass)
+        raise TypeError.new(val) unless val.kind_of?(klass)
+      end
+
+      # Returns true.
+      def ping
+        true
+      end
+
+      # Returns this object's uuid.
+      # @return [String]
+      #   UUID string
+      def uuid
+        @__uuid__ ||= Util.generate_uuid
+      end
+
+      # Finalizes this object.
+      # @return [void]
+      def finalize
+        # do nothing
+      end
+    end
+  end
+end

data/lib/pione/transformer/block-transformer.rb

@@ -0,0 +1,23 @@
+module Pione
+  module Transformer
+    module BlockTransformer
+      include TransformerModule
+
+      # flow_block:
+      rule(:flow_block => sequence(:elements)) {
+        FlowBlock.new(*elements)
+      }
+
+      # action_block:
+      rule(:action_block =>
+        { :key => simple(:keyword_Action),
+          :content => simple(:content) }
+      ) {
+        line_and_column = keyword_Action.line_and_column
+        ActionBlock.new(content) do
+          set_line_and_column(line_and_column)
+        end
+      }
+    end
+  end
+end

data/lib/pione/transformer/document-transformer.rb

@@ -0,0 +1,36 @@
+module Pione
+  module Transformer
+    class DocumentTransformer < Parslet::Transform
+      include LiteralTransformer
+      include FeatureExprTransformer
+      include ExprTransformer
+      include FlowElementTransformer
+      include BlockTransformer
+      include RuleDefinitionTransformer
+
+      def initialize(package_name="main")
+        super()
+        @current_package_name = package_name
+        Thread.current[:current_package_name] = @current_package_name
+      end
+
+      def apply(*args)
+        res = super
+        return res
+      end
+
+      def check_model_type(data, type)
+        data.pione_model_type == type
+      end
+
+      #
+      # statement
+      #
+
+      # package
+      rule(:package => subtree(:tree)) {
+        @current_package = Package.new(tree[:package_name].to_s)
+      }
+    end
+  end
+end

data/lib/pione/transformer/expr-transformer.rb

@@ -0,0 +1,89 @@
+module Pione
+  module Transformer
+    MessageArgument = Struct.new(:name, :parameters)
+    ParametersElement = Struct.new(:key, :value)
+
+    module ExprTransformer
+      include TransformerModule
+
+      # expr_operator_application
+      rule(:expr_operator_application =>
+           { :left => simple(:left),
+             :operator => simple(:operator),
+             :right => simple(:right) }) {
+        Model::BinaryOperator.new(operator, left, right)
+      }
+
+      # expr
+      rule(:expr => simple(:obj)) { obj }
+
+      # receiver
+      rule({ :receiver => simple(:receiver),
+             :messages => sequence(:messages) }) {
+        obj = receiver
+        messages.each do |msg|
+          obj = Model::Message.new(msg.name, obj, *msg.parameters)
+        end
+        obj
+      }
+      rule({ :receiver => simple(:receiver),
+             :indexes => sequence(:indexes) }) {
+        obj = receiver
+        indexes.each do |msg|
+          obj = Model::Message.new("[]", obj, *msg.parameters)
+        end
+        obj
+      }
+
+      # message
+      rule(:message => {:message_name => simple(:name)}) {
+        MessageArgument.new(name)
+      }
+      rule(:message =>
+           { :message_name => simple(:name),
+             :message_parameters => sequence(:parameters) }) {
+        MessageArgument.new(name, parameters)
+      }
+      rule(:message =>
+           { :message_name => simple(:name),
+             :message_parameters => nil }) {
+        MessageArgument.new(name)
+      }
+      rule(:message =>
+           { :message_name => simple(:name),
+             :message_parameters => simple(:arg) }) {
+        MessageArgument.new(name, arg)
+      }
+
+      # rule_expr
+      rule(:rule_expr => simple(:rule)) { rule }
+      rule(:rule_expr => {
+          :package => simple(:package),
+          :expr => simple(:expr)
+        }) {
+        expr.set_package(package)
+      }
+
+      # parameters
+      rule(:parameters => nil) { Parameters.new({}) }
+      rule(:parameters => simple(:elt)) {
+        Parameters.new({elt.key => elt.value})
+      }
+      rule(:parameters => sequence(:list)) {
+        elts = Hash[*list.map{|elt| [elt.key, elt.value]}.flatten(1)]
+        Parameters.new(elts)
+      }
+
+      rule(:parameters_element => {
+          :key => simple(:key),
+          :value => simple(:value)
+        }) {
+        ParametersElement.new(Variable.new(key.to_s), value)
+      }
+
+      rule(:index => sequence(:args)) {
+        MessageArgument.new("[]", args)
+      }
+    end
+  end
+end

data/lib/pione/transformer/feature-expr-transformer.rb

@@ -0,0 +1,56 @@
+module Pione
+  module Transformer
+    module FeatureExprTransformer
+      include TransformerModule
+
+      # feature_name
+      # convert into plain string
+      rule(:atomic_feature =>
+           { :operator => simple(:operator),
+             :symbol => simple(:symbol) }
+           ) do
+        case operator
+        when "+"
+          Feature::RequisiteExpr.new(symbol.str)
+        when "-"
+          Feature::BlockingExpr.new(symbol.str)
+        when "?"
+          Feature::PreferredExpr.new(symbol.str)
+        when "^"
+          Feature::PossibleExpr.new(symbol.str)
+        when "!"
+          Feature::RestrictiveExpr.new(symbol.str)
+        end
+      end
+      rule(:atomic_feature => {:symbol => simple(:symbol)}) {
+        case symbol
+        when "*"
+          Feature.empty
+        when "@"
+          Feature.boundless
+        end
+      }
+
+      # feature expr
+      rule(:feature_expr => simple(:expr)) do
+        expr
+      end
+
+      # feature conjunction
+      rule(:feature_conjunction => {
+             :left => simple(:left),
+             :right => simple(:right)
+           }) do
+        Feature::AndExpr.new(left, right)
+      end
+
+      # feature disjunction
+      rule(:feature_disjunction => {
+             :left => simple(:left),
+             :right => simple(:right)
+           }) do
+        Feature::OrExpr.new(left, right)
+      end
+    end
+  end
+end

data/lib/pione/transformer/flow-element-transformer.rb

@@ -0,0 +1,66 @@
+module Pione
+  module Transformer
+    module FlowElementTransformer
+      include TransformerModule
+
+      # flow_elements returns just elements sequence
+      rule(:flow_elements => sequence(:elements)) {
+        elements
+      }
+
+      # call_rule
+      rule(:call_rule => subtree(:rule_expr)) {
+        TypeRuleExpr.check(rule_expr)
+        CallRule.new(rule_expr)
+      }
+
+      # if_block
+      rule(:if_block =>
+           { :condition => simple(:condition),
+             :if_true_elements => sequence(:if_true),
+             :if_else_block => simple(:if_false)
+           }) {
+        block = { PioneBoolean.true => FlowBlock.new(*if_true) }
+        block[:else] = if_false if if_false
+        ConditionalBlock.new(condition, block)
+      }
+
+      # else_block
+      rule(:else_block =>
+           { :elements => sequence(:elements) }) {
+        FlowBlock.new(*elements)
+      }
+
+      # case_block
+      rule(:case_block =>
+        { :condition => simple(:condition),
+          :when_blocks => sequence(:when_blocks),
+          :case_else_block => simple(:else_block) }) {
+        block = {}
+        when_blocks.each do |when_block|
+          block[when_block.value] = when_block.body
+        end
+        block[:else] = else_block if else_block
+        ConditionalBlock.new(condition, block)
+      }
+
+      WhenBlock = Struct.new(:value, :body)
+
+      # when_block
+      rule(:when_block =>
+        { :value => simple(:value),
+        :elements => sequence(:elements) }
+      ) {
+        WhenBlock.new(value, FlowBlock.new(*elements))
+      }
+
+    # assignment
+    rule(:assignment =>
+      { :symbol => simple(:symbol),
+        :value => simple(:value) }
+    ) {
+      Assignment.new(symbol, value)
+    }
+    end
+  end
+end

data/lib/pione/transformer/literal-transformer.rb

@@ -0,0 +1,76 @@
+module Pione
+  module Transformer
+    module LiteralTransformer
+      include TransformerModule
+
+      # boolean
+      rule(:boolean => simple(:s)) do
+        line_and_column = s.line_and_column
+        val = (s == "true")
+        Model::PioneBoolean.new(val) do
+          set_line_and_column(line_and_column)
+        end
+      end
+
+      # string
+      rule(:string => simple(:s)) do
+        line_and_column = s.line_and_column
+        Model::PioneString.new(s.str.gsub(/\\(.)/){$1}) do
+          set_line_and_column(line_and_column)
+        end
+      end
+
+      # integer
+      rule(:integer => simple(:i)) do
+        line_and_column = i.line_and_column
+        Model::PioneInteger.new(i.to_i) do
+          set_line_and_column(line_and_column)
+        end
+      end
+
+      # float
+      rule(:float => simple(:f)) do
+        line_and_column = f.line_and_column
+        Model::PioneFloat.new(f.to_f) do
+          set_line_and_column(line_and_column)
+        end
+      end
+
+      # variable
+      rule(:variable => simple(:v)) do
+        line_and_column = v.line_and_column
+        Model::Variable.new(v) do
+          set_line_and_column(line_and_column)
+        end
+      end
+
+      # data_name
+      # escape characters are substituted
+      rule(:data_name => simple(:name)) do
+        line_and_column = name.line_and_column
+        Model::DataExpr.new(name.str.gsub(/\\(.)/) {$1}) do
+          set_line_and_column(line_and_column)
+        end
+      end
+
+      # package_name
+      rule(:package_name => simple(:name)) do
+        line_and_column = name.line_and_column
+        Model::Package.new(name) do
+          set_line_and_column(line_and_column)
+        end
+      end
+
+      # rule_name
+      rule(:rule_name => simple(:name)) do
+        line_and_column = name.line_and_column
+        RuleExpr.new(
+          Package.new(Thread.current[:current_package_name]),
+          name
+        ) do
+          set_line_and_column(line_and_column)
+        end
+      end
+    end
+  end
+end