ikra 0.0.1

data/lib/sourcify/spec/proc/readme

@@ -0,0 +1,5 @@
+Since Proc#to_source depends on Proc#to_sexp, getting Proc#to_source correct
+implies the correctness of Proc#to_sexp, thus, there is no need to maintain
+2 sets of almost similar specs ... the only spec worth maintaining separately
+is the one for variables, since we are concerned with whether the correct
+representation of sexp is there.

data/lib/sourcify/spec/proc/spec_helper.rb

@@ -0,0 +1 @@
+require File.join(File.expand_path(File.dirname(__FILE__)), '..', 'spec_helper')

data/lib/sourcify/spec/proc/to_raw_source_spec.rb

@@ -0,0 +1,33 @@
+require File.join(File.expand_path(File.dirname(__FILE__)), 'spec_helper')
+
+describe "Proc#to_raw_source" do
+
+  should 'retain comments' do
+    (
+      lambda do
+        a = 1
+        # i should stay !!
+      end
+    ).should.be having_raw_source(%(
+      proc do
+        a = 1
+        # i should stay !!
+      end
+    ))
+  end
+
+  should 'retain last nil statement' do
+    (
+      lambda do
+        a = 1
+        nil
+      end
+    ).should.be having_raw_source(%(
+      proc do
+        a = 1
+        nil
+      end
+    ))
+  end
+
+end

data/lib/sourcify/spec/proc/to_raw_source_w_specified_strip_enclosure_spec.rb

@@ -0,0 +1,69 @@
+require File.join(File.expand_path(File.dirname(__FILE__)), 'spec_helper')
+
+describe 'Proc#to_raw_source w specified {:strip_enclosure => ...}' do
+
+  describe '>> w true' do
+
+    options = {:strip_enclosure => true}
+
+    should 'strip enclosing proc wo arg' do
+      (
+        lambda do
+          a = 1
+          # i should stay !!
+        end
+      ).should.be having_raw_source(%(
+          a = 1
+          # i should stay !!
+      ), options)
+    end
+
+    should 'strip enclosing proc w arg' do
+      (
+        lambda do |a|
+          a = 1
+          # i should stay !!
+        end
+      ).should.be having_raw_source(%(
+          a = 1
+          # i should stay !!
+      ), options)
+    end
+
+  end
+
+  describe '>> w false' do
+
+    options = {:strip_enclosure => false}
+
+    should 'not strip enclosing proc wo arg' do
+      (
+        lambda do
+          a = 1
+          # i should stay !!
+        end
+      ).should.be having_raw_source(%(
+        proc do
+          a = 1
+          # i should stay !!
+        end
+      ), options)
+    end
+
+    should 'not strip enclosing proc w arg' do
+      (
+        lambda do |a|
+          a = 1
+          # i should stay !!
+        end
+      ).should.be having_raw_source(%(
+        proc do |a|
+          a = 1
+          # i should stay !!
+        end
+      ), options)
+    end
+
+  end
+
+end

data/lib/sourcify/spec/proc/to_sexp_from_multi_blocks_w_specified_attached_to_spec.rb

@@ -0,0 +1,46 @@
+require File.join(File.expand_path(File.dirname(__FILE__)), 'spec_helper')
+
+describe 'Proc#to_sexp w specified {:attached_to => ...}' do
+
+  # NOTE: We just want enough specs to show that handling of :attached_to
+  # works for Proc#to_sexp as well.
+
+  options = {:attached_to => /^.*?(\W|)watever(\W)/}
+
+  should 'handle no nesting on same line' do
+    b1 = lambda {|a| @x1+1 }; b2 = watever { @x1+2 }; b3 = lambda { @x1+3 }
+    b2.should.be having_sexp(
+      s(:iter,
+        s(:call, nil, :proc, s(:arglist)),
+        nil,
+        s(:call, s(:ivar, :@x1), :+, s(:arglist, s(:lit, 2)))),
+      options
+    )
+  end
+
+  should 'handle single level nesting on same line' do
+    b1 = lambda {|a| @x2+1 }; b2 = watever { lambda { @x2+2 } }
+    b2.should.be having_sexp(
+      s(:iter,
+        s(:call, nil, :proc, s(:arglist)),
+        nil,
+        s(:iter,
+          s(:call, nil, :lambda, s(:arglist)),
+          nil,
+          s(:call, s(:ivar, :@x2), :+, s(:arglist, s(:lit, 2))))),
+      options
+    )
+  end
+
+  should 'handle multi level nesting on same line' do
+    b2 = (lambda {|a| watever { lambda { @x3 } } }).call(1)
+    b2.should.be having_sexp(
+      s(:iter,
+        s(:call, nil, :proc, s(:arglist)),
+        nil,
+        s(:iter, s(:call, nil, :lambda, s(:arglist)), nil, s(:ivar, :@x3))),
+      options
+    )
+  end
+
+end

