rsel 0.0.4 → 0.0.5

data/vendor/rubyslim-0.1.1/lib/test_module/test_slim_with_no_sut.rb

@@ -1,5 +0,0 @@
-module TestModule
-  class TestSlimWithNoSut
-
-  end
-end

data/vendor/rubyslim-0.1.1/rubyslim.gemspec

@@ -1,22 +0,0 @@
-
-Gem::Specification.new do |s|
-  s.name = "rubyslim"
-  s.version = "0.1.1"
-  s.summary = "Ruby SliM protocol for FitNesse"
-  s.description = <<-EOS
-    RubySliM implements the SliM protocol for the FitNesse
-    acceptance testing framework.
-  EOS
-  s.authors = ["Robert C. Martin", "Doug Bradbury"]
-  s.email = "unclebob@cleancoder.com"
-  s.platform = Gem::Platform::RUBY
-
-  s.add_development_dependency 'rspec', '~> 1.3.0'
-  s.add_development_dependency 'rcov'
-
-  s.files = `git ls-files`.split("\n")
-  s.require_path = 'lib'
-
-  s.executables = ['rubyslim']
-end
-

data/vendor/rubyslim-0.1.1/spec/instance_creation_spec.rb

@@ -1,40 +0,0 @@
-require File.expand_path(File.dirname(__FILE__) + "/spec_helper")
-require "statement_executor"
-
-describe StatementExecutor do
-  before do
-    @caller = StatementExecutor.new
-  end
-
-  it "can create an instance" do
-    response = @caller.create("x", "TestModule::TestSlim", [])
-    response.should == "OK"
-    x = @caller.instance("x")
-    x.class.name.should == "TestModule::TestSlim"
-  end
-
-  it "can create an instance with arguments" do
-    response = @caller.create("x", "TestModule::TestSlimWithArguments", ["3"])
-    response.should == "OK"
-    x = @caller.instance("x")
-    x.arg.should == "3"
-  end
-
-  it "can create an instance with arguments that are symbols" do
-    @caller.set_symbol("X", "3")
-    response = @caller.create("x", "TestModule::TestSlimWithArguments", ["$X"])
-    response.should == "OK"
-    x = @caller.instance("x")
-    x.arg.should == "3"
-  end
-
-  it "can't create an instance with the wrong number of arguments" do
-    result = @caller.create("x", "TestModule::TestSlim", ["1", "noSuchArgument"])
-    result.should include(Statement::EXCEPTION_TAG + "message:<<COULD_NOT_INVOKE_CONSTRUCTOR TestModule::TestSlim[2]>>")
-  end
-
-  it "can't create an instance if there is no class" do
-    result = @caller.create("x", "TestModule::NoSuchClass", [])
-    result.should include(Statement::EXCEPTION_TAG + "message:<<COULD_NOT_INVOKE_CONSTRUCTOR TestModule::NoSuchClass failed to find in []>>")
-  end
-end

data/vendor/rubyslim-0.1.1/spec/it8f_spec.rb

@@ -1,8 +0,0 @@
-require File.expand_path(File.dirname(__FILE__) + "/spec_helper")
-
-describe "characters" do
-  it "should be able to deal with it8f chars" do
-    "Köln".should == "Köln"
-    "Köln".size.should == 5
-  end
-end

data/vendor/rubyslim-0.1.1/spec/list_deserializer_spec.rb

