pione 0.4.2 → 0.5.0.alpha.1

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

@@ -64,7 +64,7 @@ module Pione
       # @example
       #   {a: 1, b: 2, c: 3}
       rule(:parameter_set) {
-        (lbrace.as(:header) >> padded?(parameter_set_elements.maybe.as(:elements)) >> rbrace!).as(:parameter_set)
+        (lbrace.as(:header) >> padded?(parameter_set_elements.maybe.as(:elements)) >> rbrace!.as(:footer)).as(:parameter_set)
       }
 
       # +parameter_set_elements+ matches elements of parameter set.
@@ -72,7 +72,7 @@ module Pione
       # @example
       #   a: 1, b: 2, c: 3
       rule(:parameter_set_elements) {
-        parameter_set_element >> (padded?(comma) >> parameter_set_element).repeat
+        parameter_set_element >> (padded?(comma).as(:separator) >> parameter_set_element).repeat
       }
 
       # +parameter_set_element+ matches each element of parameter set.

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

@@ -105,6 +105,9 @@ module Pione
       rule(:parameter_set_element => subtree(:tree)) {
         OpenStruct.new(key: tree[:key].str, value: tree[:value])
       }
+      rule(:separator => simple(:sep), :parameter_set_element => subtree(:tree)) {
+        OpenStruct.new(key: tree[:key].str, value: tree[:value])
+      }
 
       # Transform +feature+ into FeatureSequence.
       rule(:feature => simple(:piece)) do

data/lib/pione/lang/message.rb

@@ -8,10 +8,10 @@ module Pione
 
       # Return PIONE model type of the message result according to type interface.
       def pione_type(env)
-        if pione_method = receiver.pione_type.find_method(env, name, receiver, arguments)
-          pione_method.get_output_type(receiver)
+        if pione_method = receiver.pione_type(env).find_method(env, name, receiver, arguments)
+          pione_method.get_output_type(env, receiver)
         else
-          raise MethodNotFound.new(name.to_s, receiver, arguments)
+          raise MethodNotFound.new(env, name.to_s, receiver, arguments)
         end
       end
 

data/lib/pione/lang/ordinal-sequence.rb

@@ -2,7 +2,7 @@ module Pione
   module Lang
     # OridinalSequence is a sequence that has an ordinal number index.
     class OrdinalSequence < Sequence
-      index_type TypeInteger
+      set_index_type TypeInteger
       member :separator, default: " "
 
       class << self

data/lib/pione/lang/package-expr.rb

@@ -28,7 +28,7 @@ module Pione
     end
 
     class PackageExprSequence < OrdinalSequence
-      pione_type TypePackageExpr
+      set_pione_type TypePackageExpr
       piece_class PackageExpr
     end
 

data/lib/pione/lang/parameters.rb

@@ -89,7 +89,7 @@ module Pione
     end
 
     class ParameterSetSequence < OrdinalSequence
-      pione_type TypeParameterSet
+      set_pione_type TypeParameterSet
       piece_class ParameterSet
 
       def each

data/lib/pione/lang/pione-method.rb

@@ -39,13 +39,13 @@ module Pione
 
       # Call the method with recevier and arguemnts.
       def call(env, receiver, args)
-        _output = receiver.pione_type.instance_exec(env, receiver, *args, &body)
+        _output = receiver.pione_type(env).instance_exec(env, receiver, *args, &body)
         if _output.nil?
           p self
           p receiver
           p args
         end
-        validate_output(receiver, _output)
+        validate_output(env, receiver, _output)
         return _output
       end
 
@@ -57,14 +57,14 @@ module Pione
       #   arguments
       # @return [Boolean]
       #   true if input data are valid
-      def validate_inputs(rec, args)
+      def validate_inputs(env, rec, args)
         # check size
         return false unless inputs.size == args.size
 
         # check type
         inputs.each_with_index do |input, i|
-          input = get_type(input, rec)
-          unless input.match(args[i])
+          input = get_type(env, input, rec)
+          unless input.match(env, args[i])
             return false
           end
         end
@@ -72,34 +72,34 @@ module Pione
       end
 
       # Validate output data type for the method.
-      def validate_output(receiver, value)
-        _output = get_type(output, receiver)
-        unless _output.match(value)
+      def validate_output(env, receiver, value)
+        _output = get_type(env, output, receiver)
+        unless _output.match(env, value)
           raise MethodInterfaceError.new(:output, name, [_output], [value])
         end
       end
 
       # Get the input types of receiver.
-      def get_input_types(receiver)
-        inputs.map{|input| get_type(input, receiver)}
+      def get_input_types(env, receiver)
+        inputs.map{|input| get_type(env, input, receiver)}
       end
 
       # Get the output type of receiver.
