pione 0.2.0 → 0.2.1

data/lib/pione/version.rb

@@ -1,4 +1,4 @@
 module Pione
   # version of pione
-  VERSION = "0.2.0"
+  VERSION = "0.2.1"
 end

data/pione.gemspec

@@ -30,7 +30,7 @@ Gem::Specification.new do |gem|
   gem.add_dependency "uuidtools", "~> 2.1.4"
   gem.add_dependency "highline", "~> 1.6.15"
   gem.add_dependency "hamster", "~> 0.4.3"
-  gem.add_dependency "naming", "~> 0.0.2"
+  gem.add_dependency "naming", "~> 0.1.0"
   gem.add_dependency "forwardablex", "~> 0.1.4"
   gem.add_dependency "temppath", "~> 0.1.1"
   gem.add_dependency "ruby-xes", "~> 0.1.0"

data/test/agent/spec_rule-provider.rb

@@ -1,65 +1,78 @@
 require_relative '../test-util'
-require 'pione/agent/rule-provider'
 
-describe "Agent::RuleProvider" do
+describe "Pione::Agent::RuleProvider" do
   before do
-    create_remote_tuple_space_server
-    @provider = Agent[:rule_provider].start(tuple_space_server)
-    doc = Component::Document.parse(<<-DOCUMENT)
-      Rule abc
+    @ts = create_tuple_space_server
+    @agent = Agent[:rule_provider].new(@ts)
+    doc = Component::Document.load(<<-DOCUMENT)
+      Rule A
         input  '*.a'
-        output '{$INPUT[1].MATCH[1]}.b'
-      Action---
-        content "echo 'abc' > {$OUTPUT[1]}"
-      ---End
+        output '{$I[1]}.result'
+      Action
+        echo A > {$O[1]}
+      End
 
-      Rule xyz
-        input  '*.a'
-        output '{$INPUT[1].MATCH[1]}.b'
-      Action---
-        content "echo 'xyz' > {$OUTPUT[1]}"
-      ---End
+      Rule B
+        input  '*.b'
+        output '{$I[1]}.result'
+      Action
+        echo B > {$[1]}
+      End
+    DOCUMENT
+    @rule_a = doc.find('A')
+    @rule_b = doc.find('B')
+    @agent.read_rules(doc)
+  end
+
+  after do
+    @agent.terminate
+    @ts.terminate
+  end
+
+  it "should have rules" do
+    @agent.known_rules.should.include "&Main:A"
+    @agent.known_rules.should.include "&Main:B"
+  end
+
+  it "should add a rule" do
+    doc = Component::Document.load(<<-DOCUMENT)
+      Rule C
+        input  '*.c'
+        output '{$I[1]}.result'
+      Action
+        echo C > {$O[1]}
+      End
     DOCUMENT
-    @rule_abc = doc['&main:abc']
-    @rule_xyz = doc['&main:xyz']
-    @provider.read_document(doc)
+    @agent.read_rules(doc)
+    @agent.known_rules.should.include "&Main:C"
   end
 
-  it "should provide known rule information" do
+  it "should provide requested rule" do
+    @agent.start
+
     # wait provider's setup
-    @provider.wait_till(:request_waiting)
+    @agent.wait_till(:request_waiting)
+
     # write a request
-    write_and_wait_to_be_taken(Tuple[:request_rule].new(rule_path: '&main:abc'))
+    write_and_wait_to_be_taken(Tuple[:request_rule].new(rule_path: '&Main:A'))
     check_exceptions
+
     # check rule tuple
     should.not.raise(Rinda::RequestExpiredError) do
-      rule = read(Tuple[:rule].new(rule_path: '&main:abc'))
-      rule.status.should == :known
-      rule.content.class.should == Rule::ActionRule
-      rule.content.should == @rule_abc
+      tuple = read!(Tuple[:rule].new(rule_path: '&Main:A'))
+      tuple.content.class.should == Component::ActionRule
+      tuple.content.should == @rule_a
     end
+
     # write another request
