ikra 0.0.1

data/lib/sourcify/spec/method/to_source_from_define_method_w_multi_blocks_and_single_match_spec.rb

@@ -0,0 +1,73 @@
+require File.join(File.expand_path(File.dirname(__FILE__)), 'spec_helper')
+
+describe 'Method#to_source (from define_method)' do
+  describe 'w single blocks and many matches' do
+
+    before { @thing = Object.new }
+
+    describe 'w do...end block' do
+      should 'skip non-matching w no nesting on same line' do
+        b1 = lambda do |a| @x1 end; b2 = lambda do |b| @x2 end
+        @thing.class.send(:define_method, :m1, &b2)
+        @thing.method(:m1).should.be having_source(%(
+          def m1(b)
+            @x2
+          end
+        ))
+      end
+
+      should 'skip non-matching w single level nesting on same line' do
+        b2 = (lambda do |a| lambda do |b| @x2 end end).call(1)
+        @thing.class.send(:define_method, :m2, &b2)
+        @thing.method(:m2).should.be having_source(%(
+          def m2(b)
+            @x2
+          end
+        ))
+      end
+
+      should 'skip non-matching w multi level nesting on same line' do
+        b2 = (lambda do |a| lambda do |b| b2 = lambda do |c| @x3 end end end).call(1).call(1)
+        @thing.class.send(:define_method, :m3, &b2)
+        @thing.method(:m3).should.be having_source(%(
+          def m3(c)
+            @x3
+          end
+        ))
+      end
+    end
+
+    describe 'w braced block' do
+      should 'skip non-matching w no nesting on same line' do
+        b1 = lambda {|a| @x1 }; b2 = lambda {|b| @x2 }
+        @thing.class.send(:define_method, :m1, &b2)
+        @thing.method(:m1).should.be having_source(%(
+          def m1(b)
+            @x2
+          end
+        ))
+      end
+
+      should 'skip non-matching w single level nesting on same line' do
+        b2 = (lambda {|a| lambda {|b| @x2 } }).call(1)
+        @thing.class.send(:define_method, :m2, &b2)
+        @thing.method(:m2).should.be having_source(%(
+          def m2(b)
+            @x2
+          end
+        ))
+      end
+
+      should 'skip non-matching w multi level nesting on same line' do
+        b2 = (lambda {|a| lambda {|b| b2 = lambda {|c| @x3 } } }).call(1).call(1)
+        @thing.class.send(:define_method, :m3, &b2)
+        @thing.method(:m3).should.be having_source(%(
+          def m3(c)
+            @x3
+          end
+        ))
+      end
+    end
+
+  end
+end

data/lib/sourcify/spec/method/to_source_from_define_method_w_multi_blocks_and_specified_attached_to_and_many_matches_spec.rb

@@ -0,0 +1,36 @@
+require File.join(File.expand_path(File.dirname(__FILE__)), 'spec_helper')
+
+describe 'Method#to_source (from define_method)' do
+  describe 'w specified {:attached_to => ...} & single match' do
+
+    before { @thing = Object.new }
+    options = {:attached_to => :lambda}
+
+    if has_parsetree?
+      # TODO: Should we support this ??
+    else
+
+      error = Sourcify::MultipleMatchingProcsPerLineError
+
+      should "raise #{error} w no nesting on same line" do
+        b1 = lambda {|a| @x }; b2 = lambda { @x }; b3 = lambda { @x }
+        @thing.class.send(:define_method, :m1, &b2)
+        lambda { @thing.method(:m1).to_source(options) }.should.raise(error)
+      end
+
+      should "raise #{error} w single level nesting on same line" do
+        b1 = lambda {|a| @x }; b2 = lambda { lambda { @x } }
+        @thing.class.send(:define_method, :m2, &b2)
+        lambda { @thing.method(:m2).to_source(options) }.should.raise(error)
+      end
+
+      should "raise #{error} w multi level nesting on same line" do
+        b2 = (lambda {|a| lambda { lambda { @x } } }).call(1)
+        @thing.class.send(:define_method, :m3, &b2)
+        lambda { @thing.method(:m3).to_source(options) }.should.raise(error)
+      end
+
+    end
+
+  end
+end

