pione 0.1.0 → 0.1.1

data/lib/pione/system/config.rb

@@ -1,19 +1,67 @@
 module Pione
   module System
-    # Config represents a PIONE system configuration.
+    # Config is a class for setting PIONE system configuration.
     class Config < PioneObject
       extend Forwardable
 
-      attr_reader :path
+      # This exception class is raised when configuration file is in invalid format.
+      class InvalidConfigFormat < StandardError
+        # config file path
+        # @return [Pathname]
+        attr_reader :path
+
+        # Create an exception.
+        #
+        # @param path [Pathname]
+        #   configuration file path
+        def initialize(path)
+          @path = path
+        end
+
+        # @api private
+        def message
+          "invalid format configuration file: %s" % @path
+        end
+      end
+
+      class << self
+        # Load configuration and apply it to global settings.
+        #
+        # @param path [Pathname or String]
+        #   configuration file path
+        # @return [void]
+        def load(path)
+          new(path).tap {|x| x.apply}
+        end
+      end
+
       def_delegator :@table, "[]"
 
-      # Creates a new configuration.
-      # @param [Hash] data
-      #   preset configuration table
+      # config file path
+      # @return [Pathname]
+      attr_reader :path
+
+      # Create a new configuration.
+      #
+      # @param path [Pathname or String]
+      #   configuration file path
       def initialize(path)
         @path = Pathname.new(path)
         @table = @path.exist? ? YAML.load(@path.read) : {}
-        raise TypeError.new(@path) unless @table.kind_of?(Hash)
+        raise InvalidConfigFormat.new(@path) unless @table.kind_of?(Hash)
+      end
+
+      # Apply config date to global settings.
+      #
+      # @return [void]
+      def apply
+        # set values
+        keys = Global.all_names
+        @table.each do |key, val|
+          Global.send("set_%s" % key, val) if keys.include?(key.to_sym)
+        end
+        # initialize global settings with new configuration
+        Global.init
       end
     end
   end

data/lib/pione/system/document.rb

@@ -24,6 +24,16 @@ module Pione
         rules = toplevels.select{|elt| elt.kind_of?(Rule)}
         assignments = toplevels.select{|elt| elt.kind_of?(Assignment)}
         assignments.each {|assignment| assignment.set_toplevel(true)}
+        user_params = Naming::ParamLine.values(toplevels)
+        Naming::ParamBlock.values(toplevels).each do |elts|
+          user_params += elts
+        end
+        assignments += user_params.map do |param|
+          param.tap do |x|
+            x.set_toplevel(true)
+            x.set_user_param(true)
+          end
+        end
 
         # make document parameters
         params = assignments.inject(VariableTable.empty) do |vtable, a|
@@ -31,9 +41,7 @@ module Pione
         end.to_params
 
         # set document parameters into rules
-        rules.each do |rule|
-          rule.params.merge!(params)
-        end
+        rules.each {|rule| rule.params.merge!(params)}
 
         # make rule table
         table = rules.inject({}) do |tbl, rule|
@@ -43,6 +51,7 @@ module Pione
       end
 
       attr_reader :rules
+      attr_reader :params
 
       # Creates a document.
       def initialize(rules, params)
@@ -74,7 +83,7 @@ module Pione
       # @return [RootRule]
       #   root rule
       def root_rule(params)
-        Rule::RootRule.new(main, params.merge(@params))
+        Rule::RootRule.new(main, @params.merge(params))
       end
     end
   end

data/lib/pione/system/global.rb

@@ -49,6 +49,7 @@ module Pione
         end
 
         # Returns all item names.
+        #
         # @return [Symbol]
         #   all item names
         def all_names
@@ -58,18 +59,19 @@ module Pione
         # Initializes global values.
         # @return [void]
         def init