-    write_and_wait_to_be_taken(Tuple[:request_rule].new(rule_path: '&main:xyz'))
+    write_and_wait_to_be_taken(Tuple[:request_rule].new(rule_path: '&Main:B'))
     check_exceptions
-    # check rule tuple
-    should.not.raise(Rinda::RequestExpiredError) do
-      rule = read(Tuple[:rule].new(rule_path: '&main:xyz'))
-      rule.status.should == :known
-      rule.content.class.should == Rule::ActionRule
-      rule.content.should == @rule_xyz
-    end
-  end
 
-  it "should provide unknown rule information" do
-    # wait provider's setup
-    @provider.wait_till(:request_waiting)
-    # write a request
-    write_and_wait_to_be_taken(Tuple[:request_rule].new(rule_path: "aaa"))
-    check_exceptions
-    # check unknown rule tuple
+    # check rule tuple
     should.not.raise(Rinda::RequestExpiredError) do
-      rule = read(Tuple[:rule].new(rule_path: "aaa"))
-      rule.status.should == :unknown
+      tuple = read!(Tuple[:rule].new(rule_path: '&Main:B'))
+      tuple.content.class.should == Component::ActionRule
+      tuple.content.should == @rule_b
     end
   end
 end

data/test/command/command-behavior.rb

@@ -0,0 +1,15 @@
+shared "command" do
+  it "should show a help message" do
+    res = TestUtil::Command.succeed do
+      Command::PioneVal.run ["--help"]
+    end
+    res.stdout.string.should.start_with "Usage"
+  end
+
+  it "should show a version message" do
+    res = TestUtil::Command.succeed do
+      Command::PioneVal.run ["--version"]
+    end
+    res.stdout.string.should.include Pione::VERSION
+  end
+end

data/test/command/spec_pione-client.rb

@@ -0,0 +1,56 @@
+require_relative '../test-util'
+require_relative 'command-behavior'
+
+describe "Pione::Command::PioneClient" do
+  behaves_like "command"
+
+  ### is this wrong?
+  # it "should execute a PIONE document" do
+  #   path = Temppath.create
+  #   args = ["example/HelloWorld/HelloWorld.pione", "-o", path.to_s]
+  #   res = TestUtil::Command.succeed do
+  #     Pione::Command::PioneClient.run args
+  #   end
+  #   Location[path + "message.txt"].should.exist
+  #   Location[path + "message.txt"].read.should.start_with "Hello, world!"
+  # end
+
+  it "should execute a PIONE document with stand alone mode" do
+    path = Temppath.create
+    args = ["example/HelloWorld/HelloWorld.pione", "-o", path.to_s, "--stand-alone"]
+    res = TestUtil::Command.succeed do
+      Pione::Command::PioneClient.run args
+    end
+    Location[path + "message.txt"].should.exist
+    Location[path + "message.txt"].read.should.start_with "Hello, world!"
+  end
+
+  # it "should execute a PIONE package" do
+  #   path = Temppath.create
+  #   args = ["example/HelloWorld/", "-o", path.to_s]
+  #   res = TestUtil::Command.succeed do
+  #     Pione::Command::PioneClient.run args
+  #   end
+  #   Location[path + "message.txt"].should.exist
+  #   Location[path + "message.txt"].read.should.start_with "Hello, world!"
+  # end
+
+  it "should execute a PIONE package with stand alone mode" do
+    path = Temppath.create
+    args = ["example/HelloWorld/", "-o", path.to_s, "--stand-alone"]
+    res = TestUtil::Command.succeed do
+      Pione::Command::PioneClient.run args
+    end
+    Location[path + "message.txt"].should.exist
+    Location[path + "message.txt"].read.should.start_with "Hello, world!"
+  end
+
+  it "should show parameters list of package" do
+    args = ["example/HelloWorld/HelloWorld.pione", "--list-params"]
+    res = TestUtil::Command.succeed do
+      Pione::Command::PioneClient.run args
+    end
+    res.stdout.string.size.should > 0
+  end
+end
+

data/test/command/spec_pione-val.rb

