rubyslim-unofficial 0.0.1

data/.gitignore

@@ -0,0 +1,7 @@
+.rakeTasks
+*.iml
+*.ipr
+*.iws
+.DS_Store
+.idea
+

data/Gemfile

@@ -0,0 +1,2 @@
+source :rubygems
+gemspec

data/README.md

@@ -0,0 +1,187 @@
+Ruby Slim
+=========
+
+This package provides a SliM server implementing the [FitNesse](http://fitnesse.org)
+[SliM protocol](http://fitnesse.org/FitNesse.UserGuide.SliM.SlimProtocol). It allows
+you to write test fixtures in Ruby, and invoke them from a FitNesse test.
+
+
+Fixture names
+-------------
+
+Rubyslim is very particular about how your modules and classes are named, and
+how you import and use them in your FitNesse wiki:
+
+* Fixture folder must be `lowercase_and_underscore`
+* Fixture filenames must be `lowercase_and_underscore`
+* Ruby module name must be the `CamelCase` version of fixture folder name
+* Ruby class name must be the `CamelCase` version of the fixture file name
+
+For example, this naming scheme is valid:
+
+* Folder: `ruby_fix`
+* Filename: `my_fixture.rb`
+* Module: `RubyFix`
+* Class: `MyFixture`
+
+If you have `TwoWords` in CamelCase, then that would be `two_words` with
+underscores. If you have only `oneword` in the lowercase version, then you must
+have `Oneword` in the CamelCase version. If all of these naming conventions are
+not exactly followed, you'll get mysterious errors like `Could not invoke
+constructor` for your Slim tables.
+
+
+Setup
+-----
+
+Put these commands in a parent of the Ruby test pages.
+
+    !define TEST_SYSTEM {slim}
+    !define TEST_RUNNER {rubyslim}
+    !define COMMAND_PATTERN {rubyslim}
+    !path your/ruby/fixtures
+
+Paths can be relative. You should put the following in an appropriate SetUp page:
+
+    !|import|
+    |<ruby module of fixtures>|
+
+You can have as many rows in this table as you like, one for each module that
+contains fixtures. Note that this needs to be the *name* of the module as
+written in the Ruby code, not the filename where the module is defined.
+
+Ruby slim works a lot like Java slim. We tried to use ruby method naming
+conventions. So if you put this in a table:
+
+    |SomeDecisionTable|
+    |input|get output?|
+    |1    |2          |
+
+Then it will call the `set_input` and `get_output` functions of the
+`SomeDecisionTable` class.
+
+The `SomeDecisionTable` class would be written in a file called
+`some_decision_table.rb`, like this (the file name must correspond to the class
+name defined within, and the module name must match the one you are importing):
+
+    module MyModule
+      class SomeDecisionTable
+        def set_input(input)
+          @x = input
+        end
+
+        def get_output
+          @x
+        end
+      end
+    end
+
+Note that there is no type information for the arguments of these functions, so
+they will all be treated as strings. This is important to remember! All
+arguments are strings. If you are expecting integers, you will have to convert
+the strings to integers within your fixtures.
+
+
+Hashes
+------
+
+There is one exception to the above rule. If you pass a HashWidget in a table,
+then the argument will be converted to a Hash.
+
+Consider, for example, this fixtures class:
+
+    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
+
+This corresponds to the following tables.
+
+    |script|test slim with arguments|!{name:bob addr:here}|
+    |check|name|bob|
+    |check|addr|here|
+
+    |script|test slim with arguments|gunk|
+    |check|arg|gunk|
+    |set arg|!{name:bob addr:here}|
+    |check|name|bob|
+    |check|addr|here|
+
+Note the use of the HashWidgets in the table cells. These get translated into
+HTML, which RubySlim recognizes and converts to a standard ruby `Hash`.
+
+
+System Under Test
+-----------------
+
+If a fixture has a `sut` method that returns an object, then if a method called
+by a test is not found in the fixture itself, then if it exists in the object
+returned by `sut` it will be called. For example:
+
+    !|script|my fixture|
+    |func|1|
+
+    class MySystem
+      def func(x)
+        #this is the function that will be called.
+      end
+    end
+
+    class MyFixture
+      attr_reader :sut
+
+      def initialize
+        @sut = MySystem.new
+      end
+    end
+
+Since the fixture `MyFixture` does not have a function named `func`, but it
+_does_ have a method named `sut`, RubySlim will try to call `func` on the
+object returned by `sut`.
+
+
+Library Fixtures
+----------------
+
+Ruby Slim supports the `|Library|` feature of FitNesse. If you declare certain
+classes to be libraries, then if a test calls a method, and the specified
+fixture does not have it, and there is no specified `sut`, then the libraries
+will be searched in reverse order (latest first). If the method is found, then
+it is called.
+
+For example:
+
+    |Library|
+    |echo fixture|
+
+    |script|
+    |check|echo|a|a|
+
+    class EchoFixture
+      def echo(x)
+        x
+      end
+    end
+
+Here, even though no fixture was specified for the script table, since a
+library was declared, functions will be called on it.
+

data/Rakefile

@@ -0,0 +1,21 @@
+require 'rake'
+#require 'rcov/rcovtask'
+require 'spec/rake/spectask'
+
+task :default => :spec
+
+desc "Run all spec tests"
+Spec::Rake::SpecTask.new(:spec) do |t|
+  t.spec_files = Dir.glob('spec/**/*_spec.rb')
+  t.spec_opts = ['--color', '--format specdoc']
+end
+
+desc "Run all spec tests and generate coverage report"
+Spec::Rake::SpecTask.new(:rcov) do |t|
+  t.spec_files = Dir.glob('spec/**/*_spec.rb')
+  # RCov doesn't like this part for some reason
+  #t.spec_opts = ['--color', '--format specdoc']
+  t.rcov = true
+  t.rcov_opts = %w{--exclude osx\/objc,gems\/,spec\/,features\/,lib\/test_module\/}
+end
+

data/bin/rubyslim

@@ -0,0 +1,10 @@
+#!/usr/bin/env ruby
+
+require 'rubyslim/ruby_slim'
+require 'jcode'
+$KCODE="UTF8"
+
+port = ARGV[0].to_i
+rubySlim = RubySlim.new
+rubySlim.run(port)
+

data/lib/rubyslim/list_deserializer.rb

@@ -0,0 +1,69 @@
+require 'jcode'
+
+module ListDeserializer
+  class SyntaxError < Exception
+  end
+
+  # De-serialize the given string, and return a Ruby-native list.
+  # Raises a SyntaxError if the string is empty or badly-formatted.
+  def self.deserialize(string)
+    raise SyntaxError.new("Can't deserialize null") if string.nil?
+    raise SyntaxError.new("Can't deserialize empty string") if string.empty?
+    raise SyntaxError.new("Serialized list has no starting [") if string[0..0] != "["
+    raise SyntaxError.new("Serialized list has no ending ]") if string[-1..-1] != "]"
+    Deserializer.new(string).deserialize
+  end
+
+
+  class Deserializer
+    def initialize(string)
+      @string = string;
+    end
+
+    def deserialize
+      @pos = 1
+      @list = []
+      number_of_items = consume_length
+
+      # For each item in the list
+      number_of_items.times do
+        length_of_item = consume_length
+        item = @string[@pos...@pos+length_of_item]
+        length_in_bytes = length_of_item
+
+        until (item.jlength > length_of_item) do
+          length_in_bytes += 1
+          item = @string[@pos...@pos+length_in_bytes]
+        end
+
+        length_in_bytes -= 1
+        item = @string[@pos...@pos+length_in_bytes]
+
+        # Ensure the ':' list-termination character is found
+        term_char = @string[@pos+length_in_bytes,1]
+        if term_char != ':'
+          raise SyntaxError.new("List termination character ':' not found" +
+                               " (got '#{term_char}' instead)")
+        end
+
+        @pos += length_in_bytes+1
+        begin
+          sublist = ListDeserializer.deserialize(item)
+          @list << sublist
+        rescue ListDeserializer::SyntaxError
+          @list << item
+        end
+      end
+      @list
+    end
+
+    # Consume the 6-digit length prefix, and return the
+    # length as an integer.
+    def consume_length
+      length = @string[@pos...@pos+6].to_i
+      @pos += 7
+      length
+    end
+
+  end
+end

data/lib/rubyslim/list_executor.rb

@@ -0,0 +1,12 @@
+require "rubyslim/statement"
+require "rubyslim/statement_executor"
+
+class ListExecutor
+  def initialize()
+    @executor = StatementExecutor.new
+  end
+
+  def execute(instructions)
+    instructions.collect {|instruction| Statement.execute(instruction, @executor)}
+  end
+end

data/lib/rubyslim/list_serializer.rb

@@ -0,0 +1,45 @@
+require 'jcode'
+
+module ListSerializer
+  # Serialize a list according to the SliM protocol.
+  #
+  # Lists are enclosed in square-brackets '[...]'. Inside the opening
+  # bracket is a six-digit number indicating the length of the list
+  # (number of items), then a colon ':', then the serialization of each
+  # list item. For example:
+  #
+  #   []         => "[000000:]"
+  #   ["hello"]  => "[000001:000005:hello:]"
+  #   [1]        => "[000001:000001:1:]"
+  #
+  # Strings are preceded by a six-digit sequence indicating their length:
+  #
+  #   ""         => "000000:"
+  #   "hello"    => "000005:hello"
+  #   nil        => "000004:null"
+  #
+  # See spec/list_serializer_spec.rb for more examples.
+  #
+  def self.serialize(list)
+    result = "["
+    result += length_string(list.length)
+
+    # Serialize each item in the list
+    list.each do |item|
+      item = "null" if item.nil?
+      item = serialize(item) if item.is_a?(Array)
+      item = item.to_s
+      result += length_string(item.jlength)
+      result += item + ":"
+    end
+
+    result += "]"
+  end
+
+
+  # Return the six-digit prefix for an element of the given length.
+  def self.length_string(length)
+    sprintf("%06d:",length)
+  end
+end
+

data/lib/rubyslim/ruby_slim.rb

@@ -0,0 +1,61 @@
+require "rubyslim/socket_service"
+require "rubyslim/list_deserializer"
+require "rubyslim/list_serializer"
+require "rubyslim/list_executor"
+
+class RubySlim
+  def run(port)
+    @connected = true
+    @executor = ListExecutor.new
+    socket_service = SocketService.new()
+    socket_service.serve(port) do |socket|
+      serve_ruby_slim(socket)
+    end
+
+    while (@connected)
+      sleep(0.1)
+    end
+  end
+
+  # Read and execute instructions from the SliM socket, until a 'bye'
+  # instruction is reached. Each instruction is a list, serialized as a string,
+  # following the SliM protocol:
+  #
+  #   length:command
+  #
+  # Where `length` is a 6-digit indicating the length in bytes of `command`,
+  # and `command` is a serialized list of instructions that may include any
+  # of the four standard instructions in the SliM protocol:
+  #
+  #   Import: [<id>, import, <path>]
+  #   Make: [<id>, make, <instance>, <class>, <arg>...]
+  #   Call: [<id>, call, <instance>, <function>, <arg>...]
+  #   CallAndAssign: [<id>, callAndAssign, <symbol>, <instance>, <function>, <arg>...]
+  #
+  # (from http://fitnesse.org/FitNesse.UserGuide.SliM.SlimProtocol)
+  #
+  def serve_ruby_slim(socket)
+    socket.puts("Slim -- V0.3");
+    said_bye = false
+
+    while !said_bye
+      length = socket.read(6).to_i   # <length>
+      socket.read(1)                 # :
+      command = socket.read(length)  # <command>
+
+      # Until a 'bye' command is received, deserialize the command, execute the
+      # instructions, and write a serialized response back to the socket.
+      if command.downcase != "bye"
+        instructions = ListDeserializer.deserialize(command);
+        results = @executor.execute(instructions)
+        response = ListSerializer.serialize(results);
+        socket.write(sprintf("%06d:%s", response.length, response))
+        socket.flush
+      else
+        said_bye = true
+      end
+    end
+    @connected = false
+  end
+end
+

data/lib/rubyslim/slim_error.rb

@@ -0,0 +1,3 @@
+class SlimError < Exception
+
+end

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