data/lib/sourcify/spec/proc/to_sexp_variables_spec.rb

@@ -0,0 +1,146 @@
+require File.join(File.expand_path(File.dirname(__FILE__)), 'spec_helper')
+
+describe "Proc#to_sexp (variables)" do
+
+  should 'handle non var' do
+    expected = s(:iter, s(:call, nil, :proc, s(:arglist)), nil, s(:call, nil, :x, s(:arglist)))
+    lambda { x }.should.be having_sexp(expected)
+  end
+
+  should 'handle local var' do
+    x, expected = 'lx', s(:iter, s(:call, nil, :proc, s(:arglist)), nil, s(:lvar, :x))
+    lambda { x }.should.be having_sexp(expected)
+  end
+
+  should 'handle instance var' do
+    @x, expected = 'ix', s(:iter, s(:call, nil, :proc, s(:arglist)), nil, s(:ivar, :@x))
+    lambda { @x }.should.be having_sexp(expected)
+  end
+
+  should 'handle class var' do
+    @@x, expected = 'cx', s(:iter, s(:call, nil, :proc, s(:arglist)), nil, s(:cvar, :@@x))
+    lambda { @@x }.should.be having_sexp(expected)
+  end
+
+  should 'handle global var' do
+    $x, expected = 'gx', s(:iter, s(:call, nil, :proc, s(:arglist)), nil, s(:gvar, :$x))
+    lambda { $x }.should.be having_sexp(expected)
+  end
+
+  should 'handle class_eval scoped local var' do
+    (
+      x = 1
+      lambda { Object.class_eval {|x| y = x } }
+    ).should.be having_sexp(
+      s(:iter,
+        s(:call, nil, :proc, s(:arglist)),
+        nil,
+        s(:iter,
+          s(:call, s(:const, :Object), :class_eval, s(:arglist)),
+          s(:lasgn, :x),
+          s(:lasgn, :y, s(:lvar, :x))))
+    )
+  end
+
+  should 'handle instance_eval scoped local var' do
+    (
+      x = 1
+      lambda { 'aa'.instance_eval {|x| y = x } }
+    ).should.be having_sexp(
+      s(:iter,
+        s(:call, nil, :proc, s(:arglist)),
+        nil,
+        s(:iter,
+          s(:call, s(:str, "aa"), :instance_eval, s(:arglist)),
+          s(:lasgn, :x),
+          s(:lasgn, :y, s(:lvar, :x))))
+    )
+  end
+
+  should 'handle define_method scoped local var' do
+    (
+      x = 1
+      lambda { Object.send(:define_method, :aa) {|x| y = x } }
+    ).should.be having_sexp(
+      s(:iter,
+        s(:call, nil, :proc, s(:arglist)),
+        nil,
+        s(:iter,
+          s(:call,
+            s(:const, :Object),
+            :send,
+            s(:arglist, s(:lit, :define_method), s(:lit, :aa))),
+            s(:lasgn, :x),
+            s(:lasgn, :y, s(:lvar, :x))))
+    )
+  end
+
+  should 'not handle class scoped local var (simple)' do
+    (
+      x = 1
+      lambda { class AA ; y = x ; end }
+    ).should.be having_sexp(
+      s(:iter,
+        s(:call, nil, :proc, s(:arglist)),
+        nil,
+        s(:class, :AA, nil, s(:scope, s(:lasgn, :y, s(:call, nil, :x, s(:arglist))))))
+    )
+  end
+
+  should 'not handle class scoped local var (w inheritance)' do
+    (
+      x = 1
+      lambda { class AA < Object; y = x ; end }
+    ).should.be having_sexp(
+      s(:iter,
+        s(:call, nil, :proc, s(:arglist)),
+        nil,
+        s(:class,
+          :AA,
+          s(:const, :Object),
+          s(:scope, s(:lasgn, :y, s(:call, nil, :x, s(:arglist))))))
+    )
+  end
+
+  should 'not handle class scoped local var (w singleton)' do
+    (
+      x = 1
+      lambda { class << 'AA'; y = x ; end }
+    ).should.be having_sexp(
+      s(:iter,
+        s(:call, nil, :proc, s(:arglist)),
+        nil,
+        s(:sclass,
+          s(:str, "AA"),
+          s(:scope, s(:lasgn, :y, s(:call, nil, :x, s(:arglist))))))
+    )
+  end
+
+  should 'not handle module scoped local var' do
+    (
+      x = 1
+      lambda { module AA ; y = x ; end }
+    ).should.be having_sexp(
+      s(:iter,
+        s(:call, nil, :proc, s(:arglist)),
+        nil,
+        s(:module, :AA, s(:scope, s(:lasgn, :y, s(:call, nil, :x, s(:arglist))))))
+    )
+  end
+
+  should 'not handle method scoped local var' do
+    (
+      x = 1
+      lambda { def aa ; y = x ; end }
+    ).should.be having_sexp(
+      s(:iter,
+        s(:call, nil, :proc, s(:arglist)),
+        nil,
+        s(:defn,
+          :aa,
+          s(:args),
+          s(:scope, s(:block, s(:lasgn, :y, s(:call, nil, :x, s(:arglist)))))))
+    )
+  end
+
+end

