rubyslim-unofficial 0.0.1

data/lib/rubyslim/statement_executor.rb

@@ -0,0 +1,174 @@
+require "rubyslim/slim_error"
+require "rubyslim/statement"
+require "rubyslim/table_to_hash_converter"
+require "rubyslim/slim_helper_library"
+
+class StatementExecutor
+  def initialize
+    @instances = {}
+    @modules = []
+    @symbols = {}
+    @libraries = [SlimHelperLibrary.new(self)]
+  end
+
+  def library?(instance_name)
+    library_prefix = "library"
+    instance_name[0, library_prefix.length] == library_prefix
+  end
+
+  def create(instance_name, class_name, constructor_arguments)
+    begin
+      instance = replace_symbol(class_name)
+      if instance.is_a?(String)
+        instance = construct_instance(instance, replace_symbols(constructor_arguments))
+        if library?(instance_name)
+          @libraries << instance
+        end
+      end
+      set_instance(instance_name, instance)
+      "OK"
+    rescue SlimError => e
+      Statement::EXCEPTION_TAG + e.to_s
+    end
+  end
+
+  def set_instance(instance_name, instance)
+    @instances[instance_name] = instance
+  end
+
+  def construct_instance(class_name, constructor_arguments)
+    require_class(class_name);
+    construct(class_name, constructor_arguments);
+  end
+
+
+  def make_path_to_class(class_name)
+    module_names = split_class_name(class_name)
+    files = module_names.collect { |module_name| to_file_name(module_name) }
+    File.join(files)
+  end
+
+  def split_class_name(class_name)
+    class_name.split(/\:\:/)
+  end
+
+  def replace_tables_with_hashes(constructor_arguments)
+    args = constructor_arguments.map do |arg|
+      TableToHashConverter.convert arg
+    end
+    return args
+  end
+
+  def construct(class_name, constructor_arguments)
+    class_object = get_class(class_name)
+    begin
+      class_object.new(*replace_tables_with_hashes(constructor_arguments))
+    rescue ArgumentError => e
+      raise SlimError.new("message:<<COULD_NOT_INVOKE_CONSTRUCTOR #{class_name}[#{constructor_arguments.length}]>>")
+    end
+  end
+
+
+  def with_each_fully_qualified_class_name(class_name, &block)
+    (@modules.map { |module_name| module_name + "::" + class_name } << class_name).reverse.each &block
+  end
+
+  def require_class(class_name)
+    with_each_fully_qualified_class_name(class_name) do |fully_qualified_name|
+      begin
+        require make_path_to_class(fully_qualified_name)
+        return
+      rescue LoadError
+      end
+    end
+    raise SlimError.new("message:<<COULD_NOT_INVOKE_CONSTRUCTOR #{class_name} failed to find in #{@modules.map { |mod| make_path_to_class(mod) }.inspect}>>")
+  end
+
+  def get_class(class_name)
+    with_each_fully_qualified_class_name(class_name) do |fully_qualified_name|
+      begin
+        return eval(fully_qualified_name)
+      rescue NameError
+      end
+    end
+    raise SlimError.new("message:<<COULD_NOT_INVOKE_CONSTRUCTOR #{class_name} in any module #{@modules.inspect}>>")
+  end
+
+  def instance(instance_name)
+    @instances[instance_name]
+  end
+
+  def to_file_name(module_name)
+    value = module_name[0..0].downcase + module_name[1..-1]
+    value.gsub(/[A-Z]/) { |cap| "_#{cap.downcase}" }
+  end
+
+  def send_message_to_instance(instance, method, args)
+    symbols = replace_symbols(args)
+    instance.send(method, *replace_tables_with_hashes(symbols))
+  end
+
+  def method_to_call(instance, method_name)
+    return nil unless instance
+    return method_name.to_sym if instance.respond_to?(method_name)
+    return "#{$1}=".to_sym if method_name =~ /set_(\w+)/ && instance.respond_to?("#{$1}=")
+    return nil
+  end
+
+  def call(instance_name, method_name, *args)
+    begin
+      instance = self.instance(instance_name)
+      if method = method_to_call(instance, method_name)
+        send_message_to_instance(instance, method, args)
+      elsif instance.respond_to?(:sut) && method = method_to_call(instance.sut, method_name)
+        send_message_to_instance(instance.sut, method, args)
+      else
+        @libraries.reverse_each do |library|
+          method = method_to_call(library, method_name)
+          return send_message_to_instance(library, method, args) if method
+        end
+        raise SlimError.new("message:<<NO_INSTANCE #{instance_name}>>") if instance.nil?
+        raise SlimError.new("message:<<NO_METHOD_IN_CLASS #{method_name}[#{args.length}] #{instance.class.name}.>>")
+      end
+    rescue SlimError => e
+      Statement::EXCEPTION_TAG + e.to_s
+    end
+  end
+
+  def add_module(module_name)
+    @modules << module_name.gsub(/\./, '::')
+  end
+
+  def set_symbol(name, value)
+    @symbols[name] = value
+  end
+
+  def get_symbol(name)
+    @symbols[name]
+  end
+
+  def acquire_symbol(symbol_text)
+    symbol = get_symbol(symbol_text[1..-1])
+    symbol = symbol_text if symbol.nil?
+    symbol
+  end
+
+  def replace_symbol(item)
+    match = item.match(/\A\$\w*\z/)
+    return acquire_symbol(match[0]) if match
+
+    item.gsub(/\$\w*/) do |match|
+      acquire_symbol(match)
+    end
+  end
+
+  def replace_symbols(list)
+    list.map do |item|
+      if item.kind_of?(Array)
+        replace_symbols(item)
+      else
+        replace_symbol(item)
+      end
+    end
+  end
+end