-          @__config__.each do |name, config_name|
-            if val = Global.config[config_name]
-              instance_variable_set("@%s" % name, val)
-            end
-          end
-
           @__initializer__.each do |name, action|
             unless instance_variable_get("@%s" % name)
               instance_variable_set("@%s" % name, action.call)
             end
           end
         end
+
+        # Return the table of all configurations.
+        #
+        # @return [Hash<Symbol, Object>]
+        def all
+          Hash[all_names.map {|name| [name, Global.send(name)]}]
+        end
       end
 
       extend GlobalInterface
@@ -88,8 +90,6 @@ module Pione
       # system
       #
 
-      define_item(:config, true, Config.new("~/.pione/config.yml"))
-
       # .pione dir
       define_item(:dot_pione_dir, true) do
         Pathname.new("~/.pione").expand_path.tap {|path|

data/lib/pione/system/init.rb

@@ -5,6 +5,9 @@ module Pione
         # init globals
         Global.init
 
+        # load configration file
+        System::Config.load(Global.config_path)
+
         # relay client database
         Global.relay_client_db = Relay::RelayClientDB.new(Global.relay_client_db_path)
 

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

@@ -27,9 +27,13 @@ module Pione
       # statement
       #
 
+      rule(:param_block => sequence(:assignment_list)) {
+        Naming.ParamBlock(assignment_list)
+      }
+
       # package
       rule(:package => subtree(:tree)) {
-        @current_package = Package.new(tree[:package_name].to_s)
+        @current_package = Naming.Package(tree[:package_name].to_s)
       }
     end
   end

data/lib/pione/transformer/rule-definition-transformer.rb

@@ -13,14 +13,10 @@ module Pione
           :rule_header => simple(:rule_expr),
           :rule_conditions => sequence(:conditions),
           :block => simple(:block) }) {
-        inputs = conditions.select{|c| c.type == :input}.map{|c| c.obj}
-        outputs = conditions.select{|c| c.type == :output}.map{|c| c.obj}
-        params = Parameters.merge(
-          *conditions.select{|c| c.type == :param}.map{|c| c.obj}
-        )
-        features = Feature::AndExpr.new(
-          *conditions.select{|c| c.type == :feature}.map{|c| c.obj}
-        )
+        inputs = Naming::InputLine.values(conditions)
+        outputs = Naming::OutputLine.values(conditions)
+        params = Parameters.merge(*Naming::ParamLine.values(conditions))
+        features = Feature::AndExpr.new(*Naming::FeatureLine.values(conditions))
         condition = RuleCondition.new(inputs, outputs, params, features)
         case block
         when ActionBlock
@@ -30,18 +26,16 @@ module Pione
         end.new(rule_expr, condition, block)
       }
 
-      ConditionLine = Struct.new(:type, :obj)
-
       # input_line
       rule(:input_line => simple(:data_expr)) {
         TypeDataExpr.check(data_expr)
-        ConditionLine.new(:input, data_expr)
+        Naming.InputLine(data_expr)
       }
 
       # output_line
       rule(:output_line => simple(:data_expr)) {
         TypeDataExpr.check(data_expr)
-        ConditionLine.new(:output, data_expr)
+        Naming.OutputLine(data_expr)
       }
 
       # param_line
@@ -49,13 +43,13 @@ module Pione
         unless TypeAssignment.match(param) or TypeParameters.match(param)
           raise PioneModelTypeError.new(param, TypeAssignment)
         end
-        ConditionLine.new(:param, param)
+        Naming.ParamLine(param)
       }
 
       # feature_line
       rule(:feature_line => simple(:feature)) {
         TypeFeature.check(feature)
-        ConditionLine.new(:feature, feature)
+        Naming.FeatureLine(feature)
       }
     end
   end

data/lib/pione/tuple-space/tuple-space-receiver.rb

@@ -95,7 +95,7 @@ module Pione
         @socket.close
         @socket = open_socket
         if Global.show_presence_notifier
-          puts "tuple space receiver disconnected"
+          puts "tuple space receiver disconnected: %s" % e
         end
       rescue Exception
         # ignore

