live_ast 0.2.0

data/lib/live_ast/ast_eval.rb

@@ -0,0 +1,13 @@
+require 'live_ast/base'
+
+module Kernel
+  private
+
+  #
+  # The same as +eval+ except that the binding argument is required
+  # and AST-accessible objects are created.
+  #
+  def ast_eval(*args)
+    LiveAST::Evaler.eval(args[0], *args)
+  end
+end

data/lib/live_ast/ast_load.rb

@@ -0,0 +1,15 @@
+require 'live_ast/base'
+
+module Kernel
+  private
+
+  #
+  # For use in noninvasive mode (<code>require 'live_ast/base'</code>).
+  #
+  # Same behavior as the built-in +load+ except that AST-accessible
+  # objects are created.
+  #
+  def ast_load(file, wrap = false)
+    LiveAST::Loader.load(file, wrap)
+  end
+end

data/lib/live_ast/base.rb

@@ -0,0 +1,56 @@
+require 'thread'
+
+require 'live_ast/parser'
+require 'live_ast/loader'
+require 'live_ast/evaler'
+require 'live_ast/linker'
+require 'live_ast/cache'
+require 'live_ast/error'
+
+module LiveAST
+  NATIVE_EVAL = Kernel.method(:eval)  #:nodoc:
+
+  class << self
+    #
+    # For use in noninvasive mode (<code>require 'live_ast/base'</code>).
+    #
+    # Extract an object's AST.
+    #
+    def ast(obj)  #:nodoc:
+      case obj
+      when Method, UnboundMethod
+        Linker.find_method_ast(obj.owner, obj.name, *obj.source_location)
+      when Proc
+        Linker.find_proc_ast(obj)
+      else
+        raise TypeError, "No AST for #{obj.class} objects"
+      end
+    end
+
+    #
+    # Flush unused ASTs from the cache. See README.rdoc before doing
+    # this.
+    #
+    def flush_cache
+      Linker.flush_cache
+    end
+
+    #
+    # For use in noninvasive mode (<code>require 'live_ast/base'</code>).
+    #
+    # Equivalent to Kernel#ast_eval.
+    #
+    def eval(*args)  #:nodoc:
+      Evaler.eval(args[0], *args)
+    end
+
+    #
+    # For use in noninvasive mode (<code>require 'live_ast/base'</code>).
+    #
+    # Equivalent to Kernel#ast_load.
+    #
+    def load(file, wrap = false)  #:nodoc:
+      Loader.load(file, wrap)
+    end
+  end
+end

data/lib/live_ast/cache.rb

@@ -0,0 +1,14 @@
+module LiveAST
+  class Cache
+    def initialize(*args)
+      @source, @user_line, @asts = args
+    end
+
+    def fetch_ast(line)
+      @asts ||= Parser.new.parse(@source).tap do
+        @source = nil
+      end
+      @asts.delete(line - @user_line + 1)
+    end
+  end
+end

data/lib/live_ast/error.rb

@@ -0,0 +1,30 @@
+module LiveAST
+  class MultipleDefinitionsOnSameLineError < ScriptError
+    def message
+      "AST requested for a method or block that shares a line " <<
+      "with another method or block."
+    end
+  end
+
+  class ASTNotFoundError < StandardError
+  end
+
+  class RawEvalError < ASTNotFoundError
+    def message
+      "Must use ast_eval instead of eval in order to obtain AST."
+    end
+  end
+  
+  class NoSourceError < ASTNotFoundError
+    def message
+      "No source found for the requested AST. " <<
+      "Are you sure it was written in ruby?"
+    end
+  end
+
+  class FlushedError < ASTNotFoundError
+    def message
+      "The requested AST was flushed from the cache."
+    end
+  end
+end

data/lib/live_ast/evaler.rb

@@ -0,0 +1,66 @@
+module LiveAST
+  module Evaler
+    class << self
+      def eval(parser_source, *args)
+        evaler_source, bind, *location = handle_args(*args)
+
+        file, line = handle_location(bind, *location)
+        file = Linker.strip_token(file)
+
+        key, _ = Linker.new_cache_synced(parser_source, file, line, false)
+
+        begin
+          NATIVE_EVAL.call(evaler_source, bind, key, line)
+        rescue Exception => ex
+          fix_backtrace(ex.backtrace)
+          raise ex
+        end
+      end
+
+      #
+      # match eval's error messages
+      #
+      def handle_args(*args)
+        unless (2..4).include? args.size
+          raise ArgumentError,
+          "wrong number of arguments (#{args.size} for 2..4)"
+        end
+        unless args[1].is_a? Binding
+          raise TypeError,
+          "wrong argument type #{args[1].class} (expected Binding)"
+        end
+        args[0] = arg_to_str(args[0])
+        args[2] = arg_to_str(args[2]) unless args[2].nil?
+        args
+      end
+
+      def arg_to_str(arg)
+        begin
+          arg.to_str
+        rescue
+          raise TypeError, "can't convert #{arg.class} into String"
+        end
+      end
+
+      #
+      # match eval's behavior
+      #
+      def handle_location(bind, *location)
+        case location.size
+        when 0
+          NATIVE_EVAL.call("[__FILE__, __LINE__]", bind)
+        when 1
+          [location.first, 1]
+        else
+          location
+        end
+      end
+
+      def fix_backtrace(backtrace)
+        backtrace.map! { |line|
+          LiveAST::Linker.strip_token line
+        }
+      end
+    end
+  end
+end

