akitaonrails-utility_belt 1.0.10

data/lib/utility_belt.rb

@@ -0,0 +1,22 @@
+# This started as my (Giles Bowkett's) .irbrc file, turned into a recipe on IRB for the Pragmatic Programmers,
+# and soon became a scrapbook of cool code snippets from all over the place. All the RDoc lives in the README.
+# Check that file for usage information, authorship, copyright, and extensive details. You can also find a
+# nice, HTMLified version of the README content at http://utilitybelt.rubyforge.org.
+
+UTILITY_BELT_IRB_STARTUP_PROCS = {} unless Object.const_defined? :UTILITY_BELT_IRB_STARTUP_PROCS
+
+%w{rubygems utility_belt/equipper}.each {|internal_library| require internal_library}
+
+if Object.const_defined? :IRB
+
+  # Called when the irb session is ready, after any external libraries have been loaded. This
+  # allows the user to specify which gadgets in the utility belt to equip. (Kind of pushing the
+  # metaphor, but hey, what the hell.)
+  IRB.conf[:IRB_RC] = lambda do
+    UtilityBelt.equip(:defaults) unless UtilityBelt.equipped?
+    UTILITY_BELT_IRB_STARTUP_PROCS.each {|symbol, proc| proc.call}
+  end
+  
+  # default: dark background
+  UtilityBelt::Themes.background(:dark) if defined? UtilityBelt::Themes
+end

data/lib/utility_belt/amazon_upload_shortcut.rb

@@ -0,0 +1,25 @@
+# S3 (http://amazon.rubyforge.org/)
+%w{aws/s3 cgi platform}.each {|lib| require lib}
+
+module UtilityBelt
+  module AmazonUploadShortcut
+    def aws_upload(bucket,filename)
+      AWS::S3::Base.establish_connection!(:access_key_id => ENV['AMAZON_ACCESS_KEY_ID'], 
+                                          :secret_access_key => ENV['AMAZON_SECRET_ACCESS_KEY'])
+      AWS::S3::S3Object.store(filename, open(filename), bucket, :access => :public_read)
+      url = "http://s3.amazonaws.com/#{bucket}/#{filename}".gsub(/ /, "%20")
+      Clipboard.write(url) if Clipboard.available?
+      url
+    end
+  end
+end
+    
+class Object
+  include UtilityBelt::AmazonUploadShortcut
+end if Object.const_defined? :IRB
+
+# a quick note: the "google" command uses CGI.escape, but the URLs produced by CGI.escape
+# don't seem to succeed here, in practice. this may differ by OS and/or browser. Let me
+# know if you see something weird -- the Utility Belt mailing list is here:
+#
+# http://rubyforge.org/mailman/listinfo/utilitybelt-tinkering

data/lib/utility_belt/clipboard.rb

@@ -0,0 +1,68 @@
+# original clipboard code: http://project.ioni.st/post/1334#snippet_1334
+# turned it into a class to make it flexxy:
+# http://gilesbowkett.blogspot.com/2007/09/improved-auto-pastie-irb-code.html
+# Extended to handle windows and linux as well
+require 'platform'
+
+module UtilityBelt
+  class Clipboard
+    
+    def self.available?
+      @@implemented || false
+    end
+    
+    case Platform::IMPL
+    when :macosx
+
+      def self.read
+        IO.popen('pbpaste') {|clipboard| clipboard.read}
+      end
+
+      def self.write(stuff)
+        IO.popen('pbcopy', 'w+') {|clipboard| clipboard.write(stuff)}
+      end
+      @@implemented = true
+  
+    when :mswin
+
+      begin
+        # Try loading the win32-clipboard gem
+        require 'win32/clipboard'
+
+        def self.read
+          Win32::Clipboard.data
+        end
+
+        def self.write(stuff)
+          Win32::Clipboard.set_data(stuff)
+        end
+        @@implemented = true
+
+      rescue LoadError
+        raise "You need the win32-clipboard gem for clipboard functionality!"
+      end
+
+    when :linux
+      #test execute xsel
+      `xsel`
+      if $?.exitstatus != 0
+        raise "You need to install xsel for clipboard functionality!"
+      end
+
+      def self.read
+        `xsel`
+      end
+      
+      def self.write(stuff)
+        `echo '#{stuff}' | xsel -i`
+      end
+      @@implemented = true
+
+    else
+      raise "No suitable clipboard implementation for your platform found!"
+    end
+    
+  end
+end
+
+Clipboard = UtilityBelt::Clipboard if Object.const_defined? :IRB

