sourcify 0.5.0 → 0.6.0.rc1

data/lib/sourcify/proc/parser/raw_scanner.rl

@@ -0,0 +1,149 @@
+Sourcify.require_rb('proc', 'parser', 'raw_scanner_extensions')
+
+module Sourcify
+  module Proc
+    class Parser
+      module RawScanner #:nodoc:all
+
+%%{
+
+  machine scanner;
+  include common 'common.rl';
+
+
+  ## MACHINE >> New statement
+  new_statement := |*
+
+    (kw_for | kw_while | kw_until) . ^vchar => {
+      push(:kw_do_alias2, ts, te)
+      increment_counter(:do_end, 0..1)
+      fgoto main;
+    };
+
+    (
+      ((kw_class | kw_module | kw_def | kw_begin | kw_case | kw_if | kw_unless) . ^vchar) |
+      (kw_class . ospaces . '<<' . ospaces . ^newline+)
+    ) => {
+      push(:kw_do_alias1, ts, te)
+      increment_counter(:do_end, 1)
+      fgoto main;
+    };
+
+    ospaces => { push(:space, ts, te) };
+    any => { fhold; fgoto main; };
+
+  *|;
+
+
+  ## MACHINE >> Main
+  main := |*
+
+    ## == Start/end of do..end block
+
+    kw_do => {
+      push(:kw_do, ts, te)
+      increment_counter(:do_end)
+      fgoto new_statement;
+    };
+
+    kw_end => {
+      push(:kw_end, ts, te)
+      decrement_counter(:do_end)
+    };
+
+    ## == Start/end of {...} block
+
+    lbrace => {
+      push(:lbrace, ts, te)
+      increment_counter(:brace)
+    };
+
+    rbrace => {
+      push(:rbrace, ts, te)
+      decrement_counter(:brace)
+    };
+
+    assoc => {
+      push(:assoc, ts, te)
+      fix_counter_false_start(:brace)
+    };
+
+    label => {
+      push_label(ts, te)
+      fix_counter_false_start(:brace)
+    };
+
+    ## == New statement
+
+    newline => {
+      push(:newline, ts, te)
+      increment_lineno
+      fgoto new_statement;
+    };
+
+    smcolon | lparen | assgn | kw_then | comma => {
+      push(:newline_alias, ts, te)
+      fgoto new_statement;
+    };
+
+    ## == Comment
+
+    '#' => {
+      fgoto per_line_comment;
+    };
+
+    newline . '=begin' . ospaces . (ospaces . ^newline+)* . newline => {
+      push_comment(ts, te)
+      increment_lineno
+      fgoto block_comment;
+    };
+
+    ## == Strings
+
+    ('<<' | '<<-') . ["']? . (const | var) . ["']? . newline => {
+      push_heredoc(ts, te)
+      increment_lineno
+      fgoto heredoc;
+    };
+
+    ('"' | "'" | '`' | '%') => {
+      fhold; fgoto string;
+    };
+
+    '/' => {
+      if preceded_with?(:char, :digit, :var, :const, :symbol, :dstring, :sstring, ')', ']', '}')
+        push(:op, ts, te)
+      else
+        fhold; fgoto string;
+      end
+    };
+
+    ## == Misc
+
+    var         => { push(:var, ts, te) };
+    bslash      => { push(:bslash, ts, te) };
+    const       => { push(:const, ts, te) };
+    symbol      => { push(:symbol, ts, te) };
+    mspaces     => { push(:space, ts, te) };
+    [0-9]       => { push(:digit, ts, te) };
+    lower       => { push(:char, ts, te) };
+    any         => { push(:any, ts, te) };
+
+  *|;
+
+}%%
+%% write data;
+
+        extend Extensions
+
+        def self.execute!
+          data = @data
+          eof = data.length
+          %% write init;
+          %% write exec;
+        end
+
+      end
+    end
+  end
+end

data/lib/sourcify/proc/parser/raw_scanner_extensions.rb

