pione 0.2.2 → 0.3.0

data/lib/pione/util/ftp-server.rb

@@ -296,15 +296,14 @@ module Pione
           @fs = fs
           @thread = Thread.new do
             EventMachine.run do
-              EventMachine.start_server("0.0.0.0", @port, EM::FTPD::Server, self)
+              @sig = EventMachine.start_server("0.0.0.0", @port, EM::FTPD::Server, self)
             end
           end
         end
 
         def stop
-          if EventMachine.reactor_running?
-            EventMachine.stop
-          end
+          EventMachine.stop_event_loop
+          EventMachine.reactor_thread.join
           @thread.kill if @thread
         end
 

data/lib/pione/util/id.rb

@@ -3,35 +3,40 @@ module Pione
     # ID is a set of ID generators.
     module TaskID
       # Make a task id by input data names and parameters.
-      #
-      # @param inputs [Array<Tuple::DataTuple>]
-      #   input data tuples
-      # @param params [Model::Parameters]
-      #   parameters object
-      # @return [String]
-      #   task's digest string
       def generate(inputs, params)
-        input_names = inputs.map{|t| t.name}
-        Digest::MD5.hexdigest("%s,%s" % [input_names.join(":"), params.textize])
+        # NOTE: auto variables are ignored
+        param_set = params.filter(["I", "INPUT", "O", "OUTPUT", "*"])
+        inputs = inputs.map {|t| t.is_a?(TupleSpace::DataTuple) ? t.name : t}
+        Digest::MD5.hexdigest("%s::%s" % [inputs.join(":"), param_set.textize])
       end
       module_function :generate
     end
 
     module DomainID
-      # Make a domain id by rule, inputs, and parameters.
-      #
-      # @param rule [Component::Rule]
-      #   rule
-      # @param inputs [Array<Tuple::DataTuple>]
-      #   input data tuples
-      # @param params [Model::Parameters]
-      #   parameters
-      # @return [String]
-      #   domain id string
-      def generate(rule, inputs, params)
-        package_name = rule.package_name
-        rule_name = rule.name
-        "%s-%s_%s" % [package_name, rule_name, TaskID.generate(inputs.flatten, params)]
+      # Make a domain id based on package id, rule name, inputs, and parameter set.
+      def generate(package_id, rule_name, inputs, params)
+        "%s:%s:%s" % [package_id, rule_name, TaskID.generate(inputs.flatten, params)]
+      end
+      module_function :generate
+    end
+
+    module PackageID
+      # Generate package id from the package name in the environment.
+      def generate(env, package_name)
+        begin
+          env.package_get(Lang::PackageExpr.new(name: package_name, package_id: package_name))
+          i = 0
+          loop do
+            i += 1
+            name = "%s-%s" % [package_name, i]
+            unless env.package_ids.include?(name)
+              env.package_ids << name
+              return name
+            end
+          end
+        rescue Lang::UnboundError
+          return package_name
+        end
       end
       module_function :generate
     end

data/lib/pione/util/misc.rb

@@ -5,11 +5,23 @@ module Pione
       # @yield []
       #   target block
       # @return [void]
-      def ignore_exception(&b)
+      def ignore_exception(*exceptions, &b)
+        exceptions = [Exception] if exceptions.empty?
+        b.call
+      rescue *exceptions => e
+        Log::Debug.ignored_exception(e)
+        return false
+      end
+
+      def error?(option={}, &b)
+        sec = option[:timeout]
         begin
-          b.call
-        rescue Exception => e
-          ErrorReport.warn("the error ignored", nil, e, __FILE__, __LINE__)
+          timeout(sec) do
+            b.call
+            false
+          end
+        rescue Object => e
+          true
         end
       end
 
@@ -19,6 +31,12 @@ module Pione
       def hostname
         Socket.gethostname
       end
+
+      def parse_features(textual_features)
+        stree = Lang::DocumentParser.new.expr.parse(textual_features)
+        opt = {package_name: "*feature*", filename: "*feature*"}
+        Lang::DocumentTransformer.new.apply(stree, opt)
+      end
     end
 
     extend Misc

data/lib/pione/util/package-parameters-list.rb