data/lib/utility_belt/command_history.rb

@@ -0,0 +1,129 @@
+# history
+# http://blog.bleything.net/pages
+# http://gilesbowkett.blogspot.com/2007/06/irbrc-modifications.html
+# Ben's history stuff, slightly modified, plus hvi method
+
+
+
+# Adds shell-style history display and replay to irb.  The magic happens in
+# the h, h!, and hw methods.
+#
+# == Authors
+#
+# * Ben Bleything <ben@bleything.net>
+#
+# == Copyright
+#
+# Copyright (c) 2007 Ben Bleything
+#
+# This code released under the terms of the BSD license.
+#
+# == Version
+#
+#  $Id: history.rb 50 2007-07-30 18:55:09Z ben $
+#
+
+require 'tempfile'
+
+class Object
+  def history(how_many = 50)
+    history_size = Readline::HISTORY.size
+    # no lines, get out of here
+    puts "No history" and return if history_size == 0
+    start_index = 0
+    # not enough lines, only show what we have
+    if history_size <= how_many
+      how_many  = history_size - 1
+      end_index = how_many
+    else
+      end_index = history_size - 1 # -1 to adjust for array offset
+      start_index = end_index - how_many 
+    end
+    start_index.upto(end_index) {|i| print_line i}
+  end
+  alias :h  :history
+
+  # -2 because -1 is ourself
+  def history_do(lines = (Readline::HISTORY.size - 2))
+    irb_eval lines
+  end 
+  alias :h! :history_do
+
+  def history_write(filename, lines)
+    file = File.open(filename, 'w')
+    get_lines(lines).each do |l|
+      file << "#{l}\n"
+    end
+    file.close
+  end
+  
+  # hack to handle JRuby bug
+  def handling_jruby_bug(&block)
+    if RUBY_PLATFORM =~ /java/
+      puts "JRuby IRB has a bug which prevents successful IRB vi interoperation."
+      puts "The JRuby team is aware of this and working on it."
+      puts "(http://jira.codehaus.org/browse/JRUBY-2049)"
+    else
+      yield
+    end
+  end
+
+  # TODO: history_write should go to a file, or the clipboard, or a file which opens in an application
+  def history_to_vi
+    handling_jruby_bug do
+      file = Tempfile.new("irb_tempfile")
+      get_lines(0..(Readline::HISTORY.size - 1)).each do |line|
+        file << "#{line}\n"
+      end
+      file.close
+      system("vim #{file.path}")
+    end
+  end
+  alias :hvi :history_to_vi
+
+  def history_to_textmate
+    handling_jruby_bug do
+      file = Tempfile.new("irb_tempfile")
+      get_lines(0..(Readline::HISTORY.size - 1)).each do |line|
+        file << "#{line}\n"
+      end
+      file.close
+      system("mate #{file.path}")
+    end
+  end
+  alias :hmate :history_to_textmate
+
+  def clear_history()
+    while true
+      Readline::HISTORY.delete_at(0) 
+    end
+  rescue IndexError
+  end
+
+  private
+  def get_line(line_number)
+    Readline::HISTORY[line_number] rescue ""
+  end
+
+  def get_lines(lines = [])
+    return [get_line(lines)] if lines.is_a? Fixnum
+    out = []
+    lines = lines.to_a if lines.is_a? Range
+    lines.each do |l|
+      out << Readline::HISTORY[l] rescue IndexError
+    end
+    out
+  end
+
+  def print_line(line_number, show_line_numbers = true)
+    print line_number.to_s + ": " if show_line_numbers
+    puts get_line(line_number)
+  end
+
+  def irb_eval(lines)
+    to_eval = get_lines(lines)
+    to_eval.each {|l| Readline::HISTORY << l}
+    eval to_eval.join("\n")
+  end
+end
+

