utils 0.2.4 → 0.6.4

data/lib/utils/irb.rb

@@ -1,30 +1,60 @@
 require 'tins/xt'
 require 'irb/completion'
 require 'enumerator'
+require 'tempfile'
 require 'pp'
 require_maybe 'ap'
 if Readline.respond_to?(:point) && Readline.respond_to?(:line_buffer)
   require 'pry-editline'
 end
 require 'utils'
-require 'drb'
 
 $editor = Utils::Editor.new
 $pager = ENV['PAGER'] || 'less -r'
 
 module Utils
   module IRB
+    require 'utils/irb/service'
 
     module Shell
       require 'fileutils'
       include FileUtils
       include Tins::Find
 
+      def receiver_unless_main(method, &block)
+        receiver_name = method.receiver.to_s
+        if receiver_name != 'main'
+          if block
+            block.(receiver_name)
+          else
+            receiver_name
+          end
+        end
+      end
+      private :receiver_unless_main
+
       # Start _ri_ for +pattern+. If +pattern+ is not string like, call it with
       # pattern.class.name as argument.
-      def ri(*patterns)
-        patterns.map! { |p| p.respond_to?(:to_str) ? p.to_str : p.class.name }
-        system "ri #{patterns.map { |p| "'#{p}'" } * ' '} | #{$pager}"
+      def ri(*patterns, doc: 'ri')
+        patterns.empty? and
+          receiver_unless_main(method(__method__)) do |pattern|
+          return ri(pattern, doc: doc)
+        end
+        patterns.map! { |p|
+          case
+          when Module === p
+            p.name
+          when p.respond_to?(:to_str)
+            p.to_str
+          else
+            p.class.name
+          end
+        }
+        system "#{doc} #{patterns.map { |p| "'#{p}'" } * ' ' } | #$pager"
+      end
+
+      def yri(*patterns)
+        ri *patterns, doc: 'yri'
       end
 
       # Restart this irb.
@@ -32,53 +62,70 @@ module Utils
         exec $0
       end
 
+      def irb_open(url = nil, &block)
+        case
+        when url
+          system 'open', url
+        when block
+          Tempfile.open('wb') do |t|
+            t.write capture_output(&block)
+            t.rewind
+            system 'open', t.path
+          end
+        when url = receiver_unless_main(method(__method__))
+          irb_open url
+        else
+          raise ArgumentError, 'need an url or block'
+        end
+      end
+
       # Start an irb server.
-      def irb_server(hostname = nil, port = nil)
-        Utils::IRB::Service.start(hostname, port) {}
+      def irb_server(uri = nil)
+        Utils::IRB::Service.start(uri) {}
       end
 
       # Connect to an irb server.
-      def irb_connect(hostname = nil, port = nil)
-        Utils::IRB::Service.connect(hostname, port)
+      def irb_connect(uri = nil)
+        Utils::IRB::Service.connect(uri)
       end
 
       # TODO: change the API of this stuff
 
       # Return all instance methods of obj's class.
-      def irb_all_class_instance_methods(obj)
+      def irb_all_class_instance_methods(obj = self)
         methods = obj.class.instance_methods
         irb_wrap_methods obj, methods
       end
 
       # Return instance methods of obj's class without the inherited/mixed in
       # methods.
-      def irb_class_instance_methods(obj)
+      def irb_class_instance_methods(obj = self)
         methods = obj.class.instance_methods(false)
         irb_wrap_methods obj, methods
       end
 
       # Return all instance methods defined in module modul.
-      def irb_all_instance_methods(modul)
+      def irb_all_instance_methods(modul = self)
         methods = modul.instance_methods
         irb_wrap_methods modul, methods, true
       end
 
       # Return instance methods defined in module modul without the inherited/mixed
       # in methods.
-      def irb_instance_methods(modul)
+      def irb_instance_methods(modul = self)
         methods = modul.instance_methods(false)
         irb_wrap_methods modul, methods, true
       end
 
       # Return all methods of obj (including obj's eigenmethods.)
-      def irb_all_methods(obj)
+      def irb_all_methods(obj = self)
         methods = obj.methods
         irb_wrap_methods obj, methods
       end
 
       # Return instance methods of obj's class without the inherited/mixed in
       # methods, but including obj's eigenmethods.
-      def irb_methods(obj)
+      def irb_methods(obj = self)
         methods = obj.class.ancestors[1..-1].inject(obj.methods) do |all, a|
           all -= a.instance_methods
         end
@@ -86,23 +133,16 @@ module Utils
       end
 
       # Return all eigen methods of obj.
-      def irb_eigen_methods(obj)
+      def irb_eigen_methods(obj = self)
         irb_wrap_methods obj, obj.methods(false)
       end
 
