ikra 0.0.1

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

@@ -0,0 +1,144 @@
+Sourcify.require_rb('method', 'parser', 'raw_scanner_extensions')
+
+module Sourcify
+  module Method
+    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(0..1)
+      fgoto main;
+    };
+
+    (
+      ((kw_class | kw_module | kw_do | kw_begin | kw_case | kw_if | kw_unless) . ^vchar) |
+      (kw_class . ospaces . '<<' . ospaces . ^(newline | smcolon)+)
+    ) => {
+      push(:kw_do_alias1, ts, te)
+      increment_counter(1)
+      fgoto main;
+    };
+
+    ospaces => { push(:space, ts, te) };
+    any => { fhold; fgoto main; };
+
+  *|;
+
+
+  ## MACHINE >> Main
+  main := |*
+
+    ## == Start/end of def..end block
+
+    kw_def => {
+      push(:kw_def, ts, te)
+      increment_counter(1)
+      fgoto new_statement;
+    };
+
+    kw_end => {
+      push(:kw_end, ts, te)
+      decrement_counter()
+    };
+
+    ## == Start/end of {...} block
+
+    lbrace => {
+      push(:lbrace, ts, te)
+    };
+
+    rbrace => {
+      push(:rbrace, ts, te)
+    };
+
+    assoc => {
+      push(:assoc, ts, te)
+    };
+
+    label => {
+      push_label(ts, te)
+    };
+
+    ## == 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/lib/sourcify/method/parser/raw_scanner_extensions.rb