data/lib/utility_belt/convertable_to_file.rb

@@ -0,0 +1,34 @@
+require 'tempfile'
+
+# This module adds a method, #to_file, which dumps the contents of self into a
+# temp file and then returns the path of that file.  This is particularly useful
+# when calling out to shell commands which expect their input in the form of
+# files.
+#
+# Example: use UNIX 'diff' to compare two objects:
+#
+#    >> a = ["foo", "bar", "baz"].join("\n")
+#    => "foo\nbar\nbaz"
+#    >> b = ["foo", "buz", "baz"].join("\n")
+#    => "foo\nbuz\nbaz"
+#    >> puts `diff #{a.to_file} #{b.to_file}`
+#    2c2
+#    < bar
+#    ---
+#    > buz
+#    => nil
+#
+module ConvertableToFile
+  def to_file
+    path = nil
+    Tempfile.open(object_id.to_s) do |tempfile|
+      tempfile << self
+      path = tempfile.path
+    end
+    path
+  end
+end
+
+class Object
+  include ConvertableToFile
+end

data/lib/utility_belt/equipper.rb

@@ -0,0 +1,71 @@
+# Allow to select which gadgets to equip
+#
+# Author: Markus Prinz <markus.prinz@qsig.org>
+
+module UtilityBelt
+  class << self
+    def equip(*args)
+      Equipper.equip(*args)
+    end
+    def equipped?
+      Equipper.equipped?
+    end
+  end
+  module Equipper
+    GADGETS = Dir[File.join(File.dirname(__FILE__), '*.rb')].map{|file| File.basename(file)[0..-4]}.reject{|gadget| "equipper" == gadget }
+
+    DEFAULTS = %w{wirble
+                  hash_math
+                  interactive_editor
+                  irb_options
+                  irb_verbosity_control}
+
+    @equipped = false
+
+    class << self
+      def equip(*args)
+        return if args.empty?
+
+        gadgets_to_equip = []
+
+        # Special case using :all or :none
+        if args[0].is_a?(Symbol) && [:all, :none, :defaults].include?(args[0])
+          what = args[0]
+
+          unless args[1].nil?
+            exceptions = args[1].has_key?(:except) ? args[1][:except] : []
+
+            # Handle special case where we get a string or a symbol instead of an array
+            exceptions = exceptions.to_s.to_a unless exceptions.is_a?( Array )
+          else
+            exceptions = []
+          end
+
+          case what
+          when :all
+            gadgets_to_equip.push(*(GADGETS - exceptions))
+          when :none
+            gadgets_to_equip.push(*exceptions)
+          when :defaults
+            gadgets_to_equip.push(*DEFAULTS)
+          end
+        # otherwise, args is a list of gadgets to equip
+        else
+          args.each do |arg|
+            gadget = arg.to_s
+
+            # Silently ignore unkown gadgets
+            gadgets_to_equip << gadget if GADGETS.include? gadget
+          end
+        end
+
+        gadgets_to_equip.each{|gadget| require "utility_belt/#{gadget}" }
+
+        @equipped ||= true
+      end
+      def equipped?
+        @equipped
+      end
+    end
+  end
+end

data/lib/utility_belt/google.rb

@@ -0,0 +1,26 @@
+#!/usr/bin/env ruby
+%w{rubygems platform cgi}.each {|library| require library}
+
+UtilityBelt.equip(:clipboard)
+UtilityBelt.equip(:webbrowser)
+
+module UtilityBelt
+  module Google
+    def google(search_term = nil)
+      search_term ||= Clipboard.read if Clipboard.available?
+      if search_term.empty?
+        puts "Usage: google search_term_without_spaces           (Unix command line only)"
+        puts "       google 'search term with spaces'            (Unix or IRB)"
+        puts "       google                                      (Unix or IRB)"
+        puts "              (if invoking without args, must have text in clipboard)"
+      else
+        url = "http://google.com/search?q=#{CGI.escape(search_term)}"
+        WebBrowser.open(url)
+      end
+    end
+  end
+end
+
+class Object
+  include UtilityBelt::Google
+end if Object.const_defined? :IRB