data/lib/pione/version.rb

@@ -1,3 +1,4 @@
 module Pione
-  VERSION = "0.1.0"
+  # version of pione
+  VERSION = "0.1.1"
 end

data/pione.gemspec

@@ -29,6 +29,7 @@ Gem::Specification.new do |gem|
   gem.add_dependency "parslet", "~> 1.4.0"
   gem.add_dependency "uuidtools", "~> 2.1.3"
   gem.add_dependency "highline", "~> 1.6.15"
+  gem.add_dependency "naming"
 
   # for dropbox resource
   gem.add_dependency "dropbox-sdk"
@@ -46,4 +47,5 @@ Gem::Specification.new do |gem|
 
   # for documentation
   gem.add_development_dependency "yard"
+  gem.add_development_dependency "redcarpet"
 end

data/test/parser/spec_document-parser.rb

@@ -0,0 +1,5 @@
+require_relative '../test-util'
+
+describe 'Pione::Parser::DocumentParser' do
+  TestUtil::Parser.spec(Pione::Parser::DocumentParser, __FILE__, self)
+end

data/test/parser/spec_document-parser.yml

@@ -0,0 +1,62 @@
+toplevel_element:
+  valid:
+    # parameter line
+    - "param $X := 1"
+    # parameter block
+    - |
+      Param
+        $X := 1
+        $Y := 2
+        $Z := 3
+      End
+    # rule definition
+    - |
+      Rule Test
+        input '*.txt'
+        output '{$*}.result'
+      Action
+        rev {$I[1]} > {$O[1]}
+      End
+    # assignment
+    - "$X := 1"
+param_block:
+  valid:
+    # empty block
+    - |
+      Param
+      End
+    # one line block
+    - |
+      Param
+        $X := 1
+      End
+    # multi line block
+    - |
+      Param
+        $X := 1
+        $Y := 2
+        $Z := 3
+      End
+    # multi line with empty line
+    - |
+      Param
+        $X := 1
+        
+        $Y := 2
+      End
+    # one line with comment
+    - |
+      Param
+        # param $X := 1
+        $X := 1
+      End
+    # multi line with comments
+    - |
+      Param
+        # param $X := 1
+        $X := 1
+        # param $Y := 2
+        $Y := 2
+        # param $Z := 3
+        $Z := 3
+      End

data/test/{spec_document.rb → system/spec_document.rb}

@@ -1,6 +1,15 @@
-require_relative 'test-util'
+require_relative '../test-util'
 
 src = <<DOCUMENT
+Param
+  $P1 := "a"
+  $P2 := "b"
+  $P3 := "c"
+End
+
+param $P4 := "d"
+param $P5 := "e"
+
 $X := 1
 
 Rule Main
@@ -57,7 +66,18 @@ describe 'Document' do
     doc["&main:RuleC"].should.kind_of(Model::Rule)
   end
 
-  it 'should have global variable' do
+  it 'should have document parameters' do
+    doc = Document.parse(src)
+    doc.params["P1"].should == "a".to_pione
+    doc.params["P2"].should == "b".to_pione
+    doc.params["P3"].should == "c".to_pione
+    doc.params["P4"].should == "d".to_pione
+    doc.params["P5"].should == "e".to_pione
+    user_params = doc.params.data.select{|var, val| var.user_param}.map{|var, val| var.name}
+    user_params.sort.should == ["P1", "P2", "P3", "P4", "P5"]
+  end
+
+  it 'should have document variable bindings' do
     doc = Document.parse(src)
     doc["&main:Main"].params["X"].should == 1.to_pione
     doc["&main:RuleA"].params["X"].should == 1.to_pione

data/test/test-util.rb

@@ -79,7 +79,7 @@ module TestUtil::Parser
       context.describe name do
         if strings = testcase["valid"]
           strings.each do |string|