data/lib/sourcify/spec/method/to_source_from_define_method_w_multi_blocks_and_specified_attached_to_and_no_match_spec.rb

@@ -0,0 +1,36 @@
+require File.join(File.expand_path(File.dirname(__FILE__)), 'spec_helper')
+
+describe 'Method#to_source (from define_method)' do
+  describe 'w specified {:attached_to => ...} & no match' do
+
+    before { @thing = Object.new }
+    options = {:attached_to => :forever}
+
+    if has_parsetree?
+      # TODO: Should we support this ??
+    else
+
+      error = Sourcify::NoMatchingProcError
+
+      should "raise #{error} w no nesting on same line" do
+        b1 = lambda {|a| @x }; b2 = watever { @x }; b3 = lambda { @x }
+        @thing.class.send(:define_method, :m1, &b2)
+        lambda { @thing.method(:m1).to_source(options) }.should.raise(error)
+      end
+
+      should "raise #{error} w single level nesting on same line" do
+        b1 = lambda {|a| @x }; b2 = watever { lambda { @x } }
+        @thing.class.send(:define_method, :m2, &b2)
+        lambda { @thing.method(:m2).to_source(options) }.should.raise(error)
+      end
+
+      should "raise #{error} w multi level nesting on same line" do
+        b2 = (lambda {|a| watever { lambda { @x } } }).call(1)
+        @thing.class.send(:define_method, :m3, &b2)
+        lambda { @thing.method(:m3).to_source(options) }.should.raise(error)
+      end
+
+    end
+
+  end
+end

data/lib/sourcify/spec/method/to_source_from_define_method_w_multi_blocks_and_specified_attached_to_and_single_match_spec.rb

@@ -0,0 +1,28 @@
+require File.join(File.expand_path(File.dirname(__FILE__)), 'spec_helper')
+
+describe 'Method#to_source (from define_method)' do
+  describe 'w specified {:attached_to => ...} & single match' do
+
+    before { @thing = Object.new }
+    options = {:attached_to => :watever}
+
+    should 'handle no nesting on same line' do
+      b1 = lambda {|a| @x1+1 }; b2 = watever { @x1+2 }; b3 = lambda { @x1+3 }
+      @thing.class.send(:define_method, :m1, &b2)
+      @thing.method(:m1).should.be having_source('def m1; @x1+2; end', options)
+    end
+
+    should 'handle single level nesting on same line' do
+      b1 = lambda {|a| @x2+1 }; b2 = watever { lambda { @x2+2 } }
+      @thing.class.send(:define_method, :m2, &b2)
+      @thing.method(:m2).should.be having_source('def m2; lambda { @x2+2 }; end', options)
+    end
+
+    should 'handle multi level nesting on same line' do
+      b2 = (lambda {|a| watever { lambda { @x3 } } }).call(1)
+      @thing.class.send(:define_method, :m3, &b2)
+      @thing.method(:m3).should.be having_source('def m3; lambda { @x3 }; end', options)
+    end
+
+  end
+end

data/lib/sourcify/spec/method/to_source_from_define_method_w_multi_blocks_and_specified_attached_to_spec.rb

