rubyslim 0.1.1

data/lib/rubyslim/slim_helper_library.rb

@@ -0,0 +1,23 @@
+class SlimHelperLibrary
+  ACTOR_INSTANCE_NAME = "scriptTableActor"
+  attr_accessor :executor
+
+  def initialize(executor = nil)
+    @executor = executor
+    @fixtures = []
+  end
+
+  def get_fixture
+    executor.instance(ACTOR_INSTANCE_NAME)
+  end
+
+  def push_fixture
+    @fixtures << get_fixture
+    nil
+  end
+
+  def pop_fixture
+    executor.set_instance(ACTOR_INSTANCE_NAME, @fixtures.pop)
+    nil
+  end
+end

data/lib/rubyslim/socket_service.rb

@@ -0,0 +1,53 @@
+require 'socket'
+require 'thread'
+
+
+class SocketService
+
+  attr_reader :closed
+
+  def initialize()
+    @ropeSocket = nil
+    @group = ThreadGroup.new
+    @serviceThread = nil
+  end
+
+  def serve(port, &action)
+    @closed = false
+    @action = action
+    @ropeSocket = TCPServer.open(port)
+    @serviceThread = Thread.start {serviceTask}
+    @group.add(@serviceThread)
+  end
+
+  def pendingSessions
+    @group.list.size - ((@serviceThread != nil) ? 1 : 0)
+  end
+
+  def serviceTask
+    while true
+      Thread.start(@ropeSocket.accept) do |s|
+        serverTask(s)
+      end
+    end
+  end
+
+  def serverTask(s)
+    @action.call(s)
+    s.close
+  end
+
+  def close
+    @serviceThread.kill
+    @serviceThread = nil
+    @ropeSocket.close
+    waitForServers
+    @closed = true
+  end
+
+  def waitForServers
+    @group.list.each do |t|
+      t.join
+    end
+  end
+end

data/lib/rubyslim/statement.rb

@@ -0,0 +1,79 @@
+require "rubyslim/statement_executor"
+
+class Statement
+  EXCEPTION_TAG = "__EXCEPTION__:"
+  def self.execute(statement, executor)
+    Statement.new(statement).exec(executor)
+  end
+
+  def initialize(statement)
+    @statement = statement
+  end
+
+  def exec(executor)
+    @executor = executor
+    begin
+      case(operation)
+      when "make"
+        instance_name = get_word(2)
+        class_name = slim_to_ruby_class(get_word(3))
+        [id, @executor.create(instance_name, class_name, get_args(4))]
+      when "import"
+        @executor.add_module(slim_to_ruby_class(get_word(2)))
+        [id, "OK"]
+      when  "call"
+        call_method_at_index(2)
+      when "callAndAssign"
+        result = call_method_at_index(3)
+        @executor.set_symbol(get_word(2), result[1])
+        result
+      else
+        [id, EXCEPTION_TAG + "message:<<INVALID_STATEMENT: #{@statement.inspect}.>>"]
+      end
+    rescue SlimError => e
+      [id, EXCEPTION_TAG + e.message]
+    rescue Exception => e
+      [id, EXCEPTION_TAG + e.message + "\n" + e.backtrace.join("\n")]
+    end
+
+  end
+
+  def call_method_at_index(index)
+    instance_name = get_word(index)
+    method_name = slim_to_ruby_method(get_word(index+1))
+    args = get_args(index+2)
+    [id, @executor.call(instance_name, method_name, *args)]
+  end
+
+  def slim_to_ruby_class(class_name)
+    parts = class_name.split(/\.|\:\:/)
+    converted = parts.collect {|part| part[0..0].upcase+part[1..-1]}
+    converted.join("::")
+  end
+
+  def slim_to_ruby_method(method_name)
+    value = method_name[0..0].downcase + method_name[1..-1]
+    value.gsub(/[A-Z]/) { |cap| "_#{cap.downcase}" }
+  end
+
+  def id
+    get_word(0)
+  end
+
+  def operation
+    get_word(1)
+  end
+
+  def get_word(index)
+    check_index(index)
+    @statement[index]
+  end
+
+  def get_args(index)
+    @statement[index..-1]
+  end
+
+  def check_index(index)
+    raise SlimError.new("message:<<MALFORMED_INSTRUCTION #{@statement.inspect}.>>") if index >= @statement.length
+  end
+end

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,34 @@
+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
+    # Handle empty values.
+    columns[1].text = '' if columns[1].text == nil
+    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