ikra 0.0.1

data/lib/sourcify/lib/sourcify.rb

@@ -0,0 +1,44 @@
+require 'rubygems'
+require 'ruby_parser'
+require 'sexp_processor'
+require 'ruby2ruby'
+require 'file/tail'
+
+begin
+  require 'parse_tree'
+  require 'parse_tree_extensions'
+rescue LoadError
+  # ParseTree is now optional for all supported rubies :)
+end
+
+module Sourcify #:nodoc:
+
+  IS_19x = RUBY_VERSION.include?('1.9.')
+
+  HAS_RIPPER =
+    begin
+      require 'ripper'
+      true
+    rescue LoadError
+      false
+    end
+
+  class << self
+
+    def require_rb(*args)
+      require root(*args)
+    end
+
+    def root(*args)
+      @root ||= File.join(File.dirname(File.expand_path(__FILE__)), 'sourcify')
+      File.join(@root, *args)
+    end
+
+  end
+end
+
+Sourcify.require_rb('patches')
+Sourcify.require_rb('errors')
+Sourcify.require_rb('version')
+Sourcify.require_rb('proc')
+Sourcify.require_rb('method')

data/lib/sourcify/lib/sourcify/common/parser/converter.rb

@@ -0,0 +1,29 @@
+module Sourcify
+  module Common
+    class Parser #:nodoc:all
+      class Converter
+        class << self
+
+          RUBY_PARSER = RubyParser.new
+          RUBY_2_RUBY = Ruby2Ruby.new
+
+          def to_sexp(code, file = nil)
+            retried = false
+            begin
+              RUBY_PARSER.reset
+              (retried ? RubyParser.new : RUBY_PARSER).parse(*[code, file].compact)
+            rescue Racc::ParseError, SyntaxError
+              return nil if retried
+              retried = true; retry
+            end
+          end
+
+          def to_code(sexp)
+            RUBY_2_RUBY.process(Sexp.from_array(sexp.to_a))
+          end
+
+        end
+      end
+    end
+  end
+end

data/lib/sourcify/lib/sourcify/common/parser/raw_scanner/comment.rb

@@ -0,0 +1,23 @@
+module Sourcify
+  module Common
+    class Parser
+      module RawScanner #:nodoc:all
+        class Comment
+
+          def <<(content)
+            (@contents ||= []) << content
+          end
+
+          def to_s
+            @contents.join
+          end
+
+          def closed?
+            @contents[-1].split("\n")[-1].strip == '=end'
+          end
+
+        end
+      end
+    end
+  end
+end

data/lib/sourcify/lib/sourcify/common/parser/raw_scanner/counter.rb

@@ -0,0 +1,43 @@
+module Sourcify
+  module Common
+    class Parser
+      module RawScanner #:nodoc:all
+        class Counter
+
+          attr_reader :counts
+
+          def initialize
+            @counts = [0,0]
+          end
+
+          def started?
+            @counts.any?(&:nonzero?)
+          end
+
+          def just_started?
+            @counts.any?{|count| count == 1 }
+          end
+
+          def balanced?
+            @counts.any?(&:zero?)
+          end
+
+          def decrement
+            (0..1).each{|i| @counts[i] -= 1 unless @counts[i].zero? }
+          end
+
+          def increment(val = 1)
+            if val.is_a?(Range)
+              @counts[0] += val.first
+              @counts[1] += val.last
+            else
+              (0..1).each{|i| @counts[i] += 1 }
+            end
+          end
+
+        end
+
+      end
+    end
+  end
+end

data/lib/sourcify/lib/sourcify/common/parser/raw_scanner/dstring.rb