@@ -2,16 +2,19 @@ module Pione
   module Util
     module PackageParametersList
       class << self
-        # Print parameters list of the package.
+        # Print parameter list of the package.
         #
-        # @param package [Component::Package]
+        # @param package [Package::Package]
         #   package
-        def print(package)
-          unless package.params.empty?
-            print_params_by_block("Basic Parameters", package.params.basic)
-            print_params_by_block("Advanced Parameters", package.params.advanced)
+        def print(env, package_id)
+          definition = env.package_get(Lang::PackageExpr.new(package_id: package_id))
+          params = definition.param_definition.values
+          if params.size > 0
+            group = params.group_by {|param| param.type}
+            print_params_by_block("Basic Parameters", group[:basic]) if group[:basic]
+            print_params_by_block("Advanced Parameters", group[:advanced]) if group[:advanced]
           else
-            puts "there are no user parameters in %s" % package.name
+            puts "there are no user parameters in %s" % env.current_package_id
           end
         end
 
@@ -21,8 +24,8 @@ module Pione
         def print_params_by_block(header, target_params)
           unless target_params.empty?
             puts "%s:" % header
-            target_params.data.each do |var, val|
-              puts "  %s := %s" % [var.name, val.textize]
+            target_params.each do |param|
+              puts "  %s := %s" % [param.name, param.value.textize]
             end
           end
         end

data/lib/pione/{parser → util}/parslet-extension.rb

@@ -1,33 +1,6 @@
 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
+  module Util
+    # SyntaxErrorAtom is a special parslet atom for +on_error+ helper method.
     class SyntaxErrorAtom < Parslet::Atoms::Base
       def initialize(msg, expected_elements=[], ignore_error)
         @msg = msg
@@ -35,8 +8,9 @@ module Pione
         @ignore_error = ignore_error
       end
 
+      # Raise a +ParserError+ when this atom is touched.
       def try(source, context, _)
-        raise ParserError.new(@msg, @expected_elements, source)
+        raise Lang::ParserError.new(@msg, @expected_elements, source)
       end
 
       def to_s_inner(prec)
@@ -44,6 +18,7 @@ module Pione
       end
     end
 
+    # IgnoreErrorAtom is a parslet atom for +except+ helper method.
     class IgnoreErrorAtom < Parslet::Atoms::Base
       def initialize(atom)
         @atom = atom
@@ -52,7 +27,7 @@ module Pione
       def try(source, context)
         begin
           @atom.apply(source, context)
-        rescue ParserError
+        rescue Lang::ParserError
           context.err(self, source, "", [])
         end
       end
@@ -62,26 +37,6 @@ module Pione
       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
@@ -97,12 +52,6 @@ module Pione
       end
     end
 
-    module Ignore
-      def ignore
-        IgnoreAtom.new(self)
-      end
-    end
-
     class ExceptionAtom < Parslet::Atoms::Base
       def initialize(atom, exception)
         @atom = atom
@@ -113,9 +62,6 @@ module Pione
         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
@@ -128,16 +74,81 @@ module Pione
       end
     end
 
-    module Exception
+    # ParsletParserExtension provides parser helper methods.
+    module ParsletParserExtension
+      def ignore
+        IgnoreAtom.new(self)
+      end
+
       def except(exception)
-        #ExceptionAtom.new(self, exception)
         ExceptionAtom.new(self, exception)
       end
+
+      # Create a special atom that raises +ParserError+ when it is tried.
+      def or_error(msg, *expected_elements)
+        self | SyntaxErrorAtom.new(msg, expected_elements, $ignore_error)
+      end
+
+      # 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 should(atom, msg, *expected_elements)
+        atom | syntax_error(msg, *expected_elements)
+      end
+
+      def ignore_error(&b)
+        res = yield
+        return IgnoreErrorAtom.new(res)
+      end
+    end
+
+    # +ParsletTransformerModule+ enables parslet's transforms to be defined by
+    # multiple modules.
+    module ParsletTransformerModule
+      class << self
+        # @api private
+        def included(mod)
+          singleton = class << mod; self; end
+          create_pair_by(Parslet, Parslet::Transform).each do |name, orig|
+            singleton.__send__(:define_method, name) do |*args, &b|
+              orig.__send__(name, *args, &b)
+            end
+          end
+
+          class << mod
+            def included(klass)
+              name = :@__transform_rules
+              klass_rules = klass.instance_variable_get(name)
+              klass_rules = klass_rules ? klass_rules + rules : rules
+              klass.instance_variable_set(name, klass_rules)
+            end
+          end
+        end
+
+        private
+
+        # Create module and the methods pair by modules.
+        #
+        # @api private
+        def create_pair_by(*mods)
+          mods.inject([]) do |list, mod|
+            list + (mod.methods.sort - Object.methods.sort).map{|m| [m, mod]}
+          end
+        end
+      end
     end
   end
 end
 
 class Parslet::Atoms::Base
