rsel 0.0.4 → 0.0.5

data/vendor/rubyslim-0.1.1/lib/rubyslim/statement.rb

@@ -1,79 +0,0 @@
-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/vendor/rubyslim-0.1.1/lib/rubyslim/statement_executor.rb

@@ -1,174 +0,0 @@
-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/vendor/rubyslim-0.1.1/lib/rubyslim/table_to_hash_converter.rb

@@ -1,32 +0,0 @@
-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/vendor/rubyslim-0.1.1/lib/test_module/library_new.rb

@@ -1,13 +0,0 @@
-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/vendor/rubyslim-0.1.1/lib/test_module/library_old.rb

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

data/vendor/rubyslim-0.1.1/lib/test_module/should_not_find_test_slim_in_here/test_slim.rb

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

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

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

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

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

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

@@ -1,86 +0,0 @@
-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/vendor/rubyslim-0.1.1/lib/test_module/test_slim_with_arguments.rb

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