mvz-live_ast 1.1.0

data/devel/levitate_config.rb

@@ -0,0 +1,4 @@
+
+if RUBY_ENGINE == "jruby"
+  Levitate.ruby_opts = %w[--1.9]
+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/lib/live_ast/ast_eval.rb

@@ -0,0 +1,11 @@
+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,73 @@
+require 'thread'
+
+require 'live_ast/common'
+require 'live_ast/reader'
+require 'live_ast/evaler'
+require 'live_ast/linker'
+require 'live_ast/loader'
+require 'live_ast/error'
+require 'live_ast/irb_spy' if defined?(IRB)
+
+module LiveAST
+  NATIVE_EVAL = Kernel.method(:eval)  #:nodoc:
+
+  class << self
+    attr_writer :parser  #:nodoc:
+
+    def parser  #:nodoc:
+      @parser ||= (
+        require 'live_ast/ruby_parser'
+        LiveAST::RubyParser
+      )
+    end
+
+    #
+    # For use in noninvasive mode (<code>require 'live_ast/base'</code>).
+    #
+    # Equivalent to <code>obj.to_ast</code>.
+    #
+    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 <code>Kernel#ast_eval</code>.
+    #
+    def eval(*args)  #:nodoc:
+      Evaler.eval(args[0], *args)
+    end
+
+    #
+    # For use in noninvasive mode (<code>require 'live_ast/base'</code>).
+    #
+    # Equivalent to <code>Kernel#ast_load</code>.
+    #
+    def load(file, wrap = false)  #:nodoc:
+      Loader.load(file, wrap)
+    end
+
+    #
+    # strip the revision token from a string
+    #
+    def strip_token(file)  #:nodoc:
+      file.sub(/#{Regexp.quote Linker::REVISION_TOKEN}[a-z]+/, "")
+    end
+  end
+end

data/lib/live_ast/common.rb

@@ -0,0 +1,48 @@
+
+module LiveAST
+  module Common
+    module_function
+    
+    def arg_to_str(arg)
+      begin
+        arg.to_str
+      rescue NameError
+        thing = if arg.nil? then nil else arg.class end
+
+        raise TypeError, "can't convert #{thing.inspect} into String"
+      end
+    end
+
+    def check_arity(args, range)
+      unless range.include? args.size
+        range = 0 if range == (0..0)
+
+        raise ArgumentError,
+        "wrong number of arguments (#{args.size} for #{range})"
+      end
+    end
+
+    def check_type(obj, klass)
+      unless obj.is_a? klass
+        raise TypeError, "wrong argument type #{obj.class} (expected #{klass})"
+      end
+    end
+
+    def location_for_eval(*args)
+      bind, *location = args
+
+      if bind
+        case location.size
+        when 0
+          NATIVE_EVAL.call("[__FILE__, __LINE__]", bind)
+        when 1
+          [location.first, 1]
+        else
+          location
+        end
+      else
+        ["(eval)", 1]
+      end
+    end
+  end
+end

data/lib/live_ast/error.rb

@@ -0,0 +1,20 @@
+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
+    def message
+      "The requested AST could not be found (AST flushed or compiled code)."
+    end
+  end
+
+  class RawEvalError < ASTNotFoundError
+    def message
+      "Must use ast_eval instead of eval in order to obtain AST."
+    end
+  end
+end

data/lib/live_ast/evaler.rb

@@ -0,0 +1,32 @@
+module LiveAST
+  module Evaler
+    class << self
+      include Common
+
+      def eval(parser_source, *args)
+        evaler_source, bind, *rest = handle_args(*args)
+
+        file, line = location_for_eval(bind, *rest)
+        file = LiveAST.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
+          ex.backtrace.map! { |s| LiveAST.strip_token s }
+          raise ex
+        end
+      end
+
+      def handle_args(*args)
+        args.tap do
+          check_arity(args, 2..4)
+          args[0] = arg_to_str(args[0])
+          check_type(args[1], Binding)
+          args[2] = arg_to_str(args[2]) if args[2]
+        end
+      end
+    end
+  end
+end

data/lib/live_ast/full.rb

@@ -0,0 +1,2 @@
+require 'live_ast'
+require 'live_ast/replace_eval'

data/lib/live_ast/irb_spy.rb

@@ -0,0 +1,43 @@
+
+module LiveAST
+  @history = nil
+
+  module IRBSpy
+    class << self
+      attr_writer :history
+
+      def code_at(line)
+        unless @history
+          raise NotImplementedError,
+          "LiveAST cannot access history for this IRB input method"
+        end
+        grow = 0
+        begin
+          code = @history[line..(line + grow)].join
+          LiveAST.parser.new.parse(code) or raise "#{LiveAST.parser} error"
+        rescue
+          grow += 1
+          retry if line + grow < @history.size
+          raise
+        end
+        code
+      end
+    end
+  end
+end
+
+[
+ defined?(IRB::StdioInputMethod) ? IRB::StdioInputMethod : nil,
+ defined?(IRB::ReadlineInputMethod) ? IRB::ReadlineInputMethod : nil,
+].compact.each do |klass|
+  klass.module_eval do
+    alias_method :live_ast_original_gets, :gets
+    def gets
+      live_ast_original_gets.tap do
+        if defined?(@line)
+          LiveAST::IRBSpy.history = @line
+        end
+      end
+    end
+  end
+end

data/lib/live_ast/linker.rb

@@ -0,0 +1,122 @@
+module LiveAST
+  class Cache
+    def initialize(*args)
+      @source, @user_line = args
+      @asts = nil
+    end
+
+    def fetch_ast(line)
+      @asts ||= LiveAST.parser.new.parse(@source).tap do
+        @source = nil
+      end
+      @asts.delete(line - @user_line + 1)
+    end
+  end
+
+  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 ASTNotFoundError
+            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 ASTNotFoundError
+          else
+            attach_to_method(klass, name, ast)
+          end
+        end
+      end
+
+      def find_ast(*location)
+        raise ASTNotFoundError 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)
+          _, cache =
+            if defined?(IRB) and file == "(irb)"
+              new_cache(IRBSpy.code_at(line), file, line, false)
+            else
+              #
+              # File was loaded by 'require'.
+              # Play catch-up: assume it has not changed in the meantime.
+              #
+              new_cache(Reader.read(file), file, 1, true)
+            end
+        end
+        cache.fetch_ast(line) if cache
+      end
+
+      #
+      # create a cache along with a unique 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
+    end
+  end
+end

data/lib/live_ast/loader.rb

@@ -0,0 +1,60 @@
+module LiveAST
+  module Loader
+    class << self
+      def load(file, wrap)
+        file = find_file(file)
+
+        # guards to protect toplevel locals
+        header, footer, warnings_ok = header_footer(wrap)
+  
+        parser_src = Reader.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 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, "cannot load such file -- #{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