-      def irb_wrap_methods(obj, methods, modul = false)
+      def irb_wrap_methods(obj = self, methods = methods(), modul = false)
         methods.map do |name|
           MethodWrapper.new(obj, name, modul) rescue nil
         end.compact.sort!
       end
 
-      def irb_clipboard
-        case RUBY_PLATFORM
-        when /darwin/
-          'reattach-to-user-namespace pbcopy'
-        end
-      end
-
       class WrapperBase
         include Comparable
 
@@ -147,7 +187,7 @@ module Utils
         def initialize(obj, name, modul)
           super(name)
           @method = modul ? obj.instance_method(name) : obj.method(name)
-          @description = "#{owner}##@name(#{arity})"
+          @description = @method.description(style: :namespace)
         end
 
         attr_reader :method
@@ -180,12 +220,12 @@ module Utils
       end
 
       # Return all the constants defined in +modul+.
-      def irb_constants(modul)
+      def irb_constants(modul = self)
         modul.constants.map { |c| ConstantWrapper.new(modul.const_get(c), c) }.sort
       end
 
       # Return all the subclasses of +klass+. TODO implement subclasses w/out rails
-      def irb_subclasses(klass)
+      def irb_subclasses(klass = self)
         klass.subclasses.map { |c| ConstantWrapper.new(eval(c), c) }.sort
       end
 
@@ -193,76 +233,7 @@ module Utils
         Infinity = 1.0 / 0 # I like to define the infinite.
       end
 