data/lib/utility_belt/hash_math.rb

@@ -0,0 +1,13 @@
+class Hash
+  alias :+ :merge
+  def -(thing_to_be_deleted)
+    if thing_to_be_deleted.is_a? Hash
+      thing_to_be_deleted.each do |key, value|
+        self.delete(key) if self[key] == value
+      end
+    elsif self.keys.include? thing_to_be_deleted
+      self.delete(thing_to_be_deleted)
+    end
+    self
+  end
+end

data/lib/utility_belt/interactive_editor.rb

@@ -0,0 +1,81 @@
+# Giles Bowkett, Greg Brown, and several audience members from Giles' Ruby East presentation.
+require 'tempfile'
+class InteractiveEditor
+  DEBIAN_SENSIBLE_EDITOR = "/usr/bin/sensible-editor"
+  MACOSX_OPEN_CMD        = "open"
+  XDG_OPEN               = "/usr/bin/xdg-open"
+
+  def self.sensible_editor
+    return ENV["VISUAL"] if ENV["VISUAL"]
+    return ENV["EDITOR"] if ENV["EDITOR"]
+    return MACOSX_OPEN_CMD if Platform::IMPL == :macosx
+    if Platform::IMPL == :linux
+      if File.executable?(XDG_OPEN)
+        return XDG_OPEN
+      end
+      if File.executable?(DEBIAN_SENSIBLE_EDITOR)
+        return DEBIAN_SENSIBLE_EDITOR
+      end
+    end
+    raise "Could not determine what editor to use.  Please specify."
+  end
+
+  attr_accessor :editor
+  def initialize(editor = :vim)
+    @editor = editor.to_s
+    if @editor == "mate"
+      @editor = "mate -w"
+    elsif @editor == "vim"
+      @editor = 'vim -c ":set ft=ruby"'
+    end
+  end
+  def edit_interactively
+    unless @file
+      @file = Tempfile.new("irb_tempfile")
+    end
+    system("#{@editor} #{@file.path}")
+    Object.class_eval(File.read(@file.path).gsub("\r", "\n"))
+    rescue Exception => error
+      puts @file.path
+      puts error
+  end
+end
+
+module InteractiveEditing
+  def edit_interactively(editor = InteractiveEditor.sensible_editor)
+    unless IRB.conf[:interactive_editors] && IRB.conf[:interactive_editors][editor]
+      IRB.conf[:interactive_editors] ||= {}
+      IRB.conf[:interactive_editors][editor] = InteractiveEditor.new(editor)
+    end
+    IRB.conf[:interactive_editors][editor].edit_interactively
+  end
+  
+  def handling_jruby_bug(&block)
+    if RUBY_PLATFORM =~ /java/
+      puts "JRuby IRB has a bug which prevents successful IRB vi/emacs editing."
+      puts "The JRuby team is aware of this and working on it. But it might be unfixable."
+      puts "(http://jira.codehaus.org/browse/JRUBY-2049)"
+    else
+      yield
+    end
+  end
+
+  def vi
+    handling_jruby_bug {edit_interactively(:vim)}
+  end
+
+  def mate
+    edit_interactively(:mate)
+  end
+
+  # TODO: Hardcore Emacs users use emacsclient or gnuclient to open documents in
+  # their existing sessions, rather than starting a brand new Emacs process.
+  def emacs
+    handling_jruby_bug {edit_interactively(:emacs)}
+  end
+end
+
+# Since we only intend to use this from the IRB command line, I see no reason to
+# extend the entire Object class with this module when we can just extend the
+# IRB main object.
+self.extend InteractiveEditing if Object.const_defined? :IRB