-            it "should parse as #{name}: #{string}" do
+            it "should parse as %s:%s%s" % [name, string.include?("\n") ? "\n" : " ", string.chomp] do
               should.not.raise(Parslet::ParseFailed) do
                 parser.new.send(name).parse(string)
               end
@@ -89,7 +89,7 @@ module TestUtil::Parser
 
         if strings = testcase["invalid"]
           strings.each do |string|
-            it "should fail when parsing as #{name}: #{string}" do
+            it "should fail when parsing as %s:%s%s" % [name, string.include?("\n") ? "\n" : "", string.chomp] do
               should.raise(Parslet::ParseFailed) do
                 parser.new.send(name).parse(string)
               end
@@ -120,7 +120,7 @@ module TestUtil::Transformer
     testcases.instance_eval(&b)
     context.describe name do
       testcases.each do |tc|
-        it "should get #{name}: #{tc.string}" do
+        it "should get %s:%s%s" % [name, tc.string.include?("\n") ? "\n" : "", tc.string.chomp] do
           res = DocumentTransformer.new.apply(
             DocumentParser.new.send(parser).parse(tc.string)
           )

data/test/transformer/spec_rule-definition-transformer.rb

@@ -1,57 +1,52 @@
 require_relative '../test-util'
 
-ConditionLine = Transformer::RuleDefinitionTransformer::ConditionLine
-
 describe 'Pione::Transformer::RuleDefinitionTransformer' do
   transformer_spec("input_line", :input_line) do
     tc("input '*.txt'") do
-      ConditionLine.new(:input, DataExpr.new("*.txt"))
+      Naming.InputLine(DataExpr.new("*.txt"))
     end
   end
 
   transformer_spec("output_line", :output_line) do
     tc("output '*.txt'") do
-      ConditionLine.new(:output, DataExpr.new("*.txt"))
+      Naming.OutputLine(DataExpr.new("*.txt"))
     end
   end
 
   transformer_spec("param_line", :param_line) do
     tc("param {var: 1}") do
-      ConditionLine.new(:param, {"var" => 1}.to_params)
+      Naming.ParamLine({"var" => 1}.to_params)
     end
     tc("param {var1: 1, var2: 2}") do
-      ConditionLine.new(:param, {"var1" => 1, "var2" => 2}.to_params)
+      Naming.ParamLine({"var1" => 1, "var2" => 2}.to_params)
     end
   end
 
   transformer_spec("feature_line", :feature_line) do
     tc("feature +A") do
-      ConditionLine.new(
-        :feature,
-        Feature::RequisiteExpr.new("A")
-      )
+      Naming.FeatureLine(Feature::RequisiteExpr.new("A"))
     end
   end
 
-  transformer_spec("rule_definition", :rule_definitions) do
-    tc(<<STRING) do
-Rule Test
-  input  '*.a'
-output '{$INPUT[1].MATCH[1]}.b'
-Action
-echo "test" > {$OUTPUT[1].NAME}
-End
-STRING
-      [ActionRule.new(
-          RuleExpr.new(Package.new("main"), "Test"),
-          RuleCondition.new(
-            [ DataExpr.new('*.a') ],
-            [ DataExpr.new('{$INPUT[1].MATCH[1]}.b') ],
-            Parameters.empty,
-            Feature.empty
-          ),
-          ActionBlock.new("echo \"test\" > {$OUTPUT[1].NAME}\n")
-      )]
+  transformer_spec("rule_definition", :rule_definition) do
+    tc(<<-STRING) do
+      Rule Test
+        input  '*.a'
+        output '{$INPUT[1].MATCH[1]}.b'
+      Action
+        echo "test" > {$OUTPUT[1].NAME}
+      End
+    STRING
+      ActionRule.new(
+        RuleExpr.new(Package.new("main"), "Test"),
+        RuleCondition.new(
+          [ DataExpr.new('*.a') ],
+          [ DataExpr.new('{$INPUT[1].MATCH[1]}.b') ],
+          Parameters.empty,
+          Feature.empty
+        ),
+        ActionBlock.new("        echo \"test\" > {$OUTPUT[1].NAME}\n")
+      )
     end
 
     tc(<<-STRING) do