data/lib/sourcify/spec/proc/to_sexp_w_specified_strip_enclosure_spec.rb

@@ -0,0 +1,60 @@
+require File.join(File.expand_path(File.dirname(__FILE__)), 'spec_helper')
+
+describe 'Proc#to_sexp w specified {:strip_enclosure => ...}' do
+
+  describe '>> w true' do
+
+    options = {:strip_enclosure => true}
+
+    should 'strip enclosing proc wo arg' do
+      lambda { a+b }.should.be having_sexp(
+        s(:call,
+          s(:call, nil, :a, s(:arglist)),
+          :+,
+          s(:arglist, s(:call, nil, :b, s(:arglist)))),
+        options
+      )
+    end
+
+    should 'strip enclosing proc w arg' do
+      lambda {|a| a+b }.should.be having_sexp(
+        s(:call,
+          s(:lvar, :a),
+          :+,
+          s(:arglist, s(:call, nil, :b, s(:arglist)))),
+        options
+      )
+    end
+
+  end
+
+  describe '>> w false' do
+
+    options = {:strip_enclosure => false}
+
+    should 'not strip enclosing proc wo arg' do
+      lambda { a+b }.should.be having_sexp(
+        s(:iter,
+          s(:call, nil, :proc, s(:arglist)),
+          nil,
+          s(:call,
+            s(:call, nil, :a, s(:arglist)),
+            :+,
+            s(:arglist, s(:call, nil, :b, s(:arglist))))),
+        options
+      )
+    end
+
+    should 'not strip enclosing proc w arg' do
+      lambda {|a| a+b }.should.be having_sexp(
+        s(:iter,
+          s(:call, nil, :proc, s(:arglist)),
+          s(:lasgn, :a),
+          s(:call, s(:lvar, :a), :+, s(:arglist, s(:call, nil, :b, s(:arglist))))),
+        options
+      )
+    end
+
+  end
+
+end

data/lib/sourcify/spec/proc/to_sexp_within_irb_spec.rb

