pione 0.1.1 → 0.1.2

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

@@ -12,6 +12,10 @@ module Pione
       #   +expr+ matches all expressions in PIONE document.
       #   @return [Parslet::Atoms::Entity] +expr+ atom
       #   @example
+      #     "abc"[0]
+      #   @example
+      #     'abc'.as_string
+      #   @example
       #     1 + 1
       #   @example
       #     (1 + 1).next
@@ -24,31 +28,52 @@ module Pione
       rule(:expr) {
         ( expr_operator_application |
           assignment |
-          (expr_element.as(:receiver) >>
-            (index | message).repeat(1).as(:messages)) |
+          expr_prepositional_messages.as(:reverse_messages) >> pad? >> expr.as(:receiver) |
           expr_element
         ).as(:expr)
       }
 
+
+      # @!attribute [r] expr_prepositional_messages
+      #   +expr_messages+ matches prepositional messages.
+      #   @return [Parslet::Atoms::Entity] +expr_prepositional_messages+ atom
+      rule(:expr_prepositional_messages) {
+        (pad? >> reverse_message).repeat(1)
+      }
+
+      # @!attribute [r] expr_postpositional_messages
+      #   +expr_messages+ matches postpositional messages.
+      #   @return [Parslet::Atoms::Entity] +expr_post_positional_messages+ atom
+      rule(:expr_postpositional_messages) {
+        (pad? >> (index | message | parameters.as(:postpositional_parameters))).repeat(1)
+      }
+
       # @!attribute [r] expr_element
       #   +expr_element+ matches simple expressions.
       #   @return [Parslet::Atoms::Entity] +expr_element+ atom
       #   @example
       #     true
       #   @example
-      #     "abc"[0]
+      #     (1 + 1)
       #   @example
-      #     'abc'.as_string
+      #     ("abc".index(1, 1))
+      rule(:expr_element) {
+        expr_basic_element.as(:receiver) >> expr_postpositional_messages.as(:messages) |
+        expr_basic_element
+      }
+
+      # @!attribute [r] expr_element
+      #   +expr_element+ matches simple expressions.
+      #   @return [Parslet::Atoms::Entity] +expr_element+ atom
+      #   @example
+      #     true
       #   @example
       #     (1 + 1)
       #   @example
       #     ("abc".index(1, 1))
-      rule(:expr_element) {
-        ( (atomic_expr.as(:receiver) >> indexes) |
-          (atomic_expr.as(:receiver) >> messages) |
-          atomic_expr |
-          lparen >> expr >> rparen
-        )
+      rule(:expr_basic_element) {
+        atomic_expr |
+        lparen >> expr >> rparen
       }
 
       # @!attribute [r] atomic_expr
@@ -57,6 +82,8 @@ module Pione
       #   @example
       #     true
       #   @example
+      #     false
+      #   @example
       #     0.1
       #   @example
       #     1
@@ -67,6 +94,8 @@ module Pione
       #   @example
       #     '*.txt'
       #   @example
+      #     null
+      #   @example
       #     {var: 1}
       #   @example
       #     $abc:test
@@ -77,6 +106,7 @@ module Pione
         float |
         integer |
         string |
+        ticket |
         data_name |
         rule_expr |
         feature_expr |
@@ -106,10 +136,12 @@ module Pione
       #   @example
       #     :=, ==, !=, >=, >, <=, <, &&, ||, +, -, *, /, %, or, and
       rule(:expr_operator) {
+        equals >> equals >> greater_than |
         equals >> equals |
         exclamation >> equals |
         less_than >> equals |
         less_than |
+        greater_than >> greater_than >> greater_than |
         greater_than >> equals |
         greater_than |
         ampersand >> ampersand |
@@ -151,21 +183,12 @@ module Pione
         ).as(:assignment)
       }
 
-      # @!attribute [r] messages
-      #   +messages+ matches message list.
-      #   @return [Parslet::Atoms::Entity] +messages+ atom
-      #   @example
-      #     .params("-w").sync
-      rule(:messages) {
-        message.repeat(1).as(:messages)
-      }
-
       # @!attribute [r] message
       #   +message+ matches message sending.
       #   @return [Parslet::Atoms::Entity] +message+ atom
       #   @example
       #     # message with no arguments
-      #     .to_string
+      #     .as_string
       #   @example
       #     # message with arguments
       #     .params("-w")
@@ -176,6 +199,23 @@ module Pione
         ).as(:message)
       }
 
