mvz-live_ast 1.1.0

data/lib/live_ast/reader.rb

@@ -0,0 +1,26 @@
+# encoding: us-ascii
+module LiveAST
+  module Reader
+    UTF8_BOM = /\A\xef\xbb\xbf/
+    MAGIC_COMMENT = /\A(?:#!.*?\n)?\s*\#.*(?:en)?coding\s*[:=]\s*([^\s;]+)/
+
+    def self.read(file)
+      contents = File.read(file, :encoding => "BINARY")
+      
+      utf8 = contents.sub!(UTF8_BOM, "") ? "UTF-8" : nil
+
+      # magic comment overrides BOM
+      encoding = contents[MAGIC_COMMENT, 1] || utf8 || "US-ASCII"
+
+      contents.force_encoding(strip_special(encoding))
+    end
+
+    def self.strip_special(encoding)
+      if encoding =~ /\Autf8-mac\Z/i
+        "UTF8-MAC"
+      else
+        encoding.sub(/-(unix|dos|mac)\Z/i, "")
+      end
+    end
+  end
+end

data/lib/live_ast/replace_eval.rb

@@ -0,0 +1,121 @@
+require 'live_ast/base'
+require 'binding_of_caller'
+
+module LiveAST
+  module ReplaceEval
+    class << self
+      def module_or_instance_eval(which, remote_self, bind, args)
+        handle_args(args)
+
+        cache[:remote_self] = remote_self
+        cache[:args] = args
+
+        code = %{
+          ::LiveAST::ReplaceEval.cache[:remote_self].
+          live_ast_original_#{which}_eval %{
+            ::LiveAST.eval(
+              ::LiveAST::ReplaceEval.cache[:args][0],
+              ::Kernel.binding,
+              *::LiveAST::ReplaceEval.cache[:args][1..-1])
+          }
+        }
+
+        live_ast_original_eval(code, bind)
+      ensure
+        cache.clear
+      end
+
+      def cache
+        Thread.current[:_live_ast_arg_cache] ||= {}
+      end
+
+      def handle_args(args)
+        if args.empty?
+          raise ArgumentError, "block not supplied"
+        end
+        
+        args[0] = Common.arg_to_str(args[0])
+        
+        unless (1..3).include? args.size
+          raise ArgumentError,
+          "wrong number of arguments: instance_eval(src) or instance_eval{..}"
+        end
+        
+        args[1] = Common.arg_to_str(args[1]) if args[1]
+      end
+    end
+  end
+  
+  # ensure the parser is loaded -- rubygems calls eval
+  parser
+end
+
+# squelch alias warnings
+prev_verbose = $VERBOSE
+$VERBOSE = nil
+
+module Kernel
+  class << self
+    alias_method :live_ast_original_singleton_eval, :eval
+
+    def eval(*args)
+      LiveAST::Common.check_arity(args, 1..4)
+      LiveAST.eval(
+        "::Kernel.live_ast_original_instance_eval do;" << args[0] << ";end",
+        args[1] || binding.of_caller(1),
+        *LiveAST::Common.location_for_eval(*args[1..3]))
+    end
+  end
+
+  private
+
+  alias_method :live_ast_original_eval, :eval
+
+  def eval(*args)
+    LiveAST::Common.check_arity(args, 1..4)
+    LiveAST.eval(
+      args[0],
+      args[1] || binding.of_caller(1),
+      *LiveAST::Common.location_for_eval(*args[1..3]))
+  end
+end
+
+class Binding
+  alias_method :live_ast_original_binding_eval, :eval
+
+  def eval(*args)
+    LiveAST.eval(args[0], self, *args[1..-1])
+  end
+end
+
+class BasicObject
+  alias_method :live_ast_original_instance_eval, :instance_eval
+
+  def instance_eval(*args, &block)
+    if block
+      live_ast_original_instance_eval(*args, &block)
+    else
+      ::LiveAST::ReplaceEval.
+        module_or_instance_eval(:instance, self, ::Kernel.binding.of_caller(1), args)
+    end
+  end
+end
+
+class Module
+  alias_method :live_ast_original_module_eval, :module_eval
+
+  def module_eval(*args, &block)
+    if block
+      live_ast_original_module_eval(*args, &block)
+    else
+      LiveAST::ReplaceEval.
+        module_or_instance_eval(:module, self, binding.of_caller(1), args)
+    end
+  end
+
+  remove_method :class_eval
+  alias_method :class_eval, :module_eval
+end
+
+# unsquelch alias warnings
+$VERBOSE = prev_verbose

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,18 @@
+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 => t
+           t
+         end
+    ex.backtrace.reject! { |line| line.index __FILE__ }
+    ex.backtrace.map! { |line| LiveAST.strip_token line }
+    live_ast_original_raise ex
+  end
+end