-      def get_output_type(receiver)
-        get_type(output, receiver)
+      def get_output_type(env, receiver)
+        get_type(env, output, receiver)
       end
 
       private
 
       # Get a type object.
-      def get_type(type, receiver)
+      def get_type(env, type, receiver)
         case type
         when :index_type
-          receiver.index_type
+          receiver.index_type(env)
         when :element_type
-          receiver.element_type
+          receiver.element_type(env)
         when :receiver_type
-          receiver.pione_type
+          receiver.pione_type(env)
         else
           type
         end

data/lib/pione/lang/rule-expr.rb

@@ -13,7 +13,7 @@ module Pione
 
     # RuleExprSequence is a ordinal sequence of rule expressions.
     class RuleExprSequence < OrdinalSequence
-      pione_type TypeRuleExpr
+      set_pione_type TypeRuleExpr
       piece_class RuleExpr
     end
 
@@ -65,6 +65,11 @@ module Pione
         # concat sequence
         left + right
       end
+
+      # Specify entrance rule of the package.
+      define_pione_method("Entrance", [], TypeRuleExpr) do |env, rec|
+        rec.set_annotation_type("Entrance")
+      end
     end
   end
 end

data/lib/pione/lang/sequence.rb

@@ -22,7 +22,7 @@ module Pione
         def inherited(subclass)
           members.each {|member_name| subclass.member(member_name, default: default_values[member_name])}
           subclass.immutable true
-          subclass.index_type(index_type)
+          subclass.set_index_type(index_type(nil))
         end
 
         # Get/set piece class.
@@ -35,8 +35,13 @@ module Pione
         end
 
         # Set the index type.
-        def index_type(type=nil)
-          type ? @index_type = type : @index_type
+        def index_type(env)
+          @index_type
+        end
+
+        # Set the index type.
+        def set_index_type(type)
+          @index_type = type
         end
       end
 

data/lib/pione/lang/string.rb

@@ -11,7 +11,7 @@ module Pione
     end
 
     class StringSequence < OrdinalSequence
-      pione_type TypeString
+      set_pione_type TypeString
       piece_class PioneString
 
       # Return a string that is joined pieces string.

data/lib/pione/lang/ticket-expr.rb

@@ -23,7 +23,7 @@ module Pione
 
     # TicketExprSequence is a ordinal sequence of ticket expressions.
     class TicketExprSequence < OrdinalSequence
-      pione_type TypeTicketExpr
+      set_pione_type TypeTicketExpr
       piece_class TicketExpr
 
       # Return ticket names of all elements in the sequence.

data/lib/pione/lang/type.rb

@@ -24,8 +24,8 @@ module Pione
       #   matching test target
       # @return [Boolean]
       #   true if it matches, or false
-      def match(target)
-        target_type = target.pione_type
+      def match(env, target)
+        target_type = target.pione_type(env)
         while target_type do
           return true if self == target_type
           target_type = target_type.parent_type
@@ -41,14 +41,18 @@ module Pione
 
           # exist deferred methods
           if group.has_key?(:deferred)
-            if m = group[:deferred].find {|m| m.validate_inputs(rec, args)}
+            if m = group[:deferred].find {|m| m.validate_inputs(env, rec, args)}
               return m
             end
           end
 
           # try immediate methods
           _args = args.map {|arg| arg.eval(env)} # FIXME : should be replaced by type inference
-          return group[:immediate].find {|m| m.validate_inputs(rec, _args)}
+          if group.has_key?(:immediate)
+            return group[:immediate].find {|m| m.validate_inputs(env, rec, _args)}
+          else
+            return nil
+          end
         end
 
         # find from parent type
@@ -70,9 +74,9 @@ module Pione
       # Return true if the data has the type.
       #
       # @return [void]
-      def check(data)
-        unless match(data)
-          raise LangTypeError.new(data, self)
+      def check(env, data)
+        unless match(env, data)
+          raise LangTypeError.new(data, self, env)
         end
       end
 
@@ -212,8 +216,13 @@ module Pione
     # ticket expression type
     TypeTicketExpr = Type.new("ticket-expr", TypeOrdinalSequence)
 
-    def TypeSequence.match(other)
+    def TypeSequence.match(env, target)
       true
     end
+
+    # Type variable matches variable object.
+    def TypeVariable.match(env, target)
+      target.kind_of?(Variable)
+    end
   end
 end

data/lib/pione/lang/variable.rb

@@ -8,10 +8,13 @@ module Pione
     #   is a concept of elements joined by sequencial operators and the
     #   receivers should be evaluated.
     class Variable < Expr
-      pione_type TypeVariable
       member :name
       member :package_id
 
+      def pione_type(env)
+        env.variable_get(self).pione_type(env)
+      end
+
       # Get the value from variable table in the environment.
       def eval(env)
         env.variable_get(self)

data/lib/pione/literate-action.rb