@@ -1,66 +0,0 @@
-require File.expand_path(File.dirname(__FILE__) + "/spec_helper")
-require "list_serializer"
-require "list_deserializer"
-
-describe ListDeserializer do
-  before do
-    @list = []
-  end
-
-  it "can't deserialize a null string" do
-    proc {ListDeserializer.deserialize(nil)}.should raise_error(ListDeserializer::SyntaxError)
-  end
-
-  it "can't deserialize empty string" do
-    proc {ListDeserializer.deserialize("")}.should raise_error(ListDeserializer::SyntaxError)
-  end
-
-  it "can't deserialize string that doesn't start with an open bracket" do
-    proc {ListDeserializer.deserialize("hello")}.should raise_error(ListDeserializer::SyntaxError)
-  end
-
-  it "can't deserialize string that doesn't end with a bracket" do
-    proc {ListDeserializer.deserialize("[000000:")}.should raise_error(ListDeserializer::SyntaxError)    
-  end
-
-  def check()
-    serialized = ListSerializer.serialize(@list)
-    deserialized = ListDeserializer.deserialize(serialized)
-    deserialized.should == @list
-  end
-
-  it "can deserialize and empty list" do
-    check
-  end
-
-  it "can deserialize a list with one element" do
-    @list = ["hello"]
-    check
-  end
-
-  it "can deserialize a list with two elements" do
-    @list = ["hello", "bob"]
-    check
-  end  
-
-  it "can deserialize sublists" do
-    @list = ["hello", ["bob", "micah"], "today"]
-    check
-  end
-  
-  it "can deserialize lists with multibyte strings" do
-    @list = ["Köln"]
-    check
-  end 
-  
-  it "can deserialize lists of strings that end with multibyte chars" do
-    @list = ["Kö"]
-    check
-  end
-
-  it "can deserialize lists with utf8" do
-    @list = ["123456789012345", "Espa\357\277\275ol"]
-    check
-  end 
-
-end

data/vendor/rubyslim-0.1.1/spec/list_executor_spec.rb