+      # @!attribute [r] reverse_message
+      #   +message+ matches reverse message sending.
+      #   @return [Parslet::Atoms::Entity] +reverse_message+ atom
+      #   @example
+      #     # message with no arguments
+      #     as_string ::
+      #   @example
+      #     # message with arguments
+      #     params("-w") ::
+      rule(:reverse_message) {
+        ( identifier.as(:message_name) >>
+          message_parameters.maybe >>
+          pad? >>
+          colon >> colon
+        ).as(:message)
+      }
+
       # @!attribute [r] message_parameters
       #   +message_parameters+ matches message parameters.
       #   @return [Parslet::Atoms::Entity] +message_parameters+ atom
@@ -211,14 +251,9 @@ module Pione
         pad? >> comma >> pad? >> expr
       }
 
-      # @!attribute [r] indexes
-      #   +indexes+ matches object index list.
-      #   @return [Parslet::Atoms::Entity] +indexes+ atom
-      #   @example
-      #     [1][2][3]
-      rule(:indexes) {
-        index.repeat(1).as(:indexes)
-      }
+      #
+      # INDEX
+      #
 
       # @!attribute [r] index
       #   +index+ matches object index.
@@ -227,13 +262,17 @@ module Pione
       #     [1]
       #     [1,1]
       #     [1,2,3]
+      #     ["a"]
+      #     ["a", "b", "c"]
+      #   @example
+      #     [Var: 1]
       rule(:index) {
         ( lsbracket >>
-          space? >>
+          pad? >>
           ( index_arguments.as(:index) |
             syntax_error("it should be index arguments", :expr)) >>
-          space? >>
-          rsbracket
+          pad? >>
+          (rsbracket | syntax_error("it should be index end ']'"))
         )
       }
 
@@ -245,21 +284,19 @@ module Pione
       #     1,1
       #     1,2,3
       rule(:index_arguments) {
-        expr.repeat(1,1) >> space? >> index_arguments_rest.repeat
+        expr.repeat(1,1) >> pad? >> index_arguments_rest.repeat
       }
 
       # @!attribute [r] index_arguments_rest
-      #   +index_arguments_rest+ matches argument tail of object index.
+      #   +index_arguments_rest+ matches tail elements in index expression.
       #   @return [Parslet::Atoms::Entity] +index_arguments_rest+ atom
       #   @example
       #     ,1
       rule(:index_arguments_rest) {
-        space? >>
+        pad? >>
         comma >>
-        space? >>
-        ( expr |
-          syntax_error("it should be expr", :expr)
-        )
+        pad? >>
+        (expr | syntax_error("it should be expr", :expr))
       }
     end
   end

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

@@ -177,6 +177,20 @@ module Pione
           syntax_error("it should be parameter key", :identifier)
         )
       }
+
+      # @!attribute [r] ticket
+      # +ticket+ matches ticket object.
+      #
+      # @return [Parslet::Atoms::Entity] +ticket+ atom
+      # @example
+      #   &Main
+      rule(:ticket) {
+        less_than >>
+        space? >>
+        identifier.as(:ticket) >>
+        space? >>
+        greater_than
+      }
     end
   end
 end

data/lib/pione/parser/parslet-extension.rb