@@ -0,0 +1,146 @@
+require File.join(File.expand_path(File.dirname(__FILE__)), 'spec_helper')
+
+describe "Proc#to_sexp within IRB" do
+
+  class << self
+
+    def irb_eval(string)
+      irb_exec(string)[-1]
+    end
+
+    def equal_to(expected)
+      lambda {|found| found == expected }
+    end
+
+  end
+
+  should 'handle non var' do
+    expected = s(:iter, s(:call, nil, :proc, s(:arglist)), nil, s(:call, nil, :x, s(:arglist)))
+    irb_eval('lambda { x }.to_sexp').should.be equal_to(expected)
+  end
+
+  should 'handle local var' do
+    expected = s(:iter, s(:call, nil, :proc, s(:arglist)), nil, s(:lvar, :x))
+    irb_eval(%Q(
+      x = 'lx'
+      lambda { x }.to_sexp
+    )).should.be equal_to(expected)
+  end
+
+  should 'handle class_eval scoped local var' do
+    expected =
+      s(:iter,
+        s(:call, nil, :proc, s(:arglist)),
+        nil,
+        s(:iter,
+          s(:call, s(:const, :Object), :class_eval, s(:arglist)),
+          s(:lasgn, :x),
+          s(:lasgn, :y, s(:lvar, :x))))
+    irb_eval(%Q(
+      x = 1
+      lambda { Object.class_eval {|x| y = x } }.to_sexp
+    )).should.be equal_to(expected)
+  end
+
+  should 'handle instance_eval scoped local var' do
+    expected =
+      s(:iter,
+        s(:call, nil, :proc, s(:arglist)),
+        nil,
+        s(:iter,
+          s(:call, s(:str, "aa"), :instance_eval, s(:arglist)),
+          s(:lasgn, :x),
+          s(:lasgn, :y, s(:lvar, :x))))
+    irb_eval(%Q(
+      x = 1
+      lambda { 'aa'.instance_eval {|x| y = x } }.to_sexp
+    )).should.be equal_to(expected)
+  end
+
+  should 'handle define_method scoped local var' do
+    expected =
+      s(:iter,
+        s(:call, nil, :proc, s(:arglist)),
+        nil,
+        s(:iter,
+          s(:call,
+            s(:const, :Object),
+            :send,
+            s(:arglist, s(:lit, :define_method), s(:lit, :aa))),
+            s(:lasgn, :x),
+            s(:lasgn, :y, s(:lvar, :x))))
+    irb_eval(%Q(
+      x = 1
+      lambda { Object.send(:define_method, :aa) {|x| y = x } }.to_sexp
+    )).should.be equal_to(expected)
+  end
+
+  should 'not handle class scoped local var (simple)' do
+    expected =
+      s(:iter,
+        s(:call, nil, :proc, s(:arglist)),
+        nil,
+        s(:class, :AA, nil, s(:scope, s(:lasgn, :y, s(:call, nil, :x, s(:arglist))))))
+    irb_eval(%Q(
+      x = 1
+      lambda { class AA ; y = x ; end }.to_sexp
+    )).should.be equal_to(expected)
+  end
+
+  should 'not handle class scoped local var (w inheritance)' do
+    expected =
+      s(:iter,
+        s(:call, nil, :proc, s(:arglist)),
+        nil,
+        s(:class,
+          :AA,
+          s(:const, :Object),
+          s(:scope, s(:lasgn, :y, s(:call, nil, :x, s(:arglist))))))
+    irb_eval(%Q(
+      x = 1
+      lambda { class AA < Object; y = x ; end }.to_sexp
+    )).should.be equal_to(expected)
+  end
+
+  should 'not handle class scoped local var (w singleton)' do
+    expected =
+      s(:iter,
+        s(:call, nil, :proc, s(:arglist)),
+        nil,
+        s(:sclass,
+          s(:str, "AA"),
+          s(:scope, s(:lasgn, :y, s(:call, nil, :x, s(:arglist))))))
+    irb_eval(%Q(
+      x = 1
+      lambda { class << 'AA'; y = x ; end }.to_sexp
+    )).should.be equal_to(expected)
+  end
+
+  should 'not handle module scoped local var' do
+    expected =
+      s(:iter,
+        s(:call, nil, :proc, s(:arglist)),
+        nil,
+        s(:module, :AA, s(:scope, s(:lasgn, :y, s(:call, nil, :x, s(:arglist))))))
+    irb_eval(%Q(
+      x = 1
+      lambda { module AA ; y = x ; end }.to_sexp
+    )).should.be equal_to(expected)
+  end
+
+  should 'not handle method scoped local var' do
+    expected =
+      s(:iter,
+        s(:call, nil, :proc, s(:arglist)),
+        nil,
+        s(:defn,
+          :aa,
+          s(:args),
+          s(:scope, s(:block, s(:lasgn, :y, s(:call, nil, :x, s(:arglist)))))))
+    irb_eval(%Q(
+      x = 1
+      lambda { def aa ; y = x ; end }.to_sexp
+    )).should.be equal_to(expected)
+  end
+
+end