@@ -1,10 +1,9 @@
 module Pione
   module LiterateAction
-
   end
 end
 
-require 'pione/literate-action/parser'   # literate action parser
+require 'pione/literate-action/markdown-parser'   # literate action parser
 require 'pione/literate-action/document' # literate action document
 require 'pione/literate-action/handler'  # action handler
 

data/lib/pione/literate-action/document.rb

@@ -7,7 +7,7 @@ module Pione
       end
 
       def initialize(src)
-        @action = Parser.parse(src)
+        @action = MarkdownParser.parse(src)
       end
 
       # Return action rule names in the document.

data/lib/pione/literate-action/handler.rb

@@ -1,24 +1,39 @@
 module Pione
   module LiterateAction
-    # Handler is action rule handler.
+    # Handler handles action documents.
     class Handler
       def initialize(action)
-        @lang = action[:lang]
+        @lang = action[:lang] || "sh"
         @content = action[:content]
       end
 
       # Convert the action to a string.
-      def textize(domain_info)
+      def textize(domain_dump)
         @content.to_s
       end
 
       # Execute the action.
-      def execute(domain_info, dir=Location[Global.pwd])
-        text = textize(domain_info)
+      #
+      # @param options [Hash]
+      #   the options
+      # @option options [DomainDump] :domain_dump
+      #   domain dump
+      # @option options [Loacation] :chdir
+      #   the location of working directory for action
+      # @option options [Location] :out
+      #   the file writing STDOUT
+      # @return [Boolean]
+      #   true if the action succeeded
+      def execute(options={})
         location = Location[Temppath.create]
-        location.write(("#!/usr/bin/env %s\n" % @lang) + text)
+        location.write(("#!/usr/bin/env %s\n" % @lang) + textize(options[:domain_dump]))
         location.path.chmod(0700)
-        `cd #{dir.path}; #{location.path}`
+
+        _options = {}
+        _options[:chdir] = options[:chdir] ? options[:chdir].path.to_s : Location[Global.pwd].path.to_s
+        _options[:out] = options[:out].path.to_s if options.has_key?(:out)
+
+        return system(location.path.to_s, _options)
       end
     end
   end

data/lib/pione/literate-action/{parser.rb → markdown-parser.rb}

@@ -1,6 +1,7 @@
 module Pione
   module LiterateAction
-    class Parser
+    # MarkdownParser is a parser for literate action document.
+    class MarkdownParser
       # Parse the source string and return the result.
       def self.parse(src)
         new(src).parse

data/lib/pione/log/domain-log.rb

@@ -33,7 +33,7 @@ module Pione
           :dry_run => handler.dry_run.to_s
         }
         if handler.respond_to?(:working_directory)
-          @record[:working_directory] = handler.working_directory.uri.to_s
+          @record[:working_directory] = handler.working_directory.location.uri.to_s
         end
       end
 

data/lib/pione/model/task-worker-broker-model.rb

@@ -46,7 +46,7 @@ module Pione
               @task_workers << spawner.child_front
               spawner.when_terminated {delete_task_worker(spawner.child_front)}
             rescue Command::SpawnError => e
-              Log::Debug.system("Task worker broker agent failed to spawn a task worker: %e" % e.message)
+              Log::Debug.system("Task worker broker agent failed to spawn a task worker: %s" % e.message)
               res = false
             end
           else

data/lib/pione/package/package-database.rb

@@ -75,6 +75,20 @@ module Pione
         @table[name][editor || "origin"][tag]
       end
 
+      # Return true if the package exists in database.
+      #
+      # @param [String] name
+      #   package name
+      # @param [String] editor
+      #   editor name
+      # @param [String] tag
+      #   tag name
+      # @return [Boolean]
+      #   true if the package exists in database
+      def exist?(name, editor, tag)
+        not(find(name, editor, tag).nil?)
+      end
+
       # Save the database to the location.
       def save(location=Global.package_database_location)
         json = JSON.generate(self)
@@ -92,7 +106,7 @@ module Pione
       # Convert to JSON.
       def to_json(*args)
         @table.each_with_object([]) do |(_, t1), list|
-          t1.each{|_, t2| t2.each{|_, record| list << record}}
+          t1.each{|_, t2| t2.each{|_, record| list << record if record}}
         end.to_json(*args)
       end
     end
@@ -109,7 +123,7 @@ module Pione
       def to_json(*args)
         data = Hash.new
         data["PackageName"] = name
-        data["Editor"] = editor
+        data["Editor"] = editor || "origin"
         data["Tag"] = tag
         data["Location"] = location if location
         data["State"] = state if state

data/lib/pione/package/package-exception.rb

@@ -6,7 +6,7 @@ module Pione
     class NotFound < PackageError
       def initialize(name, editor, tag)
         @name = name
-        @editor = eidition
+        @editor = editor
         @tag = tag
       end