@@ -59,23 +54,23 @@ STRING
         input '*.a'
         output '{$INPUT[1].MATCH[1]}.b'
       Flow
-      rule TestA
-      rule TestB
+        rule TestA
+        rule TestB
       End
     STRING
-      [ FlowRule.new(
-          RuleExpr.new(Package.new("main"), "Test"),
-          RuleCondition.new(
-            [ DataExpr.new('*.a') ],
-            [ DataExpr.new('{$INPUT[1].MATCH[1]}.b') ],
-            Parameters.empty,
-            Feature.empty
-          ),
-          FlowBlock.new(
-            CallRule.new(RuleExpr.new(Package.new("main"), "TestA")),
-            CallRule.new(RuleExpr.new(Package.new("main"), "TestB"))
-          )
-      )]
+      FlowRule.new(
+        RuleExpr.new(Package.new("main"), "Test"),
+        RuleCondition.new(
+          [ DataExpr.new('*.a') ],
+          [ DataExpr.new('{$INPUT[1].MATCH[1]}.b') ],
+          Parameters.empty,
+          Feature.empty
+        ),
+        FlowBlock.new(
+          CallRule.new(RuleExpr.new(Package.new("main"), "TestA")),
+          CallRule.new(RuleExpr.new(Package.new("main"), "TestB"))
+        )
+      )
     end
 
     tc(<<-STRING) do
@@ -91,40 +86,40 @@ STRING
       rule Summarize
       End
     STRING
-      [ FlowRule.new(
-          RuleExpr.new(Package.new("main"), "Main"),
-          RuleCondition.new(
-            [Message.new(
-                "except",
-                DataExpr.new("*.txt"),
-                DataExpr.new("summary.txt"))],
-            [DataExpr.new("summary.txt")],
-            Parameters.new({Variable.new("ConvertCharSet") => PioneBoolean.true}),
-            Feature.empty
+      FlowRule.new(
+        RuleExpr.new(Package.new("main"), "Main"),
+        RuleCondition.new(
+          [Message.new(
+              "except",
+              DataExpr.new("*.txt"),
+              DataExpr.new("summary.txt"))],
+          [DataExpr.new("summary.txt")],
+          Parameters.new({Variable.new("ConvertCharSet") => PioneBoolean.true}),
+          Feature.empty
+        ),
+        FlowBlock.new(
+          ConditionalBlock.new(
+            Variable.new("ConvertCharset"),
+            { PioneBoolean.true => FlowBlock.new(
+                CallRule.new(Message.new(
+                    "params",
+                    RuleExpr.new(Package.new("main"), "NKF"),
+                    PioneString.new("-w")
+                ))
+            )}
           ),
-          FlowBlock.new(
-            ConditionalBlock.new(
-              Variable.new("ConvertCharset"),
-              { PioneBoolean.true => FlowBlock.new(
-                  CallRule.new(Message.new(
-                      "params",
-                      RuleExpr.new(Package.new("main"), "NKF"),
-                      PioneString.new("-w")
-                  ))
-              )}
-            ),
-            CallRule.new(
-              RuleExpr.new(Package.new("main"), "CountChar")
-            ),
-            CallRule.new(
-              RuleExpr.new(Package.new("main"), "Summarize")
-            )
+          CallRule.new(
+            RuleExpr.new(Package.new("main"), "CountChar")
+          ),
+          CallRule.new(
+            RuleExpr.new(Package.new("main"), "Summarize")
           )
-      )]
+        )
+      )
     end
   end
 
-  transformer_spec("rule_definitions", :rule_definitions) do
+  transformer_spec("rule_definitions", :toplevel_elements) do
     tc(<<-STRING) do
       Rule TestA
         input  '*.a'