@@ -0,0 +1,58 @@
+module Sourcify
+  module Common
+    class Parser
+      module RawScanner #:nodoc:all
+        class DString < Struct.new(:tag, :encoding)
+
+          # To suppress 'warning: Object#type is deprecated; use Object#class' when
+          # evaluating string
+          attr_reader :type
+
+          def <<(content)
+            (@contents ||= []) << content
+          end
+
+          def to_s
+            @contents.join
+          end
+
+          def closed?
+            evaluable? && parsable?
+          end
+
+          private
+
+            CLOSING_TAGS = {'(' => ')', '[' => ']', '<' => '>', '{' => '}'}
+
+            def evaluable?
+              @contents.length >= 2 &&
+                @contents[-1][-1].chr == end_tag
+            end
+
+            def parsable?
+              !!RubyParser.new.parse(safe_contents)
+            rescue SyntaxError, Racc::ParseError
+              false
+            end
+
+            def safe_contents
+              # NOTE: %x & ` strings are dangerous to eval cos they execute shell commands,
+              # thus we convert them to normal strings 1st
+              to_s.gsub(/(%x)(\W|\_)/, '%Q\2').gsub(/.{0,2}(`)/) do |s|
+                s =~ /^(%Q|%W|%r|%x|.?%|.?\\)/ ? s : s.sub(/`$/,'%Q`')
+              end.force_encoding(encoding)
+            end
+
+            def start_tag
+              @start_tag ||= tag[-1].chr
+            end
+
+            def end_tag
+              @end_tag ||= (CLOSING_TAGS[start_tag] || start_tag)
+            end
+
+        end
+      end
+    end
+  end
+end

data/lib/sourcify/lib/sourcify/common/parser/raw_scanner/extensions.rb

@@ -0,0 +1,140 @@
+%w{heredoc comment dstring counter}.each do |f|
+  Sourcify.require_rb('common', 'parser', 'raw_scanner', f)
+end
+
+module Sourcify
+  module Common
+    class Parser
+      module RawScanner #:nodoc:all
+        module Extensions
+
+          class Escape < Exception; end
+
+          def process(data, opts={})
+            begin
+              @encoding = data.encoding
+              @start_pattern = opts[:start_pattern] || /.*/
+              @body_matcher = opts[:body_matcher] || lambda{|_| true }
+              @stop_on_newline = opts[:stop_on_newline]
+              @results, @data = [], data.unpack("c*")
+              reset_attributes
+              execute!
+            rescue Escape
+              @results
+            else
+              @results
+            end
+          end
+
+          def data_frag(range)
+            @data[range].pack('c*')
+          end
+
+          def push(key, ts, te)
+            @tokens << [key, data_frag(ts .. te.pred)]
+          end
+
+          def push_dstring(ts, te)
+            data = data_frag(ts .. te.pred)
+            @dstring ||= DString.new(data[%r{^("|`|/|%(?:Q|W|r|x|)(?:\W|_))},1], @encoding)
+            @dstring << data
+            return true unless @dstring.closed?
+            @tokens << [:dstring, @dstring.to_s]
+            @dstring = nil
+          end
+
+          def push_comment(ts, te)
+            data = data_frag(ts .. te.pred)
+            @comment ||= Comment.new
+            @comment << data
+            return true unless @comment.closed?
+            @tokens << [:comment, @comment.to_s]
+            @comment = nil
+          end
+
+          def push_heredoc(ts, te)
+            data = data_frag(ts .. te.pred)
+            unless @heredoc
+              indented, tag = data.match(/\<\<(\-?)['"]?(\w+)['"]?$/)[1..3]
+              @heredoc = Heredoc.new(tag, !indented.empty?, @encoding)
+            end
+            @heredoc << data
+            return true unless @heredoc.closed?(data_frag(te .. te))
+            @tokens << [:heredoc, @heredoc.to_s]
+            @heredoc = nil
+          end
+
+          def push_label(ts, te)
+            # NOTE: 1.9.* supports label key, which RubyParser cannot handle, thus
+            # conversion is needed.
+            @tokens << [:symbol, ':' + data_frag(ts .. te - 2)]
+            @tokens << [:space, ' ']
+            @tokens << [:assoc, '=>']
+          end
+
+          def preceded_with?(*args)
+            prev_token = @tokens[-1][0] == :space ? @tokens[-2] : @tokens[-1]
+            !([args].flatten & prev_token).empty? rescue nil
+          end
+
+          def increment_lineno
+            @lineno += 1
+            raise Escape \
+              if @stop_on_newline || !@results.empty? || (@results.empty? && @rejecting_block)
+          end
+
+          def codified_tokens(fix_heredoc = false)
+            (
+              if fix_heredoc
+                @tokens.map do |key, val|
+                  case key
+                  when :heredoc
+                    %(\n%"#{
+                      val.sub(/^(?:[^\n]+\n)(.*\n)(?:[^\n]+)$/m, '\1').
+                        gsub(/\\|"/) {|c| "\\#{c}" }
+                    }")
+                  else val
+                  end
+                end
+              else
+                @tokens.map(&:last)
+              end
+            ).join
+          end
+
+          def reset_attributes
+            @tokens, @lineno = [], 1
+            @heredoc, @dstring, @comment, @rejecting_block = nil
+          end
+
+          def offset_attributes
+            @lineno = 1 # Fixing JRuby's lineno bug (see http://jira.codehaus.org/browse/JRUBY-5014)
+            @tokens = [@tokens[-1]] unless @tokens.empty?
+          end
+
+          if HAS_RIPPER
+
+            def valid?(snippet, validate_as = nil)
+              sexp = Ripper.sexp(snippet)
+              return false unless sexp
+
+              case validate_as
+              when :hash then sexp[-1][0][0] == :hash
+              when nil then true
+              else raise ArgumentError
+              end
+            end
+
+          else
+
+            def valid?(snippet, _ = nil)
+              RubyParser.new.parse("#{snippet}") rescue false
+            end
+
+          end
+
+        end
+      end
+    end
+  end
+end

data/lib/sourcify/lib/sourcify/common/parser/raw_scanner/heredoc.rb

@@ -0,0 +1,26 @@
+module Sourcify
+  module Common
+    class Parser
+      module RawScanner #:nodoc:all
+        class Heredoc < Struct.new(:tag, :indented, :encoding)
+
+          def <<(content)
+            (@contents ||= []) << content
+          end
+
+          def to_s
+            @contents.join.force_encoding(encoding)
+          end
+
+          def closed?(sealer)
+            return false unless sealer == "\n"
+            parts = @contents[-1].split("\n")
+            return true if parts[-1] == tag
+            indented && parts[-1].sub(/^\s*(.*)$/,'\1') == tag
+          end
+
+        end
+      end
+    end
+  end
+end

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

@@ -0,0 +1,45 @@
+module Sourcify
+  module Common
+    class Parser #:nodoc:all
+      class SourceCode < Struct.new(:file, :line)
+
+        def line
+          super.pred
+        end
+
+        def to_s
+          case file
+          when /\(irb\)/, /\(irb\#\d+\)/ then from_irb_to_s
+          when /\(pry\)/ then from_pry_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
+
+        def from_pry_to_s
+          # NOTE: HACK to reliably construct the lines required, as:
+          # * Pry.line_buffer always fail to show the last entry
+          # * Pry.history deliberately skips duplicated consecutive lines,
+          #   yet it reliably shows the last
+          [
+            Pry.line_buffer,
+            Pry.history.to_a[-1]
+          ].flatten[line.succ .. -1] * ""
+        end
+
+      end
+    end
+  end
+end

data/lib/sourcify/lib/sourcify/common/ragel/common.rl

@@ -0,0 +1,5 @@
+%%{
+  machine common;
+  include common_expressions 'expressions.rl';
+  include common_machines 'machines.rl';
+

data/lib/sourcify/lib/sourcify/common/ragel/expressions.rl

@@ -0,0 +1,38 @@
+%%{
+  machine common_expressions;
+
+  kw_class  = 'class';
+  kw_module = 'module';
+  kw_def    = 'def';
+  kw_begin  = 'begin';
+  kw_case   = 'case';
+  kw_if     = 'if';
+  kw_unless = 'unless';
+  kw_do     = 'do';
+  kw_then   = 'then';
+  kw_for    = 'for';
+  kw_while  = 'while';
+  kw_until  = 'until';
+  kw_end    = 'end';
+
+  vchar   = alnum | '_';
+  const   = upper . vchar* . ('::' . alpha . vchar*)*;
+  var     = (lower | '_') . vchar*;
+  meth    = (alpha | '_') . vchar*;
+  symbol  = ':' . (var | const);
+  assoc   = '=>';
+  assgn   = '=';
+  comma   = ',';
+  label   = (var | const) . ':';
+
+  lparen  = '(';
+  rparen  = ')';
+  lbrace  = '{';
+  rbrace  = '}';
+  smcolon = ';';
+  newline = '\n';
+  bslash  = '\\' . newline;
+  ospaces = space* -- newline;
+  mspaces = space+ -- newline;
+
+}%%