ikra 0.0.1

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

@@ -0,0 +1,127 @@
+require File.join(File.expand_path(File.dirname(__FILE__)), 'spec_helper')
+
+describe "Proc#to_source (magic var __LINE__)" do
+
+  should 'handle single standalone' do
+    lambda { __LINE__ }.should.be having_source(%(proc { #{__LINE__} }))
+  end
+
+  should 'handle multiple standalones' do
+    lambda {
+      [
+        __LINE__, __LINE__,
+        __LINE__
+      ]
+    }.should.be having_source(%Q(
+      proc do
+        [
+          #{__LINE__ - 6}, #{__LINE__ - 6},
+          #{__LINE__ - 6}
+        ]
+      end
+    ))
+  end
+
+  should 'handle single interpolation' do
+    lambda { "#{__LINE__}" }.should.be having_source(%(proc { "\#{#{__LINE__}}" }))
+  end
+
+  should 'handle multiple interpolation (separate)' do
+    lambda {
+      [
+        "#{__LINE__}", "#{__LINE__}",
+        "#{__LINE__}"
+      ]
+    }.should.be having_source(%Q(
+      proc do
+        [
+          "\#{#{__LINE__ - 6}}", "\#{#{__LINE__ - 6}}",
+          "\#{#{__LINE__ - 6}}"
+        ]
+      end
+    ))
+  end
+
+  should 'handle multiple interpolation (together)' do
+    lambda {
+      <<EOL
+#{__LINE__}, #{__LINE__},
+#{__LINE__}
+EOL
+    }.should.be having_source(%Q(
+      proc do
+        <<EOL
+\#{#{__LINE__ - 6}}, \#{#{__LINE__ - 6}},
+\#{#{__LINE__ - 6}}
+EOL
+      end
+    ))
+  end
+
+  should 'handle interpolation in (") quoted string' do
+    lambda { "#{__LINE__}" }.should.be having_source(%Q(proc { "\#{#{__LINE__}}" }))
+  end
+
+  should 'handle interpolation in (%) quoted string' do
+    lambda { %(#{__LINE__}) }.should.be having_source(%Q(proc { "\#{#{__LINE__}}" }))
+  end
+
+  should 'handle interpolation in (%Q) quoted string' do
+    lambda { %Q(#{__LINE__}) }.should.be having_source(%Q(proc { "\#{#{__LINE__}}" }))
+  end
+
+  should 'handle interpolation in heredoc string' do
+    lambda {
+      <<-EOL
+#{__LINE__}
+EOL
+    }.should.be having_source(%Q(
+      proc do
+        <<-EOL
+\#{#{__LINE__ - 5}}
+EOL
+      end
+    ))
+  end
+
+  should 'handle interpolation in (%r) regexp' do
+    lambda { %r(#{__LINE__}) }.should.be having_source(%Q(proc { %r(\#{#{__LINE__}}) }))
+  end
+
+  should 'handle interpolation in (/) regexp' do
+    lambda { /#{__LINE__}/ }.should.be having_source(%Q(proc { %r(\#{#{__LINE__}}) }))
+  end
+
+  should 'handle interpolation in (%x) command' do
+    lambda { %x(echo #{__LINE__}) }.should.be having_source(%Q(proc { %x(echo \#{#{__LINE__}}) }))
+  end
+
+  should 'handle interpolation in (`) command' do
+    lambda { `echo #{__LINE__}` }.should.be having_source(%Q(proc { `echo \#{#{__LINE__}}` }))
+  end
+
+  should 'handle interpolation in (%W) array' do
+    lambda { %W(#{__LINE__}) }.should.be having_source(%Q(proc { %W(\#{#{__LINE__}}) }))
+  end
+
+  should 'not handle interpolation in (\') quoted string' do
+    lambda { '#{__LINE__}' }.should.be having_source(%Q(proc { '\#{__LINE__}' }))
+  end
+
+  should 'not handle interpolation in (%q) quoted string' do
+    lambda { %q(#{__LINE__}) }.should.be having_source(%Q(proc { '\#{__LINE__}' }))
+  end
+
+  should 'not handle interpolation in (%w) array' do
+    lambda { %w(#{__LINE__}) }.should.be having_source(%Q(proc { %w{\#{__LINE__}} }))
+  end
+
+  should 'not handle escaped-interpolation' do
+    lambda { "\#{__LINE__}" }.should.be having_source('proc { "\#{__LINE__}" }')
+  end
+
+  should 'not handle non-interpolated' do
+    lambda { "__LINE__" }.should.be having_source(%(proc { "__LINE__" }))
+  end
+
+end

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

@@ -0,0 +1,29 @@
+require File.join(File.expand_path(File.dirname(__FILE__)), 'spec_helper')
+
+describe "Proc#to_source (variables)" do
+
+  should 'handle non var' do
+    lambda { x }.should.be having_source(%|proc { x }|)
+  end
+
+  should 'handle local var' do
+    x = 'lx'
+    lambda { x }.should.be having_source(%|proc { x }|)
+  end
+
+  should 'handle instance var' do
+    @x = 'ix'
+    lambda { @x }.should.be having_source(%|proc { @x }|)
+  end
+
+  should 'handle class var' do
+    @@x = 'cx'
+    lambda { @@x }.should.be having_source(%|proc { @@x }|)
+  end
+
+  should 'handle global var' do
+    $x = 'gx'
+    lambda { $x }.should.be having_source(%|proc { $x }|)
+  end
+
+end

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

@@ -0,0 +1,33 @@
+require File.join(File.expand_path(File.dirname(__FILE__)), 'spec_helper')
+
+describe 'Proc#to_source 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_source('a+b', options)
+    end
+
+    should 'strip enclosing proc w arg' do
+      lambda {|a| a+b }.should.be having_source('a+b', 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_source('proc { a+b }', options)
+    end
+
+    should 'not strip enclosing proc w arg' do
+      lambda {|a| a+b }.should.be having_source('proc {|a| a+b }', options)
+    end
+
+  end
+
+end

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

@@ -0,0 +1,38 @@
+require File.join(File.expand_path(File.dirname(__FILE__)), 'spec_helper')
+
+describe "Proc#to_source 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 basic' do
+    irb_eval(%Q(
+      x = lambda { 1+2 }
+      y = lambda { 2+3 }
+      z = lambda { 3+4 }
+      y.to_source
+    )).should.be equal_to('proc { 2+3 }')
+  end
+
+  should 'handle magic variable __FILE__' do
+    irb_eval(%Q(
+      lambda { __FILE__ }.to_source
+    )).should.be equal_to('proc { "(irb)" }')
+  end
+
+  should 'handle magic variable __LINE__' do
+    irb_eval(%Q(
+      lambda { __LINE__ }.to_source
+    )).should.be equal_to('proc { 2 }')
+  end
+
+end

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

@@ -0,0 +1,61 @@
+require File.join(File.expand_path(File.dirname(__FILE__)), 'spec_helper')
+
+describe "Proc#to_source within PRY" do
+
+  class << self
+
+    def pry_eval(string)
+      pry_exec(string)[-1]
+    end
+
+    def equal_to(expected)
+      lambda {|found| normalize_code(found) == normalize_code(expected) }
+    end
+
+  end
+
+  should 'handle basic' do
+    pry_eval(%Q(
+      x = lambda { 1+2 }
+      y = lambda { 2+3 }
+      z = lambda { 3+4 }
+      y.to_source
+    )).should.be equal_to('proc { 2+3 }')
+  end
+
+  should 'handle magic variable __FILE__' do
+    pry_eval(%Q(
+      # NOTE: this line is needed to fix one-liner issue w pry
+      lambda { __FILE__ }.to_source
+    )).should.be equal_to('proc { "(pry)" }')
+  end
+
+  should 'handle magic variable __LINE__' do
+    pry_eval(%Q(
+      # NOTE: this line is needed to fix one-liner issue w pry
+      lambda { __LINE__ }.to_source
+    )).should.be equal_to('proc { 2 }')
+  end
+
+
+  # NOTE: The rest address issue#22, kudos goes to @scooter-dangle
+  # for providing such detailed examples :)
+  should 'handle a single upward scroll' do
+   pry_eval(%Q(
+     a = lambda { |proc| proc.to_source }
+     a[(lambda { 0 })]
+     a[(lambda { 1 })]
+     
+   )).should.be equal_to('proc { 1 }')
+  end
+  
+  should 'handle a double upward scroll' do
+   pry_eval(%Q(
+     a = lambda { |proc| proc.to_source }
+     a[(lambda { 0 })]
+     a[(lambda { 1 })]
+     
+   )).should.be equal_to('proc { 0 }')
+  end
+
+end

data/lib/sourcify/spec/raw_scanner/block_comment_shared_spec.rb

@@ -0,0 +1,57 @@
+shared "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/lib/sourcify/spec/raw_scanner/double_colons_shared_spec.rb

@@ -0,0 +1,11 @@
+shared "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/lib/sourcify/spec/raw_scanner/double_quote_str_w_interpolation_shared_spec.rb

@@ -0,0 +1,60 @@
+shared '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/lib/sourcify/spec/raw_scanner/double_quote_str_wo_interpolation_shared_spec.rb

@@ -0,0 +1,86 @@
+shared '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
+
+        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
+
+    should "handle #{q}#{q}" do
+      process(%Q(
+        aa; #{q}#{q} 
+        cc
+        #{q}dd#{q}
+      )).should.include([:dstring, "#{q}#{q}"])
+    end
+
+  end
+
+end