-  include Pione::Parser::Ignore
-  include Pione::Parser::Exception
+  include Pione::Util::ParsletParserExtension
 end

data/lib/pione/util/positionable.rb

@@ -0,0 +1,65 @@
+module Pione
+  module Util
+    # Positionable provides the function that stores its source position
+    # information to objects.
+    module Positionable
+      # Set source position informations of the object.
+      #
+      # @example Specify package name, filename, line number, and column number
+      #   obj = Object.new.tap {|x| x.extend Positionable}
+      #   obj.set_source_position("HelloWorld", "HelloWorld.pione", 1, 1)
+      #
+      # @example SourcePosition object
+      #   obj = Object.new.tap {|x| x.extend Positionable}
+      #   obj.set_source_position(other.pos)
+      def set_source_position(*args)
+        if args.size == 1 and args[0].is_a?(SourcePosition)
+          @__source_position__ = args[0]
+        elsif args.size > 0
+          @__source_position__ = SourcePosition.new(*args)
+        end
+      end
+
+      # Return the source position.
+      def pos
+        @__source_position__ || SourcePosition.unknown
+      end
+
+      # Return the line and column. If source position isn't established, return
+      # nil simply.
+      def line_and_column
+        if @__source_position__
+          return @__source_position__.line, @__source_position__.column
+        end
+      end
+    end
+
+    # SourcePosition represents source position model of PIONE and defines its
+    # string format.
+    class SourcePosition < StructX
+      class << self
+        def unknown
+          @unknown ||= UnknownSourcePosition.new
+        end
+      end
+
+      member :package_name
+      member :filename
+      member :line
+      member :column
+
+      def format
+        args = [package_name, filename, line, column]
+        "(package %s, file %s, line %s, column %s)" % args
+      end
+    end
+
+    class UnknownSourcePosition < StructX
+      member :dummy
+
+      def format
+        ""
+      end
+    end
+  end
+end

data/lib/pione/util/zip.rb

@@ -17,14 +17,16 @@ module Pione
           _archive = Location[Temppath.create]
 
           # compress
-          ::Zip::Archive.open(_archive.path.to_s, ::Zip::CREATE) do |ar|
+          ::Zip::File.open(_archive.path.to_s, ::Zip::File::CREATE) do |zip|
             _src.rel_entries(rec: true).each do |relpath|
               relpath = relpath.to_s
               location = _src + relpath
               if location.directory?
-                ar.add_dir(relpath)
+                zip.mkdir(relpath)
               else
-                ar.add_file(relpath, location.path.to_s)
+                entry = zip.add(relpath, location.path.to_s)
+                entry.time = ::Zip::DOSTime.at(location.mtime)
+                entry.extra.delete("UniversalTime")
               end
             end
           end
@@ -41,18 +43,17 @@ module Pione
         #    the destination directory location
         def uncompress(archive, dest)
           _archive = archive.local
-          _dest = dest.local
-          ::Zip::Archive.open(_archive.path.to_s) do |ar|
-            ar.each do |f|
-              path = _dest + f.name
-              if f.directory?
-                path.mkdir
+          ::Zip::File.open(_archive.path.to_s) do |zip|
+            zip.each do |entry|
+              if entry.directory?
+                (dest + entry.name).mkdir
               else
-                f.read(8192) {|chunk| path.append(chunk)}
+                tmp = Temppath.create
+                entry.extract(tmp)
+                Location[tmp].move(dest + entry.name)
               end
             end
           end
-          _dest.move(dest)
         end
       end
     end