@@ -0,0 +1,22 @@
+require_relative '../test-util'
+require_relative 'command-behavior'
+
+describe "Pione::Command::PioneVal" do
+  behaves_like "command"
+
+  it "should get value" do
+    res = TestUtil::Command.succeed do
+      Command::PioneVal.run ["1 + 1"]
+    end
+    res.stdout.string.chomp.should == "2"
+  end
+
+  it "should get variable from domain info" do
+    domain_info = TestUtil::DIR + "command" + "spec_pione-val.domain.dump"
+    res = TestUtil::Command.succeed do
+      Command::PioneVal.run ["$O[1]", "--domain-info", domain_info.path.to_s]
+    end
+    res.stdout.string.chomp.should == "message.txt"
+  end
+end
+

data/test/component/spec_document.pione

@@ -0,0 +1,51 @@
+Param
+  $P1 := "a"
+  $P2 := "b"
+  $P3 := "c"
+End
+
+param $P4 := "d"
+param $P5 := "e"
+
+$P6 := "f"
+
+$X := 1
+
+Rule Main
+  input '*.txt'
+  output '*.result'
+Flow
+  rule RuleA
+  rule RuleB
+  rule RuleC
+End
+
+Rule RuleA
+  input '*.txt'
+  output '{$I[1,1]}.a'
+Action
+  command_a {$I[1]} > {$O[1]}
+End
+
+Rule RuleB
+  input '*.a'
+  output '{$I[1,1]}.b'
+Action
+  command_b {$I[1]} > {$O[1]}
+End
+
+Rule RuleC
+  input '*.b'
+  output '{$I[1,1]}.result'
+Action
+  command_c {$I[1]} > {$O[1]}
+End
+
+Rule TestParams
+  input '*.input'
+  output '{$*}.output'
+  param $P1
+Action
+  echo `echo {$I[1]}` {$P1} > {$O[1]}
+End
+

data/test/component/spec_document.rb

@@ -1,93 +1,64 @@
 require_relative '../test-util'
 
-src = <<DOCUMENT
-Param
-  $P1 := "a"
-  $P2 := "b"
-  $P3 := "c"
-End
+document_location = Location[File.dirname(__FILE__)] + "spec_document.pione"
 
-param $P4 := "d"
-param $P5 := "e"
-
-$X := 1
-
-Rule Main
-  input '*.txt'
-  output '*.result'
-Flow
-rule RuleA
-rule RuleB
-rule RuleC
-End
-
-Rule RuleA
-  input '*.txt'
-  output '{$I[1,1]}.a'
-Action
-command_a {$I[1]} > {$O[1]}
-End
-
-Rule RuleB
-  input '*.a'
-  output '{$I[1,1]}.b'
-Action
-command_b {$I[1]} > {$O[1]}
-End
+describe 'Pione::Component::Document' do
+  before do
+    @document = Component::Document.load(document_location)
+  end
 
-Rule RuleC
-  input '*.b'
-  output '{$I[1,1]}.result'
-Action
-command_c {$I[1]} > {$O[1]}
-End
-DOCUMENT
+  it 'should load a document from a file' do
+    @document.rules.map{|rule| rule.name}.tap do |x|
+      x.should.include "Main"
+      x.should.include "RuleA"
+      x.should.include "RuleB"
+      x.should.include "RuleC"
+    end
+  end
 
-describe 'Pione::Component::Document' do
-  it 'should read a document from a string' do
-    doc = Component::Document.parse(src)
-    doc.rules.size.should == 4
+  it 'should load a document from a string' do
+    Component::Document.load(document_location.read).should == @document
   end
 
-  it 'should read a document from a file' do
-    temp = Tempfile.new("spec_document")
-    temp.write(src)
-    path = temp.path
-    temp.close(false)
-    doc = Component::Document.load(path)
-    doc.rules.size.should == 4
+  it 'should load a document with package name' do
+    document = Component::Document.load(document_location, "Test")
+    document.package_name.should == "Test"
+    document.find("Main").package_name == "Test"
   end
 