data/lib/live_ast/linker.rb

@@ -0,0 +1,107 @@
+module LiveAST
+  module Attacher
+    VAR_NAME = :@_live_ast
+      
+    def attach_to_proc(obj, ast)
+      obj.instance_variable_set(VAR_NAME, ast)
+    end
+    
+    def fetch_proc_attachment(obj)
+      if obj.instance_variable_defined?(VAR_NAME)
+        obj.instance_variable_get(VAR_NAME)
+      end
+    end
+    
+    def attach_to_method(klass, method, ast)
+      unless klass.instance_variable_defined?(VAR_NAME)
+        klass.instance_variable_set(VAR_NAME, {})
+      end
+      klass.instance_variable_get(VAR_NAME)[method] = ast
+    end
+    
+    def fetch_method_attachment(klass, method)
+      if klass.instance_variable_defined?(VAR_NAME)
+        klass.instance_variable_get(VAR_NAME)[method]
+      end
+    end
+  end
+    
+  module Linker
+    REVISION_TOKEN = "|ast@"
+
+    @caches = {}
+    @counter = "a"
+    @mutex = Mutex.new
+
+    class << self
+      include Attacher
+
+      def find_proc_ast(obj)
+        @mutex.synchronize do
+          fetch_proc_attachment(obj) or (
+            ast = find_ast(*obj.source_location) or raise FlushedError
+            attach_to_proc(obj, ast)
+          )
+        end
+      end
+
+      def find_method_ast(klass, name, *location)
+        @mutex.synchronize do
+          case ast = find_ast(*location)
+          when nil
+            fetch_method_attachment(klass, name) or raise FlushedError
+          else
+            attach_to_method(klass, name, ast)
+          end
+        end
+      end
+
+      def find_ast(*location)
+        raise NoSourceError unless location.size == 2
+        raise RawEvalError if location.first == "(eval)"
+        ast = fetch_from_cache(*location)
+        raise MultipleDefinitionsOnSameLineError if ast == :multiple
+        ast
+      end
+
+      def fetch_from_cache(file, line)
+        cache = @caches[file]
+        if !cache and !file.index(REVISION_TOKEN)
+          #
+          # File was loaded by 'require'.
+          # Play catch-up: assume it has not changed in the meantime.
+          #
+          _, cache = new_cache(Loader.read(file), file, 1, true)
+        end
+        cache.fetch_ast(line) if cache
+      end
+
+      #
+      # create a cache along with a uniquely-identifing key for it
+      #
+      def new_cache(contents, file, user_line, file_is_key)
+        key = file_is_key ? file : file + REVISION_TOKEN + @counter
+        cache = Cache.new(contents, user_line)
+        @caches[key] = cache
+        @counter.next!
+        return key, cache
+      end
+
+      def new_cache_synced(*args)
+        @mutex.synchronize do
+          new_cache(*args)
+        end
+      end
+
+      def flush_cache
+        @mutex.synchronize do
+          @caches.delete_if { |key, _| key.index REVISION_TOKEN }
+        end
+      end
+
+      def strip_token(file)
+        file.sub(/#{Regexp.quote REVISION_TOKEN}[a-z]+/, "")
+      end
+    end
+  end
+end

data/lib/live_ast/loader.rb

@@ -0,0 +1,69 @@
+# encoding: us-ascii
+
+module LiveAST
+  module Loader
+    MAGIC_COMMENT = /\A(?:#!.*?\n)?\s*\#.*(?:en)?coding\s*[:=]\s*([^\s;]+)/
+
+    class << self
+      def load(file, wrap)
+        file = find_file(file)
+
+        # guards to protect toplevel locals
+        header, footer, warnings_ok = header_footer(wrap)
+  
+        parser_src = read(file)
+        evaler_src = header << parser_src << footer
+        
+        run = lambda do
+          Evaler.eval(parser_src, evaler_src, TOPLEVEL_BINDING, file, 1)
+        end
+        warnings_ok ? run.call : suppress_warnings(&run)
+        true
+      end
+  
+      def read(file)
+        contents = File.read(file, :encoding => "BINARY")
+        encoding = contents[MAGIC_COMMENT, 1] || "US-ASCII"
+        contents.force_encoding(encoding)
+      end
+
+      def header_footer(wrap)
+        if wrap
+          return "class << Object.new;", ";end", true
+        else
+          locals = NATIVE_EVAL.call("local_variables", TOPLEVEL_BINDING)
+  
+          params = locals.empty? ? "" : ("|;" + locals.join(",") + "|")
+  
+          return "lambda do #{params}", ";end.call", locals.empty?
+        end
+      end
+  
+      def suppress_warnings
+        previous = $VERBOSE
+        $VERBOSE = nil
+        begin
+          yield
+        ensure
+          $VERBOSE = previous
+        end
+      end
+
+      def find_file(file)
+        if file.index Linker::REVISION_TOKEN
+          raise "refusing to load file with revision token: `#{file}'"
+        end
+        search_paths(file) or raise LoadError, "no such file to load -- #{file}"
+      end
+
+      def search_paths(file)
+        return file if File.file? file
+        $LOAD_PATH.each do |path|
+          target = path + "/" + file
+          return target if File.file? target
+        end
+        nil
+      end
+    end
+  end
+end

data/lib/live_ast/parser.rb

@@ -0,0 +1,48 @@
+require 'ruby_parser'
+require 'sexp_processor'
+
+module LiveAST
+  class Parser < SexpProcessor
+    def parse(source)
+      @defs = {}
+      process RubyParser.new.parse(source)
+      @defs
+    end
+
+    def process_defn(sexp)
+      result = Sexp.new
+      result << sexp.shift
+      result << sexp.shift
+      result << process(sexp.shift)
+      result << process(sexp.shift)
+
+      store_sexp(result, sexp.line)
+      s()
+    end
+
+    def process_iter(sexp)
+      line = sexp[1].line
+
+      result = Sexp.new
+      result << sexp.shift
+      result << process(sexp.shift)
+      result << process(sexp.shift)
+      result << process(sexp.shift)
+
+      #
+      # ruby_parser bug: a method without args attached to a
+      # multi-line block reports the wrong line. workaround.
+      #
+      if result[1][3].size == 1
+        line = sexp.line
+      end
+
+      store_sexp(result, line)
+      s()
+    end
+
+    def store_sexp(sexp, line)
+      @defs[line] = @defs.has_key?(line) ? :multiple : sexp
+    end
+  end
+end

data/lib/live_ast/replace_load.rb

@@ -0,0 +1,14 @@
+require 'live_ast/base'
+
+module Kernel
+  alias_method :live_ast_original_load, :load
+
+  def load(file, wrap = false)
+    LiveAST.load(file, wrap)
+  end
+  
+  class << self
+    remove_method :load
+  end
+  module_function :load
+end

data/lib/live_ast/replace_raise.rb

@@ -0,0 +1,21 @@
+require 'live_ast/base'
+
+module Kernel
+  private
+
+  alias_method :live_ast_original_raise, :raise
+
+  def raise(*args)
+    ex = begin
+           live_ast_original_raise(*args)
+         rescue Exception => ex
+           ex
+         end
+
+    ex.backtrace.reject! { |line| line.index __FILE__ }
+
+    LiveAST::Evaler.fix_backtrace ex.backtrace
+
+    live_ast_original_raise ex
+  end
+end

data/lib/live_ast/to_ast.rb

@@ -0,0 +1,17 @@
+require 'live_ast/base'
+
+[Method, UnboundMethod].each do |klass|
+  klass.class_eval do
+    # Extract the AST of this object.
+    def to_ast
+      LiveAST::Linker.find_method_ast(owner, name, *source_location)
+    end
+  end
+end
+    
+class Proc
+  # Extract the AST of this object.
+  def to_ast
+    LiveAST::Linker.find_proc_ast(self)
+  end
+end

data/lib/live_ast/to_ruby.rb

@@ -0,0 +1,12 @@
+require 'ruby2ruby'
+
+require 'live_ast/base'
+
+[Method, UnboundMethod, Proc].each do |klass|
+  klass.class_eval do
+    # Generate ruby code which reflects the AST of this object.
+    def to_ruby
+      Ruby2Ruby.new.process(LiveAST.ast(self))
+    end
+  end
+end

data/lib/live_ast/version.rb

@@ -0,0 +1,3 @@
+module LiveAST
+  VERSION = "0.2.0"
+end

data/lib/live_ast.rb

@@ -0,0 +1,4 @@
+require 'live_ast/base'
+require 'live_ast/to_ast'
+require 'live_ast/ast_eval'
+require 'live_ast/replace_load'

data/test/ast_eval_feature_test.rb

@@ -0,0 +1,11 @@
+require_relative 'shared/main'
+
+class AAB_ASTEvalFeatureTest < BaseTest
+  def test_require
+    assert !private_methods.include?(:ast_eval)
+
+    require 'live_ast/ast_eval'
+
+    assert private_methods.include?(:ast_eval)
+  end
+end

data/test/ast_load_feature_test.rb

@@ -0,0 +1,11 @@
+require_relative 'shared/main'
+
+class AAB_ASTLoadFeatureTest < BaseTest
+  def test_require
+    assert !private_methods.include?(:ast_load)
+
+    require 'live_ast/ast_load'
+
+    assert private_methods.include?(:ast_load)
+  end
+end

data/test/backtrace_test.rb

@@ -0,0 +1,159 @@
+require_relative 'shared/main'
+
+# test for raise redefinition side-effects: unsort this TestCase from
+# other TestCases.
+
+define_unsorted_test_case "BacktraceTest", RegularTest do
+  def test_raise_in_eval
+    3.times do
+      orig = exception_backtrace do
+        eval %{
+  
+          raise
+  
+  
+        }, binding, "somewhere", 1000
+      end
+  
+      live = exception_backtrace do
+        ast_eval %{
+  
+          raise
+  
+  
+        }, binding, "somewhere", 1000
+      end
+      
+      assert_equal orig.first, live.first
+      assert_match(/somewhere:1002/, live.first)
+    end
+  end
+
+  def test_raise_no_overrides
+    3.times do
+      orig = exception_backtrace do
+        eval %{
+  
+
+          raise
+  
+        }, binding, __FILE__, (__LINE__ + 9)
+      end
+  
+      live = exception_backtrace do
+        ast_eval %{
+  
+
+          raise
+  
+        }, binding
+      end
+
+      assert_equal orig.first, live.first
+      here = Regexp.quote __FILE__
+      assert_match(/#{here}/, live.first)
+    end
+  end
+
+  def test_raise_using_overrides
+    3.times do
+      orig = exception_backtrace do
+        eval %{
+  
+
+          raise
+  
+        }, binding, __FILE__, (__LINE__ + 9)
+      end
+  
+      live = exception_backtrace do
+        ast_eval %{
+  
+
+          raise
+  
+        }, binding, __FILE__, __LINE__
+      end
+
+      assert_equal orig.first, live.first
+      here = Regexp.quote __FILE__
+      assert_match(/#{here}/, live.first)
+    end
+  end
+
+  def test_raise_using_only_file_override
+    3.times do
+      orig = exception_backtrace do
+        eval %{
+  
+
+          raise
+  
+        }, binding, __FILE__
+      end
+  
+      live = exception_backtrace do
+        ast_eval %{
+  
+
+          raise
+  
+        }, binding, __FILE__
+      end
+
+      assert_equal orig.first, live.first
+      here = Regexp.quote __FILE__
+      assert_match(/#{here}/, live.first)
+    end
+  end
+  
+  def test_raise_after_eval
+    raise_after_eval("raise", false)
+    raise_after_eval("1/0", false)
+
+    require 'live_ast/replace_raise'
+
+    raise_after_eval("raise", true)
+    raise_after_eval("1/0", false)
+  end
+
+  def raise_after_eval(code, will_succeed)
+    3.times do
+      orig = eval %{
+
+        lambda { #{code} }
+
+
+      }, binding, "somewhere", 1000
+  
+      live = ast_eval %{
+
+          lambda { #{code} }
+
+
+      }, binding, "somewhere", 1000
+
+      orig_top = exception_backtrace { orig.call }.first
+      live_top = exception_backtrace { live.call }.first
+
+      assert_equal orig_top, LiveAST::Linker.strip_token(live_top)
+
+      if will_succeed
+        assert_equal orig_top, live_top
+        here = Regexp.quote __FILE__
+        assert_match(/somewhere:1002/, live_top)
+      else
+        assert_not_equal orig_top, live_top
+        assert_match(/somewhere.*?:1002/, live_top)
+      end
+    end
+  end
+  
+  def test_tokens_stripped
+    exception_backtrace do
+      ast_eval %{ ast_eval %{ ast_eval %{raise}, binding }, binding }, binding
+    end.each do |line|
+      assert_nil line.index(LiveAST::Linker::REVISION_TOKEN)
+    end
+  end
+end