iba 0.0.1 → 0.0.2

data/README.rdoc

@@ -39,8 +39,11 @@ to the contents of the block.
 Current limits:
 
 * Only single-expression blocks are supported.
-* The expression must start with a method-like identifier (like 'foo', but
-  not 'Foo' or '23'). In practice, this produces quite natural results.
+* The expression must start with a method-like identifier or an instance
+  variable (like 'foo'  or '@foo', but not 'Foo' or '23'). In practice,
+  this produces quite natural results.
+* Local and instance variables whose names start with an underscore should
+  not be used inside the block.
 
 Iba's implementation is inspired by Arlo[2], a generic combinator library
 for Python.

data/lib/iba.rb

@@ -18,20 +18,16 @@ class Combinator
   end
 
   def analyse
-    if expression._to_s == ""
-      "empty block"
-    else
-      str = "#{self.to_s} is #{self.call.inspect}"
-      if expression.class == MethodCallExpression and expression._method == :==
-	b = @block.binding
-	lft = expression._reciever
-	rgt = expression._args.first
-	exprs = [lft, rgt].map {|e| display_subexpression e}.compact
-	str << "\n"
-	str << exprs.join(", ")
-      end
-      str
+    str = "#{self.to_s} is #{self.call.inspect}"
+    if expression.class == MethodCallExpression and expression._method == :==
+      b = @block.binding
+      lft = expression._reciever
+      rgt = expression._args.first
+      exprs = [lft, rgt].map {|e| display_subexpression e}.compact
+      str << "\n"
+      str << exprs.join(", ")
     end
+    str
   end
 
   private
@@ -41,7 +37,7 @@ class Combinator
       nil
     else
       str = expr._to_s
-      "#{str} is #{eval str, @block.binding}"
+      "#{str} is #{eval(str, @block.binding).inspect}"
     end
   end
 
@@ -56,23 +52,42 @@ class EmptyExpression
     b = blk.binding
 
     vars = eval "local_variables", b
-    vars.each do |v|
-      next if v =~ /^_/
-      eval "_#{v} = #{v}", b
-      eval "#{v} = Iba::MethodCallExpression.new(Iba::EmptyExpression.new, :#{v}, [])", b
-    end
+    ivars = eval "instance_variables", b
+
+    _override_instance_variables ivars
+
+    _override_local_variables vars, b
 
     result = self.instance_eval(&blk)
     unless result.class == MethodCallExpression
       result = LiteralExpression.new(result)
     end
 
+    _restore_local_variables vars, b
+
+    result
+  end
+
+  def _override_instance_variables vars
+    vars.each do |v|
+      next if v =~ /^@_/
+      eval "#{v} = Iba::MethodCallExpression.new(Iba::EmptyExpression.new, :#{v}, [])"
+    end
+  end
+
+  def _override_local_variables vars, b
     vars.each do |v|
       next if v =~ /^_/
-      eval "#{v} = _#{v}", b
+      eval "_#{v} = #{v}", b
+      eval "#{v} = Iba::MethodCallExpression.new(Iba::EmptyExpression.new, :#{v}, [])", b
     end
+  end
 
-    result
+  def _restore_local_variables vars, b
+    vars.each do |v|
+      next if v =~ /^_/
+      eval "#{v} = _#{v}", b
+    end
   end
 
   def _to_s
@@ -86,49 +101,38 @@ class LiteralExpression
   end
 
   def _to_s
-    @value.to_s
+    @value.inspect
   end
 end
 
 class MethodCallExpression
-  OPERATORS = [:+]
-  def initialize reciever, methodname, args
-    @reciever = reciever
-    @method = methodname
-    @args = args.map {|a| _wrap(a)}
-  end
-
-  def _method
-    @method
-  end
-
-  def _reciever
-    @reciever
-  end
+  attr_reader :_method, :_reciever, :_args
 
-  def _args
-    @args
+  def initialize reciever, methodname, args
+    @_reciever = reciever
+    @_method = methodname
+    @_args = args.map {|a| _wrap(a)}
   end
 
   def _to_s
-    rcv = @reciever._to_s
-    args = @args.map {|a| a.respond_to?(:_to_s) ? a._to_s : a.to_s }
+    rcv = @_reciever._to_s
+    args = @_args.map {|a| a.respond_to?(:_to_s) ? a._to_s : a.to_s }
 
-    if @method == :[]
+    if @_method == :[]
       "#{rcv}[#{args[0]}]"
     elsif method_is_operator?
-      case @args.length
+      case @_args.length
       when 0
-	"#{@method.to_s.sub(/@$/, '')}#{rcv}"
+	"#{@_method.to_s.sub(/@$/, '')}#{rcv}"
       when 1
-	"(#{rcv} #{@method} #{args.first})"
+	"(#{rcv} #{@_method} #{args.first})"
       else
 	raise NotImplementedError
       end
     else
       str = rcv == "" ? "" : "#{rcv}."
