rubyslim 0.1.1

data/.gitignore

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

data/Gemfile

@@ -0,0 +1,3 @@
+source "http://www.rubygems.org"
+
+gemspec

data/Gemfile.lock

@@ -0,0 +1,16 @@
+PATH
+  remote: .
+  specs:
+    rubyslim (0.1.1)
+
+GEM
+  remote: http://www.rubygems.org/
+  specs:
+    rspec (1.3.2)
+
+PLATFORMS
+  ruby
+
+DEPENDENCIES
+  rspec (~> 1.3.0)
+  rubyslim!

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
+
+$:.unshift(File.expand_path(File.dirname(__FILE__) + "/../lib/"))
+
+require 'rubyslim/ruby_slim'
+
+port = ARGV[0].to_i
+rubySlim = RubySlim.new
+rubySlim.run(port)
+

data/lib/rubyslim/list_deserializer.rb

@@ -0,0 +1,67 @@
+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.length > 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,43 @@
+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.length)
+      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