mvz-live_ast 1.1.1 → 1.1.2

data/lib/live_ast/common.rb

@@ -2,36 +2,37 @@
 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,
-          RUBY_VERSION < "2.0.0" ?
-          "can't convert #{thing.inspect} into String" :
-          "no implicit conversion of #{thing.inspect} into String"
-      end
+      arg.to_str
+    rescue NameError
+      thing = arg.nil? ? nil : arg.class
+
+      message = if RUBY_VERSION < "2.0.0"
+                  "can't convert #{thing.inspect} into String"
+                else
+                  "no implicit conversion of #{thing.inspect} into String"
+                end
+      raise TypeError, message
     end
 
     def check_arity(args, range)
-      unless range.include? args.size
-        range = 0 if range == (0..0)
+      return if range.include? args.size
 
-        raise ArgumentError,
+      range = 0 if range == (0..0)
+
+      raise ArgumentError,
         "wrong number of arguments (#{args.size} for #{range})"
-      end
     end
 
     def check_is_binding(obj)
-      unless obj.is_a? Binding
-        raise TypeError,
-          RUBY_VERSION < "2.1.0" ?
-          "wrong argument type #{obj.class} (expected Binding)" :
-          "wrong argument type #{obj.class} (expected binding)"
-      end
+      return if obj.is_a? Binding
+      message = if RUBY_VERSION < "2.1.0"
+                  "wrong argument type #{obj.class} (expected Binding)"
+                else
+                  "wrong argument type #{obj.class} (expected binding)"
+                end
+      raise TypeError, message
     end
 
     def location_for_eval(*args)

data/lib/live_ast/error.rb

@@ -1,8 +1,8 @@
 module LiveAST
   class MultipleDefinitionsOnSameLineError < ScriptError
     def message
-      "AST requested for a method or block that shares a line " <<
-      "with another method or block."
+      "AST requested for a method or block that shares a line " \
+        "with another method or block."
     end
   end
 

data/lib/live_ast/irb_spy.rb

@@ -9,7 +9,7 @@ module LiveAST
       def code_at(line)
         unless @history
           raise NotImplementedError,
-          "LiveAST cannot access history for this IRB input method"
+            "LiveAST cannot access history for this IRB input method"
         end
         grow = 0
         begin
@@ -27,16 +27,14 @@ module LiveAST
 end
 
 [
- defined?(IRB::StdioInputMethod) ? IRB::StdioInputMethod : nil,
- defined?(IRB::ReadlineInputMethod) ? IRB::ReadlineInputMethod : nil,
+  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
+        LiveAST::IRBSpy.history = @line if defined?(@line)
       end
     end
   end

data/lib/live_ast/linker.rb

@@ -15,31 +15,31 @@ 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@"
 
@@ -80,9 +80,9 @@ module LiveAST
 
       def fetch_from_cache(file, line)
         cache = @caches[file]
-        if !cache and !file.index(REVISION_TOKEN)
+        if !cache && !file.index(REVISION_TOKEN)
           _, cache =
-            if defined?(IRB) and file == "(irb)"
+            if defined?(IRB) && file == "(irb)"
               new_cache(IRBSpy.code_at(line), file, line, false)
             else
               #

data/lib/live_ast/loader.rb

@@ -6,29 +6,29 @@ module LiveAST
 
         # 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

data/lib/live_ast/reader.rb

@@ -5,8 +5,8 @@ module LiveAST
     MAGIC_COMMENT = /\A(?:#!.*?\n)?\s*\#.*(?:en)?coding\s*[:=]\s*([^\s;]+)/
 
     def self.read(file)
-      contents = File.read(file, :encoding => "BINARY")
-      
+      contents = File.read(file, encoding: "BINARY")
+
       utf8 = contents.sub!(UTF8_BOM, "") ? "UTF-8" : nil
 
       # magic comment overrides BOM

data/lib/live_ast/replace_eval.rb

@@ -29,51 +29,47 @@ module LiveAST
         Thread.current[:_live_ast_arg_cache] ||= {}
       end
 
+      private
+
       def handle_args(args)
         if RUBY_VERSION < '2.0.0'
-          if args.empty?
-            raise ArgumentError, "block not supplied"
-          end
+          handle_args_pre_20(args)
+        else
+          handle_args_20(args)
+        end
+      end
 
-          args[0] = Common.arg_to_str(args[0])
+      def handle_args_20(args)
+        LiveAST::Common.check_arity(args, 1..3)
+        args[0] = Common.arg_to_str(args[0])
+        args[1] = Common.arg_to_str(args[1]) if args.length > 1
+      end
 
-          unless (1..3).include? args.size
-            raise ArgumentError,
-              "wrong number of arguments: instance_eval(src) or instance_eval{..}"
-          end
-        else
-          LiveAST::Common.check_arity(args, 1..3)
-          args[0] = Common.arg_to_str(args[0])
+      def handle_args_pre_20(args)
+        raise ArgumentError, "block not supplied" if args.empty?
+
+        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]
+
+        args[1] = Common.arg_to_str(args[1]) if args.length > 1
       end
     end
   end
-  
+
   # ensure the parser is loaded -- rubygems calls eval
   parser
 end
 
-# squelch alias warnings
-prev_verbose = $VERBOSE
-$VERBOSE = nil
-
+# Override for Kernel#eval and Kernel.eval
 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)
@@ -85,6 +81,7 @@ module Kernel
   end
 end
 
+# Override for Binding#eval
 class Binding
   alias_method :live_ast_original_binding_eval, :eval
 
@@ -93,6 +90,7 @@ class Binding
   end
 end
 
+# Override for BasicObject#instance_eval
 class BasicObject
   alias_method :live_ast_original_instance_eval, :instance_eval
 
@@ -106,6 +104,7 @@ class BasicObject
   end
 end
 
+# Overrides for Module#module_eval and Module#class_eval
 class Module
   alias_method :live_ast_original_module_eval, :module_eval
 
@@ -121,6 +120,3 @@ class Module
   remove_method :class_eval
   alias_method :class_eval, :module_eval
 end
-
-# unsquelch alias warnings
-$VERBOSE = prev_verbose

data/lib/live_ast/replace_load.rb

@@ -6,7 +6,7 @@ module Kernel
   def load(file, wrap = false)
     LiveAST.load(file, wrap)
   end
-  
+
   class << self
     remove_method :load
   end

data/lib/live_ast/ruby_parser.rb

@@ -1,32 +1,34 @@
 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)
+module LiveAST
+  class 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
 
-    sexp.each do |elem|
-      process(elem) if elem.is_a? Sexp
+    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
-  end
 
-  def store_sexp(sexp, line)
-    @defs[line] = @defs.has_key?(line) ? :multiple : sexp
+    def store_sexp(sexp, line)
+      @defs[line] = @defs.key?(line) ? :multiple : sexp
+    end
   end
 end
 

data/lib/live_ast/ruby_parser/test.rb

@@ -2,196 +2,200 @@
 #
 # 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
+module LiveAST
+  class RubyParser
+    module 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
+        #
+        # 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
+      #
+      # 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
+      #
+      # 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
+      #
+      # 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
+      #
+      # 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
+      #
+      # 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(: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_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_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
 
-  #
-  # 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
+      #
+      # 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
 
-  #
-  # 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
+      #
+      # 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_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))))
+      #
+      # 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
   end
 end