@@ -1,187 +0,0 @@
-require File.expand_path(File.dirname(__FILE__) + "/spec_helper")
-require "statement_executor"
-require "list_executor"
-
-describe ListExecutor do
-  before do
-    @executor = ListExecutor.new
-    @statements = []
-    @table = "<table><tr><td>name</td><td>bob</td></tr><tr><td>addr</td><td>here</td></tr></table>"
-    add_statement "i1", "import", "TestModule"
-    add_statement "m1", "make", "test_slim", "TestSlim"
-  end
-
-  def get_result(id, result_list)
-    pairs_to_map(result_list)[id]
-  end
-
-  def pairs_to_map(pairs)
-    map = {}
-    pairs.each {|pair| map[pair[0]] = pair[1]}
-    map
-  end
-
-  def add_statement(*args)
-    @statements << args
-  end
-
-  def check_results expectations
-    results = @executor.execute(@statements)
-    expectations.each_pair {|id, expected|
-      get_result(id, results).should == expected
-    }
-  end
-
-  it "can respond with OK to import" do
-    check_results "i1"=>"OK"
-  end
-
-  it "can't execute an invalid operation" do
-    add_statement "inv1", "invalidOperation"
-    results = @executor.execute(@statements)
-    get_result("inv1", results).should include(Statement::EXCEPTION_TAG+"message:<<INVALID_STATEMENT: [\"inv1\", \"invalidOperation\"].")
-  end
-
-  it "can't execute a malformed instruction" do
-    add_statement "id", "call", "notEnoughArguments"
-    message = "message:<<MALFORMED_INSTRUCTION [\"id\", \"call\", \"notEnoughArguments\"].>>"
-    results = @executor.execute(@statements)
-    get_result("id", results).should include(Statement::EXCEPTION_TAG+message)
-  end
-
-  it "can't call a method on an instance that doesn't exist" do
-    add_statement "id", "call", "no_such_instance", "no_such_method"
-    results = @executor.execute(@statements)
-    get_result("id", results).should include(Statement::EXCEPTION_TAG+"message:<<NO_INSTANCE no_such_instance>>")
-  end
-
-  it "should respond to an empty set of instructions with an empty set of results" do
-    @executor.execute([]).length.should == 0
-  end
-
-  it "can make an instance given a fully qualified name in dot format" do
-    @executor.execute([["m1", "make", "instance", "testModule.TestSlim"]]).should == [["m1", "OK"]]
-  end
-
-  it "can call a simple method in ruby form" do
-    add_statement "id", "call", "test_slim", "return_string"
-
-    check_results "m1" => "OK", "id"=>"string"
-  end
-
-  it "can call a simple method in ruby form" do
-    add_statement "id", "call", "test_slim", "utf8"
-
-    check_results "m1" => "OK", "id"=>"Espa\357\277\275ol"
-  end
-
-
-  it "can call a simple method in FitNesse form" do
-    add_statement "id", "call", "test_slim", "returnString"
-
-    check_results "m1"=>"OK", "id"=>"string"
-  end
-
-  it "will allow later imports to take precendence over early imports" do
-    @statements.insert(0, ["i2", "import", "TestModule.ShouldNotFindTestSlimInHere"])
-    add_statement "id", "call", "test_slim", "return_string"
-    check_results "m1"=>"OK", "id"=>"string"
-  end
-
-  it "can pass arguments to constructor" do
-    add_statement "m2", "make", "test_slim_2", "TestSlimWithArguments", "3"
-    add_statement "c1", "call", "test_slim_2", "arg"
-
-    check_results "m2"=>"OK", "c1"=>"3"
-  end
-
-  it "can pass tables to constructor" do
-    add_statement "m2", "make", "test_slim_2", "TestSlimWithArguments", @table
-    add_statement "c1", "call", "test_slim_2", "name"
-    add_statement "c2", "call", "test_slim_2", "addr"
-
-    check_results "m2"=>"OK", "c1"=>"bob", "c2"=>"here"
-  end
-
-  it "can pass tables to functions" do
-    add_statement "m2", "make", "test_slim_2", "TestSlimWithArguments", "nil"    
-    add_statement "c0", "call", "test_slim_2", "set_arg", @table
-    add_statement "c1", "call", "test_slim_2", "name"
-    add_statement "c2", "call", "test_slim_2", "addr"
-
-    check_results "m2"=>"OK", "c1"=>"bob", "c2"=>"here"
-  end
-
-  it "can call a function more than once" do
-    add_statement "c1", "call", "test_slim", "add", "x", "y"
-    add_statement "c2", "call", "test_slim", "add", "a", "b"
-
-    check_results "c1" => "xy", "c2" => "ab"
-  end
-
-  it "can assign the return value to a symbol" do
-    add_statement "id1", "callAndAssign", "v", "test_slim", "add", "x", "y"
-    add_statement "id2", "call", "test_slim", "echo", "$v"
-    check_results "id1" => "xy", "id2" => "xy"
-  end
-
-  it "can replace multiple symbols in a single argument" do
-    add_statement "id1", "callAndAssign", "v1", "test_slim", "echo", "Bob"
-    add_statement "id2", "callAndAssign", "v2", "test_slim", "echo", "Martin"
-    add_statement "id3", "call", "test_slim", "echo", "name: $v1 $v2"
-    check_results "id3" => "name: Bob Martin"
-  end
-
-  it "should ignore '$' if what follows is not a symbol" do
-    add_statement "id3", "call", "test_slim", "echo", "$v1"
-    check_results "id3" => "$v1"
-  end
-
-  it "can pass and return a list" do
-    l = ["1", "2"]
-    add_statement "id", "call", "test_slim", "echo", l
-    check_results "id"=> l
-  end
-
-  it "can pass a symbol in a list" do
-    add_statement "id1", "callAndAssign", "v", "test_slim", "echo", "x"
-    add_statement "id2", "call", "test_slim", "echo", ["$v"]
-    check_results "id2" => ["x"]
-  end
-
-  it "can return null" do
-    add_statement "id", "call", "test_slim", "null"
-    check_results "id" => nil
-  end
-
-  it "can survive executing a syntax error" do
-    add_statement "id", "call", "test_slim", "syntax_error"
-    results = @executor.execute(@statements)
-    get_result("id", results).should include(Statement::EXCEPTION_TAG)
-  end
-
-  it "can make a fixture from the name in a symbol" do
-    add_statement "id1", "callAndAssign", "test_system", "test_slim", "echo", "TestChain"
-    add_statement "id2", "make", "fixture_instance1", "$test_system"
-    check_results "id2"=>"OK"
-  end
-
-  it "can make a fixture from a concatonated symbol" do
-    add_statement "id1", "callAndAssign", "test_system", "test_slim", "echo", "Chain"
-    add_statement "id2", "make", "fixture_instance1", "Test$test_system"
-    check_results "id2"=>"OK"
-  end
-
-  it "can use a fixture method that returns a fixture object" do
-    add_statement "id1", "callAndAssign", "object", "test_slim", "echo_object", "let_me_see", "Boogaloo"
-    add_statement "id2", "call", "test_slim", "call_on", "let_me_see", "$object"
-    check_results "id2" => "Boogaloo"
-  end
-
-  it "can use an instance that was stored as a symbol" do
-    add_statement "id1", "callAndAssign", "test_slim_instance", "test_slim", "create_test_slim_with_string", "Boogaloo"
-    add_statement "m2", "make", "test_slim", "$test_slim_instance"
-    check_results "m2" => "OK"
-  end
-
-end