-      # Output all kinds of information about +obj+. If detailed is given output
-      # details about the methods (+ arity) in inheritance chain of +obj+ as well.
-      # * detailed as 0 output instance methods only of part 0 (the first) of the
-      #   chain.
-      # * detailed as 1..2 output instance methods of +obj+ inherited from parts 1
-      #   and 2 of the the chain.
-      def irb_info(obj, detailed = nil)
-        if Module === obj
-          modul = obj
-          klassp = Class === modul
-          if klassp
-            begin
-              allocated = modul.allocate
-            rescue TypeError
-            else
-              obj = allocated
-            end
-          end
-        else
-          modul = obj.class
-        end
-        inspected = obj.inspect
-        puts "obj = #{inspected.size > 40 ? inspected[0, 40] + '...' : inspected} is of class #{obj.class}."
-        am = irb_all_methods(obj).size
-        ms = irb_methods(obj).size
-        ems = irb_eigen_methods(obj).size
-        puts "obj: #{am} methods, #{ms} only local#{ems > 0 ? " (#{ems} eigenmethods),": ','} #{am - ms} inherited/mixed in."
-        acim = irb_all_class_instance_methods(obj).size
-        cim = irb_class_instance_methods(obj).size
-        puts "obj: #{acim} instance methods, #{cim} local, #{acim - cim} only inherited/mixed in."
-        if klassp
-          s = modul.superclass
-          puts "Superclass of #{modul}: #{s}"
-        end
-        a = []
-        ec = true
-        begin
-          a << (class << obj; self; end)
-        rescue TypeError
-          ec = false
-        end
-        a.concat modul.ancestors
-        if ec
-          puts "Ancestors of #{modul}: (#{a[0]},) #{a[1..-1].map { |k| "#{k}#{k == s ? '*' : ''}" } * ', '}"
-        else
-          puts "Ancestors of #{modul}: #{a[0..-1].map { |k| "#{k}#{k == s ? '*' : ''}" } * ', '}"
-        end
-        if Class === modul and detailed
-          if detailed.respond_to? :to_int
-            detailed = detailed..detailed
-          end
-          detailed.each do |i|
-            break if i >= a.size
-            k = a[i]
-            puts "#{k}:"
-            puts irb_wrap_methods(obj, k.instance_methods(false)).sort
-          end
-        end
-        nil
-      end
-
-      # Output *all* the irb_info about +obj+. You may need to buy a bigger screen for
-      # this or use:
-      #  less { irb_fullinfo object }
-      def irb_fullinfo(obj)
-        irb_info obj, 0..Infinity
-      end
-
       def capture_output(with_stderr = false)
-        return "missing block" unless block_given?
         require 'tempfile'
         begin
           old_stdout, $stdout = $stdout, Tempfile.new('irb')
@@ -319,8 +290,12 @@ module Utils
         end
       end
 
-      def irb_write(filename, text = nil)
-        File.secure_write filename, text, 'wb'
+      def irb_write(filename, text = nil, &block)
+        if text.nil? && block
+          File.secure_write filename, nil, 'wb', &block
+        else
+          File.secure_write filename, text, 'wb'
+        end
       end
 
       def irb_read(filename, chunk_size = 8_192)
@@ -367,6 +342,10 @@ module Utils
         $editor.full?(:edit, *files)
       end
 
+      def edit
+        $editor.full?(:edit, self)
+      end
+
       # List contents of directory
       def ls(*args)
         puts `ls #{args.map { |x| "'#{x}'" } * ' '}`
@@ -388,25 +367,6 @@ module Utils
       end
     end
 
-    module Module
-      # Start +ri+ for +module#pattern+, trying to find a method matching +pattern+
-      # for all modules in the ancestors chain of this module.
-      def ri(pattern = nil)
-        if pattern
-          pattern = pattern.to_sym.to_s if pattern.respond_to? :to_sym
-          ancestors.each do |a|
-            if method = a.instance_methods(false).find { |m| pattern === m }
-              a = Object if a == Kernel # ri seems to be confused
-              system "ri #{a}##{method} | #{$pager}"
-            end
-          end
-        else
-          system "ri #{self} | #{$pager}"
-        end
-        return
-      end
-    end
-
     module Regexp
       # Show the match of this Regexp on the +string+.
       def show_match(string)
@@ -430,59 +390,6 @@ module Utils
       end
     end
 
-    module Relation
-      def explain
-        connection.select_all("EXPLAIN #{to_sql}")
-      end
-    end
-
-    module Service
-      class << self
-        attr_accessor :hostname
-
-        attr_accessor :port
-
-        def start(hostname = nil, port = nil, &block)
-          hostname ||= self.hostname
-          port     ||= self.port
-          block    ||= proc {}
-          uri = "druby://#{hostname}:#{port}"
-          puts "Starting IRB server listening to #{uri.inspect}."
-          DRb.start_service(uri, eval('irb_current_working_binding', block.binding))
-        end
-
-        def connect(hostname = nil, port = nil)
-          hostname ||= self.hostname
-          port     ||= self.port
-          uri = "druby://#{hostname}:#{port}"
-          irb = DRbObject.new_with_uri(uri)
-          Proxy.new(irb)
-        end
-      end
-
-      self.hostname = 'localhost'
-
-      self.port = 6642
-
-      class Proxy
-        def initialize(irb)
-          @irb = irb
-        end
-
-        def eval(code)
-          @irb.conf.workspace.evaluate nil, code
-        end
-
-        def load(filename)
-          unless filename.start_with?('/')
-            filename = File.expand_path filename
-          end
-          @irb.load filename
-        end
-      end
-
-    end
-
     def self.configure
       ::IRB.conf[:SAVE_HISTORY] = 1000
       if ::IRB.conf[:PROMPT]
@@ -501,12 +408,11 @@ end
 
 Utils::IRB.configure
 
-
 module IRB
   class Context
     def init_save_history
-      unless (class<<@io;self;end).include?(HistorySavingAbility)
-        @io.extend(HistorySavingAbility)
+      unless @io.singleton_class < HistorySavingAbility
+        @io.extend HistorySavingAbility
       end
     end
 
@@ -568,12 +474,6 @@ module IRB
   end
 end
 
-if defined?(ActiveRecord::Relation) && !ActiveRecord::Relation.method_defined?(:examine)
-  class ActiveRecord::Relation
-    include Utils::IRB::Relation
-  end
-end
-
 class String
   include Utils::IRB::String
 end
@@ -582,10 +482,6 @@ class Object
   include Utils::IRB::Shell
 end
 
-class Module
-  include Utils::IRB::Module
-end
-
 class Regexp
   include Utils::IRB::Regexp
 end

data/lib/utils/irb/service.rb

@@ -0,0 +1,39 @@
+require 'drb'
+
+module Utils::IRB::Service
+  class << self
+    attr_accessor :hostname
+
+    attr_accessor :port
+
+    def start(uri = nil, &block)
+      uri ||= "druby://localhost:6642"
+      block    ||= proc {}
+      puts "Starting IRB server listening to #{uri.inspect}."
+      DRb.start_service(uri, eval('irb_current_working_binding', block.binding))
+    end
+
+    def connect(uri = nil)
+      uri ||= "druby://localhost:6642"
+      irb = DRbObject.new_with_uri(uri)
+      Proxy.new(irb)
+    end
+  end
+
+  class Proxy
+    def initialize(irb)
+      @irb = irb
+    end
+
+    def eval(code)
+      @irb.conf.workspace.evaluate nil, code
+    end
+
+    def load(filename)
+      unless filename.start_with?('/')
+        filename = File.expand_path filename
+      end
+      @irb.load filename
+    end
+  end
+end