@@ -0,0 +1,143 @@
+module Pione
+  module Parser
+    # ParserError is raised when the parser finds syntax error.
+    class ParserError < Parslet::ParseFailed
+      # Creates an error.
+      # @param [String] str
+      #   target string
+      # @param [Array<String>] expected
+      #   expected names
+      # @param [Parslet::Source] source
+      #   parser source
+      def initialize(str, expected, source)
+        @str = str
+        @expected = expected
+        @source = source
+        super(str)
+      end
+
+      # @api private
+      def message
+        line, column = @source.line_and_column
+        expected = @expected.join(", ")
+        left = @source.consume(@source.chars_left)
+        "%s(expected: %s, line: %s, column: %s):\n%s" % [
+          @str, expected, line, column, left
+        ]
+      end
+    end
+
+    # @api private
+    class SyntaxErrorAtom < Parslet::Atoms::Base
+      def initialize(msg, expected_elements=[], ignore_error)
+        @msg = msg
+        @expected_elements = expected_elements
+        @ignore_error = ignore_error
+      end
+
+      def try(source, context, _)
+        raise ParserError.new(@msg, @expected_elements, source)
+      end
+
+      def to_s_inner(prec)
+        "SYNTAX_ERROR"
+      end
+    end
+
+    class IgnoreErrorAtom < Parslet::Atoms::Base
+      def initialize(atom)
+        @atom = atom
+      end
+
+      def try(source, context)
+        begin
+          @atom.apply(source, context)
+        rescue ParserError
+          context.err(self, source, "", [])
+        end
+      end
+
+      def to_s_inner(prec)
+        "IGNORE_ERROR"
+      end
+    end
+
+    # SyntaxError provides notification methods for syntax error.
+    module SyntaxError
+      # Raises syntax error. This method returns a dummy atom and the parser
+      # evaluates it as error.
+      # @param [String] msg
+      #   error message
+      # @param [Array<String>] expected_elements
+      #   expected name list
+      # @return [SyntaxErrorAtom]
+      #   dummy atom for parser
+      def syntax_error(msg, *expected_elements)
+        SyntaxErrorAtom.new(msg, expected_elements, $ignore_error)
+      end
+
+      def ignore_error(&b)
+        res = yield
+        return IgnoreErrorAtom.new(res)
+      end
+    end
+
+    class IgnoreAtom < Parslet::Atoms::Base
+      def initialize(atom)
+        @atom = atom
+      end
+
+      def try(source, context, consume_all)
+        success, _ = result = @atom.try(source, context, consume_all)
+        return sucess ? succ(nil) : result
+      end
+
+      def to_s_inner(prec)
+        "IGNORE"
+      end
+    end
+
+    module Ignore
+      def ignore
+        IgnoreAtom.new(self)
+      end
+    end
+
+    class ExceptionAtom < Parslet::Atoms::Base
+      def initialize(atom, exception)
+        @atom = atom
+        @exception = exception
+      end
+
+      def try(source, context)
+        success, value = result = @atom.apply(source, context)
+        if success
+          esuccess, _ = @exception.apply(source, context)
+          p @exception
+          p source
+          p esuccess
+          if esuccess
+            return result
+          end
+        end
+        return result
+      end
+
+      def to_s_inner(prec)
+        "EXCEPTION"
+      end
+    end
+
+    module Exception
+      def except(exception)
+        #ExceptionAtom.new(self, exception)
+        ExceptionAtom.new(self, exception)
+      end
+    end
+  end
+end
+
+class Parslet::Atoms::Base
+  include Pione::Parser::Ignore
+  include Pione::Parser::Exception
+end

data/lib/pione/rule-handler/flow-handler.rb

@@ -69,10 +69,35 @@ module Pione
 
       # Finds applicable flow-element rules with inputs and variables.
       def find_applicable_rules(callees)
-        callees.inject([]) do |combinations, callee|
-          # eval callee expr by handling rule context
-          callee = callee.eval(@variable_table)
+        callees = callees.inject([]) do |list, callee|
+          # evaluate callee expr by handling rule context
+          # and expand compositional rule expressions as simple rule expressions
+          list + callee.eval(@variable_table).expr.to_set.to_a.map{|expr| CallRule.new(expr)}
+        end
+
+        # ticket check
+        callees = callees.inject([]) do |list, callee|
+          target = nil
+          # check if tickets exist in the domain
+          names = callee.expr.input_ticket_expr.names
+          if not(names.empty?)
+            if names.all? do |name|
+              begin
+                read0(Tuple[:ticket].new(@domain, name))
+                true
+              rescue Rinda::RequestExpiredError
+                false # when the ticket doesn't exist
+              end
+            end
+              target = callee
+            end
+          else
+            target = callee
+          end
+          target ? list << callee : list
+        end
 
+        callees.inject([]) do |combinations, callee|
           # find callee rule
           rule = find_callee_rule(callee)
 
@@ -211,6 +236,11 @@ module Pione
           # copy data from task domain to this domain
           @finished << finished
           copy_data_into_domain(finished.outputs, @domain)
+
+          # output ticket
+          callee.expr.output_ticket_expr.names.each do |name|
+            write(Tuple[:ticket].new(@domain, name))
+          end
         end
 
         user_message_end("End Task Distribution: %s" % handler_digest)

data/lib/pione/system/global.rb

@@ -21,10 +21,10 @@ module Pione
         # @param [Object] val
         #   default value
         # @return [void]
-        def define_item(name, config, val=nil, &b)
+        def define_item(name, configurable, val=nil, &b)
           @__names__ << name
-          if config
-            @__config__[name] = config.kind_of?(TrueClass) ? name : config
+          if configurable
+            @__config__[name] = configurable ? name : config
           end
 
           singleton_class.module_eval do |mod|
@@ -90,6 +90,13 @@ module Pione
       # system
       #
 
+      # @!method monitor
+      # Global monitor object for PIONE system.
+      #
+      # @return [Monitor]
+      #   monitor object
+      define_item(:monitor, false, Monitor.new)
+
       # .pione dir
       define_item(:dot_pione_dir, true) do
         Pathname.new("~/.pione").expand_path.tap {|path|