data/vendor/rubyslim-0.1.1/spec/list_serialzer_spec.rb

@@ -1,38 +0,0 @@
-require File.expand_path(File.dirname(__FILE__) + "/spec_helper")
-require "list_serializer"
-
-describe ListSerializer do
-  it "can serialize and empty list" do
-    ListSerializer.serialize([]).should == "[000000:]"
-  end
-
-  it "can serialize a one item list" do
-    ListSerializer.serialize(["hello"]).should == "[000001:000005:hello:]"
-  end
-
-  it "can serialize a two item list" do
-    ListSerializer.serialize(["hello", "world"]).should == "[000002:000005:hello:000005:world:]"
-  end
-
-  it "can serialize a nested list" do
-    ListSerializer.serialize([["element"]]).should == "[000001:000024:[000001:000007:element:]:]" 
-  end
-
-  it "can serialize a list with a non-string" do
-    ListSerializer.serialize([1]).should == "[000001:000001:1:]"
-  end
-
-  it "can serialize a null element" do
-    ListSerializer.serialize([nil]).should == "[000001:000004:null:]"
-  end
-  
-  it "can serialize a string with multibyte chars" do
-    ListSerializer.serialize(["Köln"]).should == "[000001:000004:Köln:]"
-  end
-
-  it "can serialize a string with UTF8" do
-    ListSerializer.serialize(["Español"]).should == "[000001:000007:Espa\xc3\xb1ol:]"
-  end
-  
-  
-end

data/vendor/rubyslim-0.1.1/spec/method_invocation_spec.rb