data/lib/live_ast/ruby_parser.rb

@@ -0,0 +1,36 @@
+require 'ruby_parser'
+require 'live_ast/base'
+
+class LiveAST::RubyParser
+  #
+  # Returns a line-to-sexp hash where sexp corresponds to the method
+  # or block defined at the given line.
+  #
+  # This method is the only requirement of a LiveAST parser plugin.
+  #
+  def parse(source)
+    @defs = {}
+    process RubyParser.new.parse(source)
+    @defs
+  end
+
+  def process(sexp)
+    case sexp.first
+    when :defn, :defs, :iter
+      store_sexp(sexp, sexp.line)
+    end
+
+    sexp.each do |elem|
+      process(elem) if elem.is_a? Sexp
+    end
+  end
+
+  def store_sexp(sexp, line)
+    @defs[line] = @defs.has_key?(line) ? :multiple : sexp
+  end
+end
+
+LiveAST::RubyParser.autoload :Unparser, 'live_ast/ruby_parser/unparser'
+LiveAST::RubyParser.autoload :Test, 'live_ast/ruby_parser/test'
+
+LiveAST.parser = LiveAST::RubyParser

data/lib/live_ast/ruby_parser/test.rb

@@ -0,0 +1,197 @@
+
+#
+# Used by the LiveAST test suite.
+#
+module LiveAST::RubyParser::Test
+  class << self
+    #
+    # Whether this is Ryan Davis's unified sexp format.
+    #
+    def unified_sexp?
+      true
+    end
+
+    #
+    # Whether the unparser output matches that of ruby2ruby.
+    #
+    def unparser_matches_ruby2ruby?
+      true
+    end
+  end
+
+  #
+  # no_arg_def(:f, "A#f") returns the ast of
+  #
+  #   def f
+  #     "A#f"
+  #   end
+  #
+  def no_arg_def(name, ret)
+    s(:defn, name, s(:args), s(:str, ret))
+  end
+
+  #
+  # singleton_no_arg_def(:f, "foo") returns the ast of
+  #
+  #   def self.f
+  #     "foo"
+  #   end
+  #
+  def singleton_no_arg_def(name, ret)
+    s(:defs, s(:self), name, s(:args), s(:str, ret))
+  end
+
+  #
+  # no_arg_def_return(no_arg_def(:f, "A#f")) == "A#f"
+  #
+  def no_arg_def_return(ast)
+    ast[3][1]
+  end
+
+  #
+  # binop_def(:f, :+) returns the ast of
+  #
+  #   def f(x, y)
+  #     x + y
+  #   end
+  #
+  def binop_def(name, op)
+    s(:defn,
+      name,
+      s(:args, :x, :y),
+      s(:call, s(:lvar, :x), op, s(:lvar, :y)))
+  end
+
+  #
+  # singleton_binop_def(:A, :f, :+) returns the ast of
+  #
+  #   def A.f(x, y)
+  #     x + y
+  #   end
+  #
+  def singleton_binop_def(const, name, op)
+    s(:defs,
+      s(:const, const),
+      name,
+      s(:args, :x, :y),
+      s(:call, s(:lvar, :x), op, s(:lvar, :y)))
+  end
+
+  #
+  # binop_define_method(:f, :*) returns the ast of
+  #
+  #   define_method :f do |x, y|
+  #     x * y
+  #   end
+  #
+  # binop_define_method(:f, :-, :my_def) returns the ast of
+  #
+  #   my_def :f do |x, y|
+  #     x - y
+  #   end
+  #
+  def binop_define_method(name, op, using = :define_method)
+    s(:iter,
+      s(:call, nil, using, s(:lit, name)),
+      s(:args, :x, :y),
+      s(:call, s(:lvar, :x), op, s(:lvar, :y)))
+  end
+
+  #
+  # binop_define_method_with_var(:method_name, :/) returns the ast of
+  #
+  #   define_method method_name do |x, y|
+  #     x / y
+  #   end
+  #
+  def binop_define_method_with_var(var_name, op)
+    s(:iter,
+      s(:call, nil, :define_method, s(:lvar, var_name)),
+      s(:args, :x, :y),
+      s(:call, s(:lvar, :x), op, s(:lvar, :y)))
+  end
+
+  #
+  # binop_define_singleton_method(:f, :+, :a) returns the ast of
+  #
+  #   a.define_singleton_method :f do |x, y|
+  #     x + y
+  #   end
+  #
+  def binop_define_singleton_method(name, op, receiver)
+    s(:iter,
+      s(:call, s(:lvar, receiver), :define_singleton_method,
+        s(:lit, name)),
+      s(:args, :x, :y),
+      s(:call, s(:lvar, :x), op, s(:lvar, :y)))
+  end
+  
+  #
+  # no_arg_block(:foo, "bar") returns the ast of
+  #
+  #   foo { "bar" }
+  #
+  def no_arg_block(name, ret)
+    s(:iter, s(:call, nil, name), s(:args), s(:str, ret))
+  end
+  
+  #
+  # binop_block(:foo, :+) returns the ast of
+  #
+  #   foo { |x, y| x + y }
+  #
+  def binop_block(name, op)
+    s(:iter,
+      s(:call, nil, name),
+      s(:args, :x, :y),
+      s(:call, s(:lvar, :x), op, s(:lvar, :y)))
+  end
+
+  #
+  # binop_proc_new(:*) returns the ast of
+  #
+  #   Proc.new { |x, y| x * y }
+  #
+  def binop_proc_new(op)
+    s(:iter,
+      s(:call, s(:const, :Proc), :new),
+      s(:args, :x, :y),
+      s(:call, s(:lvar, :x), op, s(:lvar, :y)))
+  end
+
+  #
+  # nested_lambdas("foo") returns the ast of
+  #
+  #   lambda {
+  #     lambda {
+  #       "foo"
+  #     }
+  #   }
+  #  
+  def nested_lambdas(str)
+    s(:iter,
+      s(:call, nil, :lambda),
+      s(:args),
+      s(:iter, s(:call, nil, :lambda), s(:args), s(:str, str)))
+  end
+
+  # nested_defs(:f, :g, "foo") returns the ast of
+  #
+  #   def f
+  #     Class.new do
+  #       def g
+  #         "foo"
+  #       end
+  #     end
+  #   end
+  #   
+  def nested_defs(u, v, str)
+    s(:defn,
+      u,
+      s(:args),
+      s(:iter,
+        s(:call, s(:const, :Class), :new),
+        s(:args),
+        s(:defn, v, s(:args), s(:str, str))))
+  end
+end

data/lib/live_ast/ruby_parser/unparser.rb

@@ -0,0 +1,13 @@
+require 'ruby2ruby'
+
+#
+# Used by +to_ruby+ in LiveAST.
+#
+module LiveAST::RubyParser::Unparser
+  #
+  # Return a ruby source string which reflects the given AST.
+  #
+  def self.unparse(sexp)
+    Ruby2Ruby.new.process(sexp)
+  end
+end

data/lib/live_ast/to_ast.rb

@@ -0,0 +1,26 @@
+require 'live_ast/base'
+
+[Method, UnboundMethod].each do |klass|
+  klass.class_eval do
+    def to_ast #:nodoc:
+      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
+
+class Method
+  # :method: to_ast
+  # Extract the AST of this object.
+end
+
+class UnboundMethod
+  # :method: to_ast
+  # Extract the AST of this object.
+end