@@ -0,0 +1,103 @@
+require File.join(File.expand_path(File.dirname(__FILE__)), 'spec_helper')
+
+describe 'Method#to_source (from define_method)' do
+  describe 'w specified {:attached_to => ...}' do
+
+    if has_parsetree?
+      # TODO: Should we support this ??
+    else
+
+      before { @thing = Object.new }
+
+      err1 = Sourcify::MultipleMatchingProcsPerLineError
+      err2 = Sourcify::NoMatchingProcError
+
+      describe '>> w :attached_to as regexp' do
+
+        should "raise Sourcify::MultipleMatchingProcsPerLineError for multiple matches" do
+          b1 = lambda {|a| @x }; b2 = lambda { @x }; b3 = lambda { @x }
+          @thing.class.send(:define_method, :m1, &b2)
+          lambda { @thing.method(:m1).to_source(:attached_to => /^(?:.*?\W|)lambda(?:\W)/) }.should.raise(err1)
+        end
+
+        should "raise Sourcify::NoMatchingProcError for no match" do
+          b1 = lambda {|a| @x }; b2 = lambda { @x }; b3 = lambda { @x }
+          @thing.class.send(:define_method, :m2, &b2)
+          lambda { @thing.method(:m2).to_source(:attached_to => /^(?:.*?\W|)proc(?:\W)/) }.should.raise(err2)
+        end
+
+        should "handle for single match" do
+          b1 = lambda {|a| @x1 }; b2 = proc { @x2 }; b3 = lambda { @x3 }
+          @thing.class.send(:define_method, :m3, &b2)
+          @thing.method(:m3).should.be having_source('def m3; @x2; end', :attached_to => /^(?:.*?\W|)proc(?:\W)/)
+        end
+
+      end
+
+      describe '>> w :attached_to as string' do
+
+        should "raise Sourcify::MultipleMatchingProcsPerLineError for multiple matches" do
+          b1 = lambda {|a| @x }; b2 = lambda { @x }; b3 = lambda { @x }
+          @thing.class.send(:define_method, :m1, &b2)
+          lambda { @thing.method(:m1).to_source(:attached_to => 'lambda') }.should.raise(err1)
+        end
+
+        should "raise Sourcify::NoMatchingProcError for no match" do
+          b1 = lambda {|a| @x }; b2 = lambda { @x }; b3 = lambda { @x }
+          @thing.class.send(:define_method, :m2, &b2)
+          lambda { @thing.method(:m2).to_source(:attached_to => 'proc') }.should.raise(err2)
+        end
+
+        should "handle for single match" do
+          b1 = lambda {|a| @x1 }; b2 = proc { @x2 }; b3 = lambda { @x3 }
+          @thing.class.send(:define_method, :m3, &b2)
+          @thing.method(:m3).should.be having_source('def m3; @x2; end', :attached_to => 'proc')
+        end
+
+      end
+
+      describe '>> w :attached_to as symbol' do
+
+        should "raise Sourcify::MultipleMatchingProcsPerLineError for multiple matches" do
+          b1 = lambda {|a| @x }; b2 = lambda { @x }; b3 = lambda { @x }
+          @thing.class.send(:define_method, :m1, &b2)
+          lambda { @thing.method(:m1).to_source(:attached_to => :lambda) }.should.raise(err1)
+        end
+
+        should "raise Sourcify::NoMatchingProcError for no match" do
+          b1 = lambda {|a| @x }; b2 = lambda { @x }; b3 = lambda { @x }
+          @thing.class.send(:define_method, :m2, &b2)
+          lambda { @thing.method(:m2).to_source(:attached_to => :proc) }.should.raise(err2)
+        end
+
+        should "handle for single match" do
+          b1 = lambda {|a| @x1 }; b2 = proc { @x2 }; b3 = lambda { @x3 }
+          @thing.class.send(:define_method, :m3, &b2)
+          @thing.method(:m3).should.be having_source('def m3; @x2; end', :attached_to => :proc)
+        end
+
+      end
+
+      describe '>> w false start as a result of preceding hash' do
+
+        option = {:attached_to => :watever}
+        aa = :aa
+
+        should 'handle for do ... end block' do
+          x = watever({aa => 1, :bb => 3}) do :blah end
+          @thing.class.send(:define_method, :m1, &x)
+          @thing.method(:m1).should.be having_source('def m1; :blah; end', option)
+        end
+
+        should 'handle for { ... } block' do
+          x = watever({aa => 1, :bb => 3}) { :blah }
+          @thing.class.send(:define_method, :m2, &x)
+          @thing.method(:m2).should.be having_source('def m2; :blah; end', option)
+        end
+
+      end
+
+    end
+
+  end
+end