-  it 'should get rules by rule path' do
-    doc = Component::Document.parse(src)
-    doc["&main:Main"].should.kind_of(Component::Rule)
-    doc["&main:RuleA"].should.kind_of(Component::Rule)
-    doc["&main:RuleB"].should.kind_of(Component::Rule)
-    doc["&main:RuleC"].should.kind_of(Component::Rule)
+  it 'should get rule by name' do
+    @document.find("Main").should.kind_of(Component::FlowRule)
+    @document.find("RuleA").should.kind_of(Component::ActionRule)
+    @document.find("RuleB").should.kind_of(Component::ActionRule)
+    @document.find("RuleC").should.kind_of(Component::ActionRule)
   end
 
   it 'should have document parameters' do
-    doc = Component::Document.parse(src)
-    doc.params["P1"].should == PioneString.new("a").to_seq
-    doc.params["P2"].should == PioneString.new("b").to_seq
-    doc.params["P3"].should == PioneString.new("c").to_seq
-    doc.params["P4"].should == PioneString.new("d").to_seq
-    doc.params["P5"].should == PioneString.new("e").to_seq
-    user_params = doc.params.data.select{|var, val| var.user_param}.map{|var, val| var.name}
+    @document.params["P1"].should == PioneString.new("a").to_seq
+    @document.params["P2"].should == PioneString.new("b").to_seq
+    @document.params["P3"].should == PioneString.new("c").to_seq
+    @document.params["P4"].should == PioneString.new("d").to_seq
+    @document.params["P5"].should == PioneString.new("e").to_seq
+    @document.params["P6"].should == PioneString.new("f").to_seq
+    user_params = @document.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 = Component::Document.parse(src)
-    doc["&main:Main"].condition.params["X"].should == 1.to_pione.to_seq
-    doc["&main:RuleA"].condition.params["X"].should == 1.to_pione.to_seq
-    doc["&main:RuleB"].condition.params["X"].should == 1.to_pione.to_seq
-    doc["&main:RuleC"].condition.params["X"].should == 1.to_pione.to_seq
+    @document.find("Main").condition.params["X"].should == 1.to_pione.to_seq
+    @document.find("RuleA").condition.params["X"].should == 1.to_pione.to_seq
+    @document.find("RuleB").condition.params["X"].should == 1.to_pione.to_seq
+    @document.find("RuleC").condition.params["X"].should == 1.to_pione.to_seq
+  end
+
+  it 'should create root rule' do
+    root = @document.create_root_rule(@document.find("Main"), Model::Parameters.empty)
+    root.should.kind_of(Component::RootRule)
   end
 
   it 'should raise variable binding error' do
     should.raise(VariableBindingError) do
-      Component::Document.parse <<-PIONE
+      Component::Document.load <<-PIONE
         $X := 1
         $X := 2
       PIONE

data/test/component/spec_package.rb

@@ -34,12 +34,14 @@ describe "Pione::Component::Package" do
   end
 
   it "should get rules" do
-    @package.rules.keys.should.include("&TestPackage:Main")
-    @package.rules.keys.should.include("&TestPackage:Count")
+    @package.rules.map{|rule| rule.path}.tap do |x|
+      x.should.include("&TestPackage:Main")
+      x.should.include("&TestPackage:Count")
+    end
   end
 
   it "should get a main rule" do
-    @package.main.path.should == "&TestPackage:Main"
+    @package.find_rule("Main").path.should == "&TestPackage:Main"
   end
 
   it "should upload package files" do
@@ -75,3 +77,16 @@ describe "Pione::Component::PackageScenario" do
     @scenario.name.should == "TestCase1"
   end
 end
+
+describe "Pione::Component::PackageReader" do
+  it "should read package directory" do
+    path = Location[File.expand_path("../spec_package", __FILE__)] + "TestPackage"
+    Component::PackageReader.new(path).type.should == :directory
+  end
+
+  it "should read the package and return it" do
+    path = Location[File.expand_path("../spec_package", __FILE__)] + "TestPackage"
+    Component::PackageReader.read(path).should.kind_of Component::Package
+  end
+end
+