@@ -1,127 +0,0 @@
-require File.expand_path(File.dirname(__FILE__) + "/spec_helper")
-require "statement_executor"
-
-describe StatementExecutor do
-  before do
-    @executor = StatementExecutor.new
-  end
-  context "Simple Method Invocations" do
-    before do
-      @executor.create("test_slim", "TestModule::TestSlim", [])
-      @test_slim = @executor.instance("test_slim")
-    end
-
-    it "can call a method with no arguments" do
-      @test_slim.should_receive(:no_args).with()
-      @executor.call("test_slim", "no_args")
-    end
-
-    it "can't call a method that doesn't exist" do
-      result = @executor.call("test_slim", "no_such_method")
-      result.should include(Statement::EXCEPTION_TAG + "message:<<NO_METHOD_IN_CLASS no_such_method[0] TestModule::TestSlim.>>")
-    end
-
-    it "can call a method that returns a value" do
-      @test_slim.should_receive(:return_value).and_return("arg")
-      @executor.call("test_slim", "return_value").should == "arg"
-    end
-
-    it "can call a method that returns a value" do
-      @test_slim.should_receive(:return_value).and_return("Español")
-      val = @executor.call("test_slim", "return_value")
-      val.should == "Español"
-      val.jlength.should == 7
-    end
-
-
-    it "can call a method that takes an argument" do
-      @test_slim.should_receive(:one_arg).with("arg")
-      @executor.call("test_slim", "one_arg", "arg")
-    end
-
-    it "can't call a method on an instance that doesn't exist" do
-      result = @executor.call("no_such_instance", "no_such_method")
-      result.should include(Statement::EXCEPTION_TAG + "message:<<NO_INSTANCE no_such_instance>>")
-    end
-
-    it "can replace symbol expressions with their values" do
-      @executor.set_symbol("v", "bob")
-      @executor.call("test_slim", "echo", "hi $v.").should == "hi bob."
-    end
-
-    it "can call a method on the @sut" do
-      @test_slim.sut.should_receive(:sut_method).with()
-      @executor.call("test_slim", "sut_method")
-    end
-
-    it "should call attributes on sut" do
-      @executor.call("test_slim", "set_attribute", "a")
-      @executor.call("test_slim", "attribute").should == "a"
-    end
-  end
-
-  context "Method invocations using fixture with no sut" do
-    before do
-      @executor.create("test_slim", "TestModule::TestSlimWithNoSut", []);
-      @test_slim = @executor.instance("test_slim")
-    end
-
-    it "can't call method that doesn't exist if no 'sut' exists" do
-      result = @executor.call("test_slim", "no_such_method")
-      result.should include(Statement::EXCEPTION_TAG + "message:<<NO_METHOD_IN_CLASS no_such_method[0] TestModule::TestSlimWithNoSut.>>")
-    end
-  end
-
-  context "Method invocations when library instances have been created." do
-    before do
-      @executor.create("library_old", "TestModule::LibraryOld", [])
-      @executor.create("library_new", "TestModule::LibraryNew", [])
-      @library_old = @executor.instance("library_old")
-      @library_new = @executor.instance("library_new")
-      @executor.create("test_slim", "TestModule::TestSlim", [])
-      @test_slim = @executor.instance("test_slim")
-    end
-
-    it "should throw normal exception if no such method is found." do
-      result = @executor.call("test_slim", "no_such_method")
-      result.should include(Statement::EXCEPTION_TAG + "message:<<NO_METHOD_IN_CLASS no_such_method[0] TestModule::TestSlim.>>")
-    end
-
-    it "should still call normal methods in fixture" do
-      @test_slim.should_receive(:no_args).with()
-      @executor.call("test_slim", "no_args")
-    end
-
-    it "should still call methods on the sut" do
-      @test_slim.sut.should_receive(:sut_method).with()
-      @executor.call("test_slim", "sut_method")
-    end
-
-    it "should call a specific method on library_old" do
-      @library_old.should_receive(:method_on_library_old).with()
-      @executor.call("test_slim", "method_on_library_old")
-    end
-
-    it "should call a specific method on library_new" do
-      @library_new.should_receive(:method_on_library_new).with()
-      @executor.call("test_slim", "method_on_library_new")
-    end
-
-    it "should call method on library_new but not on library_old" do
-      @library_new.should_receive(:a_method).with()
-      @library_old.should_not_receive(:a_method).with()
-      @executor.call("test_slim", "a_method")
-    end
-
-    it "should call built-in library methods" do
-      @executor.call("test_slim", "push_fixture").should == nil
-      @executor.call("test_slim", "pop_fixture").should == nil
-    end
-
-    it "should translate getters and setters" do
-      @executor.call("test_slim", "set_lib_attribute", "lemon")
-      @executor.call("test_slim", "lib_attribute").should == "lemon"
-    end
-
-  end
-end