-      str << @method.to_s
-      unless @args.empty?
+      str << @_method.to_s
+      unless @_args.empty?
 	str << "(#{args.join(', ')})"
       end
       str
@@ -141,7 +145,7 @@ class MethodCallExpression
   end
 
   def method_is_operator?
-    @method.to_s !~ /^[a-z]/
+    @_method.to_s !~ /^[a-z]/
   end
 
   def to_s

data/test/analyse_test.rb

@@ -3,7 +3,7 @@ require File.expand_path('test_helper.rb', File.dirname(__FILE__))
 # Test how the combinator analyses the parsed block contents.
 class AnalyseTest < Test::Unit::TestCase
   def test_empty_block
-    assert_equal "empty block", combinator { }.analyse
+    assert_equal "nil is nil", combinator { }.analyse
   end
 
   def test_variable
@@ -24,11 +24,22 @@ class AnalyseTest < Test::Unit::TestCase
       combinator { foo == 23 }.analyse 
   end
 
+  def test_operator_equals_array_literal
+    foo = [1, "bar"]
+    assert_equal "(foo == [2, \"baz\"]) is false\nfoo is [1, \"bar\"]",
+      combinator { foo == [2, "baz"] }.analyse 
+  end
+
   def test_string_variable
     foo = "blub"
     assert_equal "foo is \"blub\"", combinator { foo }.analyse
   end
 
+  def test_array_variable
+    foo = [1, 2]
+    assert_equal "foo is [1, 2]", combinator { foo }.analyse
+  end
+
   def test_object_variable
     foo = Object.new
     insp = foo.inspect
@@ -38,5 +49,10 @@ class AnalyseTest < Test::Unit::TestCase
   def test_literal
     assert_equal "23 is 23", combinator { 23 }.analyse
   end
+
+  def test_instance_variable
+    @foo = 23
+    assert_equal "@foo is 23", combinator { @foo }.analyse
+  end
 end
 

data/test/assert_test.rb

@@ -6,23 +6,30 @@ class AssertTest < Test::Unit::TestCase
     assert { true }
   end
 
-  def test_simple_failing_assert
+  def failing_block_assertion_test message, &block
     begin
-      assert { false }
+      assert(&block)
     rescue Exception => e
-      assert_equal "false is false.", e.message
+      assert_equal message, e.message
     end
   end
 
+  def test_simple_failing_assert
+    failing_block_assertion_test("false is false.") { false }
+  end
+
   def test_operator_equals_assert
     foo = 24
-    begin
-      assert { foo == 23  }
-    rescue Exception => e
-      assert_equal "(foo == 23) is false\nfoo is 24.", e.message
-    end
+    failing_block_assertion_test("(foo == 23) is false\nfoo is 24.") { foo == 23  }
   end
 
+  def test_instance_variable_assert
+    @foo = 24
+    failing_block_assertion_test("(@foo == 23) is false\n@foo is 24.") { @foo == 23  }
+  end
+
+  # Special cases
+
   def test_assert_with_custom_message
     foo = false
     begin

data/test/display_test.rb

@@ -3,13 +3,17 @@ require File.expand_path('test_helper.rb', File.dirname(__FILE__))
 # Test how the combinator displays the parsed block contents.
 class DisplayTest < Test::Unit::TestCase
   def test_empty_combinator
-    assert_equal "", combinator { }.to_s
+    assert_equal "nil", combinator { }.to_s
   end
 
-  def test_literal
+  def test_literal_number
     assert_equal "23", combinator { 23 }.to_s
   end
 
+  def test_literal_string
+    assert_equal "\"aa\"", combinator { "aa" }.to_s
+  end
+
   def test_method_calls
     assert_equal "foo", combinator { foo }.to_s
     assert_equal "foo.foo", combinator { foo.foo }.to_s
@@ -45,4 +49,9 @@ class DisplayTest < Test::Unit::TestCase
   def test_operator_if_wont_work
     assert_equal "bar", combinator { foo ? bar : baz }.to_s
   end
+
+  def test_defined_instance_variables
+    @foo = 1
+    assert_equal "@foo", combinator { @foo }.to_s
+  end
 end

metadata

@@ -1,13 +1,13 @@
 --- !ruby/object:Gem::Specification 
 name: iba
 version: !ruby/object:Gem::Version 
-  hash: 29
+  hash: 27
   prerelease: false
   segments: 
   - 0
   - 0
-  - 1
-  version: 0.0.1
+  - 2
+  version: 0.0.2
 platform: ruby
 authors: 
 - Matijs van Zuijlen
@@ -15,7 +15,7 @@ autorequire:
 bindir: bin
 cert_chain: []
 
-date: 2011-01-02 00:00:00 +01:00
+date: 2011-02-25 00:00:00 +01:00
 default_executable: 
 dependencies: []