@@ -0,0 +1,72 @@
+Sourcify.require_rb('common', 'parser', 'raw_scanner', 'extensions')
+
+module Sourcify
+  module Proc
+    class Parser
+      module RawScanner #:nodoc:all
+        module Extensions
+
+          include Common::Parser::RawScanner::Extensions
+          class DoEndBlockCounter < Common::Parser::RawScanner::Counter; end
+          class BraceBlockCounter < Common::Parser::RawScanner::Counter; end
+
+          def fix_counter_false_start(key)
+            return unless this_counter(key).just_started?
+            return unless really_false_started?
+            reset_attributes
+            @tokens, @false_start_backup = @false_start_backup.dup, nil if @false_start_backup
+          end
+
+          def increment_counter(key, count = 1)
+            return if other_counter(key).started?
+            unless (counter = this_counter(key)).started?
+              return if (@rejecting_block = codified_tokens !~ @start_pattern)
+              @false_start_backup = @tokens.dup if key == :brace
+              offset_attributes
+            end
+            counter.increment(count)
+          end
+
+          def decrement_counter(key)
+            return unless (counter = this_counter(key)).started?
+            counter.decrement
+            construct_result_code if counter.balanced?
+          end
+
+          def other_counter(type)
+            {:do_end => @brace_counter, :brace => @do_end_counter}[type]
+          end
+
+          def this_counter(type)
+            {:brace => @brace_counter, :do_end => @do_end_counter}[type]
+          end
+
+          def construct_result_code
+            code = %Q(proc #{codified_tokens}).strip
+
+            begin
+              if valid?(code) && @body_matcher.call(code)
+                @results << code
+                raise Escape if @stop_on_newline or @lineno != 1
+                reset_attributes
+              end
+            rescue Exception
+              raise if $!.is_a?(Escape)
+            end
+          end
+
+          def really_false_started?
+            valid?(%Q(#{codified_tokens} 1}), :hash)
+          end
+
+          def reset_attributes
+            @do_end_counter = DoEndBlockCounter.new
+            @brace_counter = BraceBlockCounter.new
+            super
+          end
+
+        end
+      end
+    end
+  end
+end

data/lib/sourcify/proc/parser/{code_scanner.rb → scanner.rb}

@@ -1,7 +1,9 @@
+Sourcify.require_rb('proc', 'parser', 'raw_scanner')
+
 module Sourcify
   module Proc
     class Parser #:nodoc:all
-      class CodeScanner
+      class Scanner
         class << self
 
           def process(source_code, opts, &matcher)
@@ -28,12 +30,13 @@ module Sourcify
           end
 
           def rscan(str, opts)
-            results = Scanner.process(str, opts) || []
+            results = RawScanner.process(str, opts) || []
             return results if opts[:ignore_nested]
             results.map do |outer|
-              inner = rscan(outer.sub(/^proc\s*(do|\{)/,''), opts.merge(:stop_on_newline => true))
-                [outer, inner]
-              end
+              [
+                outer,
+                rscan(outer.sub(/^proc\s*(do|\{)/,''), opts.merge(:stop_on_newline => true))
+              ]
             end
           end
 
@@ -41,3 +44,4 @@ module Sourcify
       end
     end
   end
+end

data/lib/sourcify/proc/parser/source_code.rb

@@ -1,33 +1,8 @@
 module Sourcify
   module Proc
     class Parser #:nodoc:all
-      class SourceCode < Struct.new(:file, :line)
-
-        def line
-          super.pred
-        end
-
-        def to_s
-          case file
-          when /\(irb\)/ then from_irb_to_s
-          else from_file_to_s
-          end
-        end
-
-        def from_file_to_s
-          File.open(file, 'r') do |fh|
-            fh.extend(File::Tail).forward(line)
-            fh.readlines.join
-          end
-        end
-
-        def from_irb_to_s
-          # Really owe it to Florian Groß's solution @ http://rubyquiz.com/quiz38.html ...
-          # anyway, note that we use *line.succ* instead of *line* here.
-          IRB.CurrentContext.io.line(line.succ .. -1).join
-        end
-
-      end
+      Sourcify.require_rb('common', 'parser', 'source_code')
+      SourceCode = Common::Parser::SourceCode
     end
   end
 end

data/lib/sourcify/version.rb

@@ -1,3 +1,3 @@
 module Sourcify
-  VERSION = "0.5.0"
+  VERSION = "0.6.0.rc1"
 end

data/spec/method/others_from_def_end_block_spec.rb

@@ -0,0 +1,49 @@
+require File.join(File.expand_path(File.dirname(__FILE__)), 'spec_helper')
+
+describe "Misc (from def..end block)" do
+
+  should 'handle accessing #to_sexp after #to_source' do
+    def m1; x; end
+    (m = method(:m1)).to_source
+    m.should.be having_sexp(
+      s(:defn, :m1, s(:args), s(:scope, s(:block, s(:call, nil, :x, s(:arglist)))))
+    )
+  end
+
+  should 'handle accessing #to_source after #to_sexp' do
+    def m2; x; end
+    (m = method(:m2)).to_sexp
+    m.should.be having_source(%(
+      def m2; x; end
+    ))
+  end
+
+  should "handle body with '/' char" do
+    def m3; x/2; end
+    method(:m3).should.be having_source(%(
+      def m3; x/2; end
+    ))
+  end
+
+  should "handle lexer bug in missing trailing chars after '=>' operator" do
+    # This example addresses bug @ http://redmine.ruby-lang.org/issues/show/3765
+    {
+      __LINE__ => (def m4; x; end; method(:m4))
+    }.values.last.should.be having_source(%(
+      def m4; x; end
+    ))
+  end
+
+  should 'raise Sourcify::CannotFindSourceLocationError when Method#source_location is nil' do
+    lambda { 1.method(:to_s).to_source }.should.
+      raise(Sourcify::CannotFindSourceLocationError)
+  end
+
+  unless has_parsetree?
+    should "raise Sourcify::CannotParseEvalCodeError when method is created from eval" do
+      lambda { eval("def m5; x; end; method(:m5)").to_source }.should.
+        raise(Sourcify::CannotParseEvalCodeError)
+    end
+  end
+
+end

data/spec/method/others_from_define_method_spec.rb

@@ -0,0 +1,62 @@
+require File.join(File.expand_path(File.dirname(__FILE__)), 'spec_helper')
+
+describe "Misc (from define_method)" do
+
+  before { @thing = Object.new }
+
+  should 'handle accessing #to_sexp after #to_source' do
+    blk = lambda { x }
+    @thing.class.send(:define_method, :m1, &blk)
+    (m = @thing.method(:m1)).to_source
+    m.should.be having_sexp(
+      s(:defn, :m1, s(:args), s(:scope, s(:block, s(:call, nil, :x, s(:arglist)))))
+    )
+  end
+
+  should 'handle accessing #to_source after #to_sexp' do
+    blk = lambda { x }
+    @thing.class.send(:define_method, :m2, &blk)
+    (m = @thing.method(:m2)).to_sexp
+    m.should.be having_source(%(
+      def m2; x; end
+    ))
+  end
+
+  should "handle body with '/' char" do
+    blk = lambda { x / 2 }
+    @thing.class.send(:define_method, :m3, &blk)
+    @thing.method(:m3).should.be having_source(%(
+      def m3; x / 2; end
+    ))
+  end
+
+  should "handle lexer bug in missing trailing chars after '=>' operator" do
+    # This example addresses bug @ http://redmine.ruby-lang.org/issues/show/3765
+    hash = {
+      :x => lambda { x }
+    }
+    @thing.class.send(:define_method, :m4, &(hash[:x]))
+    @thing.method(:m4).should.be having_source(%(
+      def m4; x; end
+    ))
+  end
+
+  should "handle lexer bug in missing trailing chars after '=>' operator" do
+    # This example addresses bug @ http://redmine.ruby-lang.org/issues/show/3765
+    hash = {
+      :blk => lambda do x end
+    }
+    @thing.class.send(:define_method, :m5, &(hash[:blk]))
+    @thing.method(:m5).should.be having_source(%(
+      def m5; x; end
+    ))
+  end
+
+  unless has_parsetree?
+    should "raise Sourcify::CannotParseEvalCodeError when method is created from eval" do
+      lambda { eval("klass = Class.new { define_method(:m6){ x }; }; klass.new.method(:m6)").to_source }.
+        should.raise(Sourcify::CannotParseEvalCodeError)
+    end
+  end
+
+end

data/spec/method/raw_scanner/block_comment_spec.rb

@@ -0,0 +1,8 @@
+require File.expand_path('../spec_helper', __FILE__)
+
+unless has_parsetree?
+  describe "Method's raw scanner > block comment (=begin ... =end)" do
+    extend Sourcify::Method::Parser::RawScanner::Spec::GenericSupport
+    behaves_like "Block comment (=begin ... =end)"
+  end
+end

data/spec/method/raw_scanner/double_colons_spec.rb

@@ -0,0 +1,8 @@
+require File.expand_path('../spec_helper', __FILE__)
+
+unless has_parsetree?
+  describe "Method's raw scanner > double colons" do
+    extend Sourcify::Method::Parser::RawScanner::Spec::GenericSupport
+    behaves_like "Double colons"
+  end
+end

data/spec/method/raw_scanner/double_quote_str_w_interpolation_spec.rb

@@ -0,0 +1,8 @@
+require File.expand_path('../spec_helper', __FILE__)
+
+unless has_parsetree?
+  describe "Method's raw scanner > double quote strings (w interpolation)" do
+    extend Sourcify::Method::Parser::RawScanner::Spec::GenericSupport
+    behaves_like "Double quote strings (w interpolation)"
+  end
+end

data/spec/method/raw_scanner/double_quote_str_wo_interpolation_spec.rb

@@ -0,0 +1,8 @@
+require File.expand_path('../spec_helper', __FILE__)
+
+unless has_parsetree?
+  describe "Method's raw scanner > double quote strings (wo interpolation)" do
+    extend Sourcify::Method::Parser::RawScanner::Spec::GenericSupport
+    behaves_like "Double quote strings (wo interpolation)"
+  end
+end