data/lib/sourcify/spec/method/to_source_from_define_method_w_multi_blocks_and_specified_body_matcher_and_many_matches_spec.rb

@@ -0,0 +1,36 @@
+require File.join(File.expand_path(File.dirname(__FILE__)), 'spec_helper')
+
+describe 'Method#to_source (from define_method)' do
+  describe 'w specified body matcher & single match' do
+
+    before { @thing = Object.new }
+    matcher = lambda {|code| code =~ /^(.*\W|)alert\W/ }
+
+    if has_parsetree?
+      # TODO: Should we support this ??
+    else
+
+      error = Sourcify::MultipleMatchingProcsPerLineError
+
+      should "raise #{error} w no nesting on same line" do
+        b1 = lambda {|a| @x }; b2 = lambda { alert(1) }; b3 = lambda { alert(2) }
+        @thing.class.send(:define_method, :m1, &b2)
+        lambda { @thing.method(:m1).to_source(&matcher) }.should.raise(error)
+      end
+
+      should "raise #{error} w single level nesting on same line" do
+        b1 = lambda {|a| @x }; b2 = lambda { lambda { alert(1) } }
+        @thing.class.send(:define_method, :m2, &b2)
+        lambda { @thing.method(:m2).to_source(&matcher) }.should.raise(error)
+      end
+
+      should "raise #{error} w multi level nesting on same line" do
+        b2 = (lambda {|a| lambda { lambda { alert(1) } } }).call(1)
+        @thing.class.send(:define_method, :m3, &b2)
+        lambda { @thing.method(:m3).to_source(&matcher) }.should.raise(error)
+      end
+
+    end
+
+  end
+end

data/lib/sourcify/spec/method/to_source_from_define_method_w_multi_blocks_and_specified_body_matcher_and_no_match_spec.rb

@@ -0,0 +1,36 @@
+require File.join(File.expand_path(File.dirname(__FILE__)), 'spec_helper')
+
+describe 'Method#to_source (from define_method)' do
+  describe 'w specified body matcher & no match' do
+
+    before { @thing = Object.new }
+    matcher = lambda {|code| code =~ /^(.*\W|)def\W/ }
+
+    if has_parsetree?
+      # TODO: Should we support this ??
+    else
+
+      error = Sourcify::NoMatchingProcError
+
+      should "raise #{error} w no nesting on same line" do
+        b1 = lambda {|a| @x }; b2 = lambda { @x }; b3 = lambda { @x }
+        @thing.class.send(:define_method, :m1, &b2)
+        lambda { @thing.method(:m1).to_source(&matcher) }.should.raise(error)
+      end
+
+      should "raise #{error} w single level nesting on same line" do
+        b1 = lambda {|a| @x }; b2 = lambda { lambda { @x } }
+        @thing.class.send(:define_method, :m2, &b2)
+        lambda { @thing.method(:m2).to_source(&matcher) }.should.raise(error)
+      end
+
+      should "raise #{error} w multi level nesting on same line" do
+        b2 = (lambda {|a| lambda { lambda { @x } } }).call(1)
+        @thing.class.send(:define_method, :m3, &b2)
+        lambda { @thing.method(:m3).to_source(&matcher) }.should.raise(error)
+      end
+
+    end
+
+  end
+end

data/lib/sourcify/spec/method/to_source_from_define_method_w_multi_blocks_and_specified_body_matcher_and_single_match_spec.rb

