sourcify 0.1.2 → 0.2.0

data/spec/proc/to_source_from_do_end_block_w_nested_literal_keyword_spec.rb

@@ -2,6 +2,8 @@ require File.join(File.dirname(__FILE__), '..', 'spec_helper')
 
 describe "Proc#to_source from do ... end block (w nested literal keyword)" do
 
+  # See http://redmine.ruby-lang.org/issues/show/3764
+
   should 'handle :class' do
     (
       lambda do

data/spec/proc/to_source_from_multi_blocks_w_many_matches_spec.rb

@@ -32,40 +32,116 @@ describe 'Proc#to_source from multi blocks w many matches' do
 
   else
 
-    # Need this line since the parser file is dynamically required, otherwise we will get
-    # undefined constant error
-    require 'sourcify/proc/parser'
-
-    should 'raise Sourcify::MultipleMatchingProcsPerLineError (all do...end blocks)' do
-      lambda {
-        (
-          b1 = lambda do |a| @x1 end; b2 = lambda do @x1 end; b3 = lambda do @x1 end ; b2
-        ).to_source
-      }.should.raise(Sourcify::MultipleMatchingProcsPerLineError)
-    end
+    describe 'wo nesting on same line' do
+
+      should 'raise Sourcify::MultipleMatchingProcsPerLineError (all do...end blocks)' do
+        lambda {
+          (
+            b1 = lambda do |a| @x1 end; b2 = lambda do @x1 end; b3 = lambda do @x1 end ; b2
+          ).to_source
+        }.should.raise(Sourcify::MultipleMatchingProcsPerLineError)
+      end
+
+      should 'raise Sourcify::MultipleMatchingProcsPerLineError (all {...} blocks)' do
+        lambda {
+          (
+            b1 = lambda {|a| @x2 }; b2 = lambda { @x2 }; b3 = lambda { @x2 } ; b2
+          ).to_source
+        }.should.raise(Sourcify::MultipleMatchingProcsPerLineError)
+      end
+
+      should 'raise Sourcify::MultipleMatchingProcsPerLineError (mixed {...} w do...end blocks)' do
+        lambda {
+          (
+            b1 = lambda {|a| @x3 }; b2 = lambda do @x3 end; b3 = lambda { @x4 } ; b2
+          ).to_source
+        }.should.raise(Sourcify::MultipleMatchingProcsPerLineError)
+      end
+
+      should 'raise Sourcify::MultipleMatchingProcsPerLineError (mixed do...end w {...} blocks)' do
+        lambda {
+          (
+            b1 = lambda do |a| @x4 end; b2 = lambda { @x4 }; b3 = lambda do @x4 end ; b2
+          ).to_source
+        }.should.raise(Sourcify::MultipleMatchingProcsPerLineError)
+      end
 
-    should 'raise Sourcify::MultipleMatchingProcsPerLineError (all {...} blocks)' do
-      lambda {
-        (
-          b1 = lambda {|a| @x2 }; b2 = lambda { @x2 }; b3 = lambda { @x2 } ; b2
-        ).to_source
-      }.should.raise(Sourcify::MultipleMatchingProcsPerLineError)
     end
 
-    should 'raise Sourcify::MultipleMatchingProcsPerLineError (mixed {...} w do...end blocks)' do
-      lambda {
-        (
-          b1 = lambda {|a| @x3 }; b2 = lambda do @x3 end; b3 = lambda { @x4 } ; b2
-        ).to_source
-      }.should.raise(Sourcify::MultipleMatchingProcsPerLineError)
+    describe 'w single level nesting on same line' do
+
+      should 'raise Sourcify::MultipleMatchingProcsPerLineError (all do...end blocks)' do
+        lambda {
+          (
+            b1 = lambda do |a| @x1 end; b2 = lambda do lambda do @x1 end end; b2
+          ).to_source
+        }.should.raise(Sourcify::MultipleMatchingProcsPerLineError)
+      end
+
+      should 'raise Sourcify::MultipleMatchingProcsPerLineError (all {...} blocks)' do
+        lambda {
+          (
+            b1 = lambda {|a| @x2 }; b2 = lambda { lambda { @x2 } }; b2
+          ).to_source
+        }.should.raise(Sourcify::MultipleMatchingProcsPerLineError)
+      end
+
+      should 'raise Sourcify::MultipleMatchingProcsPerLineError (mixed {...} w do...end blocks)' do
+        lambda {
+          (
+            b1 = lambda {|a| @x3 }; b2 = lambda do lambda { @x4 } end; b2
+          ).to_source
+        }.should.raise(Sourcify::MultipleMatchingProcsPerLineError)
+      end
+
+      should 'raise Sourcify::MultipleMatchingProcsPerLineError (mixed do...end w {...} blocks)' do
+        lambda {
+          (
+            b1 = lambda do |a| @x4 end; b2 = lambda { lambda do @x4 end }; b2
+          ).to_source
+        }.should.raise(Sourcify::MultipleMatchingProcsPerLineError)
+      end
+
     end
 
-    should 'raise Sourcify::MultipleMatchingProcsPerLineError (mixed do...end w {...} blocks)' do
-      lambda {
-        (
-          b1 = lambda do |a| @x4 end; b2 = lambda { @x4 }; b3 = lambda do @x4 end ; b2
-        ).to_source
-      }.should.raise(Sourcify::MultipleMatchingProcsPerLineError)
+    describe 'w multi level nesting on same line' do
+
+      should 'raise Sourcify::MultipleMatchingProcsPerLineError (all do...end blocks)' do
+        lambda {
+          (
+            b1 = lambda do |a| lambda do lambda do @x1 end end end
+            b2 = b1.call(1)
+          ).to_source
+        }.should.raise(Sourcify::MultipleMatchingProcsPerLineError)
+      end
+
+      should 'raise Sourcify::MultipleMatchingProcsPerLineError (all {...} blocks)' do
+        lambda {
+          (
+            b1 = lambda {|a| lambda { lambda { @x2 } } }
+            b2 = b1.call(1)
+          ).to_source
+        }.should.raise(Sourcify::MultipleMatchingProcsPerLineError)
+      end
+
+      should 'raise Sourcify::MultipleMatchingProcsPerLineError (mixed {...} w do...end blocks)' do
+        lambda {
+          (
+            b1 = lambda {|a| lambda do lambda { @x4 } end }
+            b2 = b1.call(1)
+          ).to_source
+        }.should.raise(Sourcify::MultipleMatchingProcsPerLineError)
+      end
+
+      should 'raise Sourcify::MultipleMatchingProcsPerLineError (mixed do...end w {...} blocks)' do
+        lambda {
+          (
+            b1 = lambda do |a| lambda { lambda do @x4 end } end
+            b2 = b1.call(1)
+          ).to_source
+        }.should.raise(Sourcify::MultipleMatchingProcsPerLineError)
+      end
+
     end
 
   end

data/spec/proc/to_source_from_multi_blocks_w_single_match_spec.rb

@@ -4,28 +4,96 @@ describe 'Proc#to_source from multi blocks w single match' do
 
   expected = 'proc { @x%s }'
 
-  should 'skip non-matching (all do...end blocks)' do
-    (
-      b1 = lambda do |a| @x1 end; b2 = lambda do @x1 end; b2
-    ).should.be having_source(expected%1)
-  end
+  describe 'wo nesting on same line' do
+
+    should 'skip non-matching (all do...end blocks)' do
+      (
+        b1 = lambda do |a| @x1 end; b2 = lambda do @x1 end; b2
+      ).should.be having_source(expected%1)
+    end
+
+    should 'skip non-matching (all {...} blocks)' do
+      (
+        b1 = lambda {|a| @x2 }; b2 = lambda { @x2 }; b2
+      ).should.be having_source(expected%2)
+    end
+
+    should 'skip non-matching (mixed {...} with do...end blocks)' do
+      (
+        b1 = lambda {|a| @x3 }; b2 = lambda do @x3 end; b2
+      ).should.be having_source(expected%3)
+    end
+
+    should 'skip non-matching (mixed do...end with {...} blocks)' do
+      (
+        b1 = lambda do |a| @x4 end; b2 = lambda { @x4 }; b2
+      ).should.be having_source(expected%4)
+    end
 
-  should 'skip non-matching (all {...} blocks)' do
-    (
-      b1 = lambda {|a| @x2 }; b2 = lambda { @x2 }; b2
-    ).should.be having_source(expected%2)
   end
 
-  should 'skip non-matching (mixed {...} with do...end blocks)' do
-    (
-      b1 = lambda {|a| @x3 }; b2 = lambda do @x3 end; b2
-    ).should.be having_source(expected%3)
+  describe 'w single level nesting on same line' do
+
+    should 'skip non-matching (all do...end blocks)' do
+      (
+        b1 = lambda do |a| lambda do @x1 end end
+        b2 = b1.call(1) # returns the inner proc
+      ).should.be having_source(expected%1)
+    end
+
+    should 'skip non-matching (all {...} blocks)' do
+      (
+        b1 = lambda {|a| lambda { @x2 } }
+        b2 = b1.call(1) # returns the inner proc
+      ).should.be having_source(expected%2)
+    end
+
+    should 'skip non-matching (mixed {...} with do...end blocks)' do
+      (
+        b1 = lambda {|a| lambda do @x3 end }
+        b2 = b1.call(1) # returns the inner proc
+      ).should.be having_source(expected%3)
+    end
+
+    should 'skip non-matching (mixed do...end with {...} blocks)' do
+      (
+        b1 = lambda do |a| lambda { @x4 } end
+        b2 = b1.call(1) # returns the inner proc
+      ).should.be having_source(expected%4)
+    end
+
   end
 
-  should 'skip non-matching (mixed do...end with {...} blocks)' do
-    (
-      b1 = lambda do |a| @x4 end; b2 = lambda { @x4 }; b2
-    ).should.be having_source(expected%4)
+  describe 'w multi level nesting on same line' do
+
+    should 'skip non-matching (all do...end blocks)' do
+      (
+        b1 = lambda do |a| lambda do |a| b2 = lambda do @x1 end end end
+        b2 = b1.call(1).call(1) # returns the inner-most proc
+      ).should.be having_source(expected%1)
+    end
+
+    should 'skip non-matching (all {...} blocks)' do
+      (
+        b1 = lambda {|a| lambda {|a| b2 = lambda { @x2 } } }
+        b2 = b1.call(1).call(1) # returns the inner-most proc
+      ).should.be having_source(expected%2)
+    end
+
+    should 'skip non-matching (mixed {...} with do...end blocks)' do
+      (
+        b1 = lambda {|a| lambda do |a| b2 = lambda do @x3 end end }
+        b2 = b1.call(1).call(1) # returns the inner-most proc
+      ).should.be having_source(expected%3)
+    end
+
+    should 'skip non-matching (mixed do...end with {...} blocks)' do
+      (
+        b1 = lambda do |a| lambda do |a| lambda { @x4 } end end
+        b2 = b1.call(1).call(1) # returns the inner-most proc
+      ).should.be having_source(expected%4)
+    end
+
   end
 
 end

data/spec/proc_scanner/block_comment_spec.rb

@@ -0,0 +1,59 @@
+require File.join(File.dirname(__FILE__), 'spec_helper')
+
+describe "Block comment (=begin ... =end)" do
+
+  should 'handle =begin\n ... =end\n' do
+    process(<<EOL
+aa
+=begin
+ bb 
+=end
+cc
+EOL
+           ).should.include([:comment, "\n=begin\n bb \n=end"])
+  end
+
+  should 'handle =begin \n ... =end\n' do
+    process(<<EOL
+aa
+=begin 
+ bb 
+=end
+cc
+EOL
+           ).should.include([:comment, "\n=begin \n bb \n=end"])
+  end
+
+  should 'handle =begin aa \n ... =end\n' do
+    process(<<EOL
+
+=begin aa 
+ bb 
+=end
+cc
+EOL
+           ).should.include([:comment, "\n=begin aa \n bb \n=end"])
+  end
+
+  should 'handle =begin\n ... =end \n' do
+    process(<<EOL
+aa
+=begin
+ bb 
+=end 
+cc
+EOL
+           ).should.include([:comment, "\n=begin\n bb \n=end "])
+  end
+
+  should 'not handle =begin\n ... =end ... \n' do
+    process(<<EOL
+aa
+=begin
+ bb 
+=end cc
+EOL
+           ).should.not.include([:comment, "\n=begin\n bb \n=end cc"])
+  end
+
+end

data/spec/proc_scanner/double_colons_spec.rb

@@ -0,0 +1,14 @@
+require File.join(File.dirname(__FILE__), 'spec_helper')
+
+describe "Double colons" do
+
+  should "handle A::B as :const" do
+    process(" A::B ").should.include([:const, 'A::B'])
+  end
+
+  should "handle A::aa as :const" do
+    process(" A::aa ").should.include([:const, 'A::aa'])
+  end
+
+end
+

data/spec/proc_scanner/double_quote_str_w_interpolation_spec.rb

@@ -0,0 +1,62 @@
+require File.join(File.dirname(__FILE__), 'spec_helper')
+
+describe 'Double quote strings (w interpolation)' do
+
+  # NOTE: we skip %Q#...# cos %Q#..#{..}..# is invalid syntax.
+  %w{~ ` ! @ $ % ^ & * _ - + = | ; : ' " , . ? / \\}.map{|w| [w,w] }.concat(
+    [%w{( )}, %w{[ ]}, %w({ }), %w{< >}]
+  ).each do |q1,q2|
+    ['Q', 'W', 'x', 'r', ''].each do |t|
+
+      should "handle %#{t}#{q1}...#{q2} (wo nesting (single))" do
+        process(" xx %#{t}#{q1}h\#{%#{t}#{q1}ell#{q2}}o#{q2} ").
+          should.include([:dstring, "%#{t}#{q1}h\#{%#{t}#{q1}ell#{q2}}o#{q2}"])
+      end
+
+      should "handle %#{t}#{q1}...#{q2} (wo nesting (multiple))" do
+        tokens = process(" xx  %#{t}#{q1}h\#{%#{t}#{q1}ell#{q2}}o#{q2} %#{t}#{q1}w\#{%#{t}#{q1}orl#{q2}}d#{q2}  ")
+        tokens.should.include([:dstring, "%#{t}#{q1}h\#{%#{t}#{q1}ell#{q2}}o#{q2}"])
+        tokens.should.include([:dstring, "%#{t}#{q1}w\#{%#{t}#{q1}orl#{q2}}d#{q2}"])
+      end
+
+      should "handle %#{t}#{q1}...#{q2} (w nesting (single))" do
+        process(" xx %#{t}#{q1}h\#{%#{t}#{q1}e\#{%#{t}#{q1}l#{q2}}l#{q2}}o#{q2} ").
+          should.include([:dstring, "%#{t}#{q1}h\#{%#{t}#{q1}e\#{%#{t}#{q1}l#{q2}}l#{q2}}o#{q2}"])
+      end
+
+      should "handle %#{t}#{q1}...#{q2} (w nesting (multiple))" do
+        tokens = process(" xx " +
+          "%#{t}#{q1}h\#{%#{t}#{q1}e\#{%#{t}#{q1}l#{q2}}l#{q2}}o#{q2} " +
+          "%#{t}#{q1}w\#{%#{t}#{q1}o\#{%#{t}#{q1}r#{q2}}l#{q2}}d#{q2} "
+        )
+        tokens.should.include([:dstring, "%#{t}#{q1}h\#{%#{t}#{q1}e\#{%#{t}#{q1}l#{q2}}l#{q2}}o#{q2}"])
+        tokens.should.include([:dstring, "%#{t}#{q1}w\#{%#{t}#{q1}o\#{%#{t}#{q1}r#{q2}}l#{q2}}d#{q2}"])
+      end
+
+    end
+  end
+
+  %w{" / `}.each do |q|
+
+    should "handle #{q}...#{q} (wo escape (single))" do
+      process(%Q( xx #{q}hello#{q} )).should.include([:dstring, %Q(#{q}hello#{q})])
+    end
+
+    should "handle #{q}...#{q} (wo escape & multiple)" do
+      tokens = process(%Q( xx #{q}hello#{q} #{q}world#{q} ))
+      tokens.should.include([:dstring, %Q(#{q}hello#{q})])
+      tokens.should.include([:dstring, %Q(#{q}world#{q})])
+    end
+
+    should "handle #{q}...#{q} (w escape (single))" do
+      process(%Q( xx #{q}hel\\#{q}lo#{q} )).should.
+        include([:dstring, %Q(#{q}hel\\#{q}lo#{q})])
+    end
+
+    should "handle #{q}...#{q} (w escape (multiple))" do
+      process(%Q( xx #{q}h\\#{q}el\\#{q}lo#{q} )).should.include([:dstring, %Q(#{q}h\\#{q}el\\#{q}lo#{q})])
+    end
+
+  end
+
+end

data/spec/proc_scanner/double_quote_str_wo_interpolation_spec.rb

@@ -0,0 +1,75 @@
+require File.join(File.dirname(__FILE__), 'spec_helper')
+
+describe 'Double quote strings (wo interpolation)' do
+
+  %w{~ ` ! @ # $ % ^ & * _ - + = | \\ ; : ' " , . ? /}.map{|w| [w,w] }.concat(
+    [%w{( )}, %w{[ ]}, %w({ }), %w{< >}]
+  ).each do |q1,q2|
+    ['Q', 'W', 'x', 'r', ''].each do |t|
+
+      should "handle %#{t}#{q1}...#{q2} (wo escape (single))" do
+        process(" xx %#{t}#{q1}hello#{q2} ").should.include([:dstring, "%#{t}#{q1}hello#{q2}"])
+      end
+
+      should "handle %#{t}#{q1}...#{q2} (wo escape (multiple))" do
+        tokens = process(" xx  %#{t}#{q1}hello#{q2} %#{t}#{q1}world#{q2}  ")
+        tokens.should.include([:dstring, "%#{t}#{q1}hello#{q2}"])
+        tokens.should.include([:dstring, "%#{t}#{q1}world#{q2}"])
+      end
+
+      # NOTE: We are skipping '\\' cos %Q\hel\\o\ is always raise SyntaxError no matter
+      # how many backslashes we add
+      unless q1 == '\\'
+
+        should "handle %#{t}#{q1}...#{q2} (w escape (single))" do
+          process(" xx %#{t}#{q1}hel\\#{q2}lo#{q2} ").should.
+            include([:dstring, "%#{t}#{q1}hel\\#{q2}lo#{q2}"])
+        end
+
+        should "handle %#{t}#{q1}...#{q2} (w escape (multiple))" do
+          process(" xx %#{t}#{q1}h\\#{q2}el\\#{q2}lo#{q2} ").should.
+            include([:dstring, "%#{t}#{q1}h\\#{q2}el\\#{q2}lo#{q2}"])
+        end
+
+        should "handle %#{t}#{q1}\\\\#{q2}" do
+          process(" xx %#{t}#{q1}\\\\#{q2} %#{t}#{q2}lo#{q2} ").should.
+            include([:dstring, "%#{t}#{q1}\\\\#{q2}"])
+        end
+
+      end
+
+    end
+  end
+
+  %w{" / `}.each do |q|
+
+    should "handle #{q}...#{q} (wo escape (single))" do
+      process(%Q( xx #{q}hello#{q} )).should.include([:dstring, %Q(#{q}hello#{q})])
+    end
+
+    should "handle #{q}...#{q} (wo escape & multiple)" do
+      tokens = process(%Q( xx #{q}hello#{q} #{q}world#{q} ))
+      tokens.should.include([:dstring, %Q(#{q}hello#{q})])
+      tokens.should.include([:dstring, %Q(#{q}world#{q})])
+    end
+
+    should "handle #{q}...#{q} (w escape (single))" do
+      process(%Q( xx #{q}hel\\#{q}lo#{q} )).should.include([:dstring, %Q(#{q}hel\\#{q}lo#{q})])
+    end
+
+    should "handle #{q}...#{q} (w escape (multiple))" do
+      process(%Q( xx #{q}h\\#{q}el\\#{q}lo#{q} )).should.
+        include([:dstring, %Q(#{q}h\\#{q}el\\#{q}lo#{q})])
+    end
+
+    should "handle #{q}\\\\#{q}" do
+      process(%Q(
+        aa #{q}\\\\#{q} 
+        cc
+        #{q}dd#{q}
+      )).should.include([:dstring, "#{q}\\\\#{q}"])
+    end
+
+  end
+
+end