@@ -0,0 +1,68 @@
+Sourcify.require_rb('common', 'parser', 'raw_scanner', 'extensions')
+
+module Sourcify
+  module Method
+    class Parser
+      module RawScanner #:nodoc:all
+        module Extensions
+
+          include Common::Parser::RawScanner::Extensions
+          Counter = Common::Parser::RawScanner::Counter
+
+          def increment_lineno
+            stop_if_probably_defined_by_proc
+            super
+          end
+
+          def stop_if_probably_defined_by_proc
+            raise ProbablyDefinedByProc if @lineno == 1 && @results.empty? && !@counter.started?
+          end
+
+          def increment_counter(count = 1)
+            unless @counter.started?
+              return if (@rejecting_block = codified_tokens !~ @start_pattern)
+              offset_attributes
+            end
+            @counter.increment(count)
+          end
+
+          def decrement_counter
+            @counter.decrement
+            construct_result_code if @counter.balanced?
+          end
+
+          def construct_result_code
+            codes = [false, true].map do |fix_heredoc|
+              codified_tokens(fix_heredoc).force_encoding(@encoding)
+            end
+
+            begin
+              if valid?(codes[1]) && @body_matcher.call(codes[0])
+                # NOTE: Need to fix singleton method to avoid errors (eg. undefined object)
+                # downstream
+                @results << codes.map do |s|
+                  s.sub(%r{^(def\s+)(?:[^\.]+\.)?(#{@name}.*end)$}m, '\1\2')
+                end
+                raise Escape if @stop_on_newline or @lineno != 1
+                reset_attributes
+              end
+            rescue Exception
+              raise if $!.is_a?(Escape)
+            end
+          end
+
+          def reset_attributes
+            @counter = Counter.new
+            super
+          end
+
+          def valid?(*args)
+            # TODO: shouldn't need this check, there seems to be a bug w raw_scanner.rl.
+            args[0].start_with?('def') && super
+          end
+
+        end
+      end
+    end
+  end
+end

data/lib/sourcify/lib/sourcify/method/parser/scanner.rb

@@ -0,0 +1,52 @@
+Sourcify.require_rb('method', 'parser', 'raw_scanner')
+
+module Sourcify
+  module Method
+    class Parser #:nodoc:all
+      class Scanner
+        class << self
+
+          def process(source_code, opts, &matcher)
+            results = rscan(source_code.to_s, {
+              :start_pattern => scan_pattern_hint(opts[:attached_to]),
+              :body_matcher => opts[:body_matcher],
+              :ignore_nested => opts[:ignore_nested],
+              :stop_on_newline => false,
+            }).select{|(raw, normalized)| matcher.call(raw) }
+
+            case results.size
+            when 0 then raise NoMatchingMethodError
+            when 1 then results[0]
+            else raise MultipleMatchingMethodsPerLineError
+            end
+          end
+
+          def scan_pattern_hint(val)
+            case val
+            when Regexp then val
+            when String, Symbol then /^(?:.*?\W|)#{val}(?:\W)/
+            when nil then /.*/
+            else raise TypeError
+            end
+          end
+
+          def rscan(str, opts)
+            results = RawScanner.process(str, opts) || []
+            inner_opts = opts.merge(:stop_on_newline => true)
+            return results if opts[:ignore_nested]
+            results.map do |outer|
+              [
+                outer,
+                *rscan(
+                  outer[0].sub(/^def(.*)end$/,'\1').sub(/^(?:.*?)(def.*)$/,'\1'),
+                  inner_opts
+                )
+              ]
+            end.flatten(1)
+          end
+
+        end
+      end
+    end
+  end
+end

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

@@ -0,0 +1,8 @@
+module Sourcify
+  module Method
+    class Parser #:nodoc:all
+      Sourcify.require_rb('common', 'parser', 'source_code')
+      SourceCode = Common::Parser::SourceCode
+    end
+  end
+end

data/lib/sourcify/lib/sourcify/patches.rb

@@ -0,0 +1,63 @@
+if RUBY_VERSION.include?('1.8.6')
+
+  unless 1.respond_to?(:pred)
+    class Integer
+      def pred
+        self - 1
+      end
+    end
+  end
+
+  unless :a.respond_to?(:to_proc)
+    class Symbol
+      def to_proc
+        Proc.new{|*args| args.shift.__send__(self, *args)}
+      end
+    end
+  end
+
+end
+
+unless binding.respond_to?(:has_local_variable?)
+  class Binding
+    def has_local_variable?(name)
+      check_str = "local_variables.include?(#{name})"
+      self.eval(check_str) rescue eval(check_str, self)
+    end
+  end
+end
+
+# New way of adding new functionalities
+module Sourcify
+  module Patches
+
+    module String
+      if ''.respond_to?(:force_encoding)
+
+        def same_encoding_as(other)
+          force_encoding(other.encoding)
+        end
+
+      else
+
+        def same_encoding_as(other)
+          self
+        end
+
+        def encoding
+          nil
+        end
+
+        def force_encoding(dummy)
+          self
+        end
+
+      end
+    end
+
+    ::String.class_eval do
+      include Sourcify::Patches::String
+    end
+
+  end
+end

data/lib/sourcify/lib/sourcify/proc.rb

@@ -0,0 +1,183 @@
+module Sourcify
+
+  class MultipleMatchingProcsPerLineError < Exception; end
+  class NoMatchingProcError < Exception; end
+  class CannotHandleCreatedOnTheFlyProcError < Exception; end
+
+  module Proc
+
+    def self.included(base) #:nodoc:
+      base.class_eval do
+        Sourcify.require_rb('proc', 'methods')
+        include Methods::SourceLocation
+        include Methods::ToRawSource
+        include Methods::ToSource
+        include Methods::ToSexp
+      end
+    end
+
+    module Stubs
+
+      ###
+      # Returns the ruby source filename and line number containing this proc.
+      #
+      #   # /tmp/test.rb
+      #   x = lambda { 1 }
+      #   x.source_location # >> ["/tmp/test.rb", 2]
+      #
+      # When proc is not defined in ruby (i.e. native), or when the proc is created using
+      # Method#to_proc or Symbol#to_proc, nil is returned.
+      #
+      #   class AA
+      #     class << self
+      #       def m1; 1; end
+      #       def m2(&block); block; end
+      #     end
+      #   end
+      #
+      #   AA.method(:m1).to_proc.source_location # >> nil
+      #   AA.m2(&:m1).source_location            # >> nil
+      #
+      # For 1.9.2, the proc obtained using Method#to_proc by default yields info pointing
+      # to where the method is located. Sourcify respects this builtin implementation and
+      # assumes you usually want it. It is possible to get info that is consistent with all
+      # other rubies by passing in +get_original+ as false:
+      #
+      #   # /tmp/test.rb
+      #   class AA
+      #     def m; 1; end
+      #   end
+      #
+      #   x = AA.new.method(:m).to_proc
+      #   x.source_location        # >> ["/tmp/test.rb", 2]
+      #   x.source_location(false) # >> nil
+      #
+      def source_location(get_original = true)
+        # NOTE: this is a stub for the actual one in Methods::SourceLocation
+      end
+
+      ###
+      # Returns the code representation of this proc. Unlike Proc#to_raw_source, the
+      # returned code retains only the functional aspects, fluff like comments are
+      # stripped off.
+      #
+      #   lambda do |i|
+      #     i+1 # (blah)
+      #   end.to_source
+      #   # >> "proc {|i| i+1 }"
+      #
+      # The following options are supported:
+      #
+      # * +:strip_enclosure+ when set to true, strips the enclosing "proc { ... }" to get
+      #   just the meat within.
+      #
+      #     lambda {|i| i+1 }.to_source(:strip_enclosure => true)
+      #     # >> "i+2"
+      #
+      #   (this option is effective regardless of presence of ParseTree)
+      #
+      # * +:attached_to+ is useful to avoid the nasty
+      #   Sourcify::MultipleMatchingProcsPerLineError (as a result of ambiguities when doing
+      #   static code analysis), it declares the condition that must be met prior grabbing
+      #   the code block:
+      #
+      #     x = lambda { proc { :blah } }
+      #
+      #     x.to_source
+      #     # >> Sourcify::MultipleMatchingProcsPerLineError
+      #
+      #     x.to_source(:attached_to => :lambda)
+      #     # >> "proc { proc { :blah } }"
+      #
+      #   Sometimes more control is needed:
+      #
+      #     # We want to ignore everything associated with ignore
+      #     def ignore(&block); block; end
+      #     x = lambda { ignore { :blah } }
+      #
+      #     x.to_source
+      #     # >> Sourcify::MultipleMatchingProcsPerLineError
+      #
+      #     x.to_source(:attached_to => /^(.*\W|)(lambda|proc)\W/)
+      #     # >> "proc { ignore { :blah } }"
+      #
+      #   (this option is effective ONLY when ParseTree is not available)
+      #
+      # * +:ignore_nested+ is useful when only the outermost proc matters and we want to
+      #   ignore all other nested proc(s):
+      #
+      #     x = lambda { lambda { :blah } }
+      #
+      #     x.to_source
+      #     # >> Sourcify::MultipleMatchingProcsPerLineError
+      #
+      #     x.to_source(:ignore_nested => true)
+      #     # >> "proc { lambda { :blah } }"
+      #
+      #   However, since code scanning stops at the outermost proc, beware of the following:
+      #
+      #     x = lambda {|_| lambda { lambda { :blah } } }.call(nil)
+      #
+      #     x.to_source
+      #     # >> "proc { lambda { :blah } }"
+      #
+      #     x.to_source(:ignore_nested => true)
+      #     # >> Sourcify::NoMatchingProcError
+      #
+      #   (this option is effective ONLY when ParseTree is not available)
+      #
+      # When in static code analysis (non-ParseTree) mode, it is even possible to
+      # specify how the proc body should look like by passing in a code block:
+      #
+      #     x, y = lambda { def secret; 1; end }, lambda { :blah }
+      #
+      #     x.to_source
+      #     # >> Sourcify::MultipleMatchingProcsPerLineError
+      #
+      #     x.to_source{|body| body =~ /^(.*\W|)def\W/ }
+      #     # >> "proc { def secret; 1; end }"
+      #
+      def to_source(opts={}, &body_matcher)
+        # NOTE: this is a stub for the actual one in Methods::ToSource
+      end
+
+      ###
+      # Returns the S-expression representation of this proc.
+      #
+      #   lambda {|i| i+1 }.to_sexp
+      #   # >> s(:iter,
+      #   # >>   s(:call, nil, :proc, s(:arglist)),
+      #   # >>   s(:lasgn, :i),
+      #   # >>   s(:call, s(:lvar, :i), :+, s(:arglist, s(:lit, 1))))
+      #
+      # (pls see #to_source for options/arguments supported)
+      #
+      def to_sexp(opts={}, &body_matcher)
+        # NOTE: this is a stub for the actual one in Methods::ToSexp
+      end
+
+      ###
+      # Returns the raw code enclosed within this proc.
+      #
+      #   lambda do |i|
+      #     i+1 # (blah)
+      #   end.to_source
+      #   # >> "proc do |i|
+      #   # >>   i+1 # (blah)
+      #   # >> end"
+      #
+      # NOTE: The options supported are the same as those for Proc#to_source.
+      #
+      def to_raw_source(opts={}, &body_matcher)
+        # NOTE: this is a stub for the actual one in Methods::ToRawSource
+      end
+
+    end
+
+  end
+
+end
+
+Proc.class_eval do
+  include Sourcify::Proc
+end