data/lib/rubyslim/table_to_hash_converter.rb

@@ -0,0 +1,32 @@
+require 'rexml/document'
+
+class TableToHashConverter
+  def self.convert(string)
+    begin
+      doc = REXML::Document.new(string.strip)
+      return html_to_hash(doc)
+    rescue
+      return string
+    end
+  end
+
+  def self.html_to_hash(doc)
+    table = doc.elements['table']
+    raise ArgumentError if table.nil?
+    create_hash_from_rows(table)
+  end
+
+  def self.create_hash_from_rows(rows)
+    hash = {}
+    rows.elements.each('tr') do |row|
+      add_row_to_hash(hash, row)
+    end
+    hash
+  end
+
+  def self.add_row_to_hash(hash, row)
+    columns = row.get_elements('td')
+    raise ArgumentError if columns.size != 2
+    hash[columns[0].text.strip.to_sym] = columns[1].text.strip
+  end
+end

data/lib/test_module/library_new.rb

@@ -0,0 +1,13 @@
+module TestModule
+  class LibraryNew
+    attr_reader :called
+    attr_accessor :lib_attribute
+    def method_on_library_new
+      @called = true;
+    end
+
+    def a_method
+      @called = true;
+    end
+  end
+end

data/lib/test_module/library_old.rb

@@ -0,0 +1,12 @@
+module TestModule
+  class LibraryOld
+    attr_reader :called
+    def method_on_library_old
+      @called = true;
+    end
+
+    def a_method
+      @called = true
+    end
+  end
+end

data/lib/test_module/should_not_find_test_slim_in_here/test_slim.rb

@@ -0,0 +1,7 @@
+module TestModule::ShouldNotFindTestSlimInHere
+  class TestSlim
+    def return_string
+      "blah"
+    end    
+  end
+end

data/lib/test_module/simple_script.rb

@@ -0,0 +1,9 @@
+class SimpleScript
+  def set_arg(arg)
+    @arg = arg
+  end
+
+  def get_arg
+    @arg  
+  end
+end

data/lib/test_module/test_chain.rb

@@ -0,0 +1,5 @@
+class TestChain
+  def echo_boolean(b)
+    b
+  end
+end

data/lib/test_module/test_slim.rb

@@ -0,0 +1,86 @@
+require 'ostruct'
+
+module TestModule
+  class SystemUnderTest
+    attr_accessor :attribute
+    def sut_method
+      true
+    end
+  end
+
+  class TestSlim
+    attr_reader :sut
+    attr_accessor :string
+
+    def initialize(generation = 0)
+      @generation = generation
+      @sut = SystemUnderTest.new
+      @string = "string"
+    end
+
+    def return_string
+      @string
+    end
+
+    def returnString  #Should not ever be called.
+      "blah"
+    end
+
+    def add(a, b)
+      a+b
+    end
+
+    def echo(x)
+      x
+    end
+
+    def null
+      nil
+    end
+
+    def echo_int i
+      i
+    end
+
+    def echo_string s
+      s
+    end
+
+    def syntax_error
+      eval "1,2"
+    end
+
+    def utf8
+      "Espa\357\277\275ol"
+    end
+
+    def create_test_slim_with_string(string)
+      slim = TestSlim.new(@generation + 1)
+      slim.string = string
+      slim
+    end
+
+    def new_with_string(string)
+      s = TestSlim.new
+      s.string = string
+      s
+    end
+
+    def echo_object(method, string)
+      OpenStruct.new(method.to_sym => string)
+    end
+
+    def call_on(method, object)
+      object.send(method.to_sym)
+    end
+
+#    def is_same(other)
+#      self === other
+#    end
+#
+#    def  get_string_from_other other
+#      other.get_string_arg
+#    end
+
+  end
+end

data/lib/test_module/test_slim_with_arguments.rb

@@ -0,0 +1,23 @@
+module TestModule
+  class TestSlimWithArguments
+    def initialize(arg)
+      @arg = arg
+    end
+
+    def arg
+      @arg
+    end
+
+    def name
+      @arg[:name]
+    end
+
+    def addr
+      @arg[:addr]
+    end
+
+    def set_arg(hash)
+      @arg = hash
+    end
+  end
+end

data/lib/test_module/test_slim_with_no_sut.rb

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

data/rubyslim-unofficial.gemspec

@@ -0,0 +1,25 @@
+
+Gem::Specification.new do |s|
+  s.name = "rubyslim-unofficial"
+  s.version = "0.0.1"
+  s.summary = "Ruby SliM protocol for FitNesse"
+  s.description = <<-EOS
+    RubySliM implements the SliM protocol for the FitNesse acceptance testing
+    framework. This gem is an unofficial version created and distributed by
+    Eric Pierce <wapcaplet88@gmail.com>, based on the original code by Robert
+    C. Martin and Doug Bradbury.
+  EOS
+  s.authors = ["Robert C. Martin", "Doug Bradbury"]
+  s.email = "unclebob@cleancoder.com"
+  s.homepage = "http://github.com/wapcaplet/rubyslim"
+  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/spec/instance_creation_spec.rb

@@ -0,0 +1,40 @@
+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/spec/it8f_spec.rb

@@ -0,0 +1,8 @@
+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/spec/list_deserializer_spec.rb

@@ -0,0 +1,66 @@
+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