@@ -0,0 +1,28 @@
+require File.join(File.expand_path(File.dirname(__FILE__)), 'spec_helper')
+
+describe 'Method#to_source (from define_method)' do
+  describe 'w specified body matcher & single match' do
+
+    before { @thing = Object.new }
+    matcher = lambda {|code| code =~ /^(.*\W|)alert\W/ }
+
+    should 'handle no nesting on same line' do
+      b1 = lambda {|a| @x1+1 }; b2 = lambda { @x1+2 }; b3 = lambda { alert(1) }
+      @thing.class.send(:define_method, :m1, &b3)
+      @thing.method(:m1).should.be having_source('def m1; alert(1); end', &matcher)
+    end
+
+    should 'handle single level nesting on same line' do
+      b1 = lambda {|a| @x2+1 }; b2 = lambda { alert(1); lambda { @x2+3 } }
+      @thing.class.send(:define_method, :m2, &b2)
+      @thing.method(:m2).should.be having_source('def m2; alert(1); lambda { @x2+3 }; end', &matcher)
+    end
+
+    should 'handle multi level nesting on same line' do
+      b2 = (lambda {|a| lambda { alert(1); lambda { @x3+3 } } }).call(1)
+      @thing.class.send(:define_method, :m3, &b2)
+      @thing.method(:m3).should.be having_source('def m3; alert(1); lambda { @x3+3 }; end', &matcher)
+    end
+
+  end
+end

data/lib/sourcify/spec/method/to_source_from_define_method_w_multi_blocks_and_specified_ignore_nested_spec.rb

@@ -0,0 +1,36 @@
+require File.join(File.expand_path(File.dirname(__FILE__)), 'spec_helper')
+
+describe 'Method#to_source w specified {:ignore_nested => ...} (for defind_method)' do
+
+  before { @thing = Object.new }
+  options = {:ignore_nested => true}
+
+  if has_parsetree?
+    # TODO: Should we support parsetree ??
+  else
+
+    should "raise Sourcify::MultipleMatchingProcsPerLineError w no nesting on same line" do
+      b1 = lambda {|a| @x1+1 }; b2 = lambda { @x1+2 }; b3 = lambda { @x1+3 }
+      @thing.class.send(:define_method, :m1, &b2)
+      lambda { @thing.method(:m1).to_source(options) }.should.raise(Sourcify::MultipleMatchingProcsPerLineError)
+    end
+
+    should "handle w single level nesting on same line" do
+      b1 = lambda {|a| @x2+1 }; b2 = lambda { lambda { @x2+3 } }
+      @thing.class.send(:define_method, :m2, &b2)
+      @thing.method(:m2).should.be having_source(%(
+        def m2
+          lambda { @x2+3 }
+        end
+      ), options)
+    end
+
+    should "raise Sourcify::NoMatchingProcError w multi level nesting on same line (w outermost having diff arity)" do
+      b2 = (lambda {|a| lambda { lambda { @x3 } } }).call(1)
+      @thing.class.send(:define_method, :m3, &b2)
+      lambda { @thing.method(:m3).to_source(options) }.should.raise(Sourcify::NoMatchingProcError)
+    end
+
+  end
+
+end

data/lib/sourcify/spec/method/to_source_from_define_method_within_irb_spec.rb

@@ -0,0 +1,32 @@
+require File.join(File.expand_path(File.dirname(__FILE__)), 'spec_helper')
+
+describe 'Method#to_source (from define_method)' do
+  describe 'within IRB' do
+
+    class << self
+
+      def irb_eval(string)
+        irb_exec(string)[-1]
+      end
+
+      def equal_to(expected)
+        lambda {|found| normalize_code(found) == normalize_code(expected) }
+      end
+
+    end
+
+    should 'handle' do
+      irb_eval(%\
+        thing = Object.new
+        blk = lambda { x }
+        thing.class.send(:define_method, :m1, &blk)
+        thing.method(:m1).to_source
+      \).should.be equal_to(%(
+        def m1
+          x
+        end
+      ))
+    end
+
+  end
+end