wirble-0.1.3/0000755000175000017500000000000011573730144012022 5ustar gwolfgwolfwirble-0.1.3/lib/0000755000175000017500000000000011573730144012570 5ustar gwolfgwolfwirble-0.1.3/lib/wirble.rb0000644000175000017500000003125611573730144014410 0ustar gwolfgwolfrequire 'ostruct' # # Wirble: A collection of useful Irb features. # # To use, add the following to your ~/.irbrc: # # require 'rubygems' # require 'wirble' # Wirble.init # # If you want color in Irb, add this to your ~/.irbrc as well: # # Wirble.colorize # # Note: I spent a fair amount of time documenting this code in the # README. If you've installed via RubyGems, root around your cache a # little bit (or fire up gem_server) and read it before you tear your # hair out sifting through the code below. # module Wirble VERSION = '0.1.3' # # Load internal Ruby features, including pp, tab-completion, # and a simple prompt. # module Internals # list of internal libraries to automatically load LIBRARIES = %w{pp irb/completion} # # load libraries # def self.init_libraries LIBRARIES.each do |lib| begin require lib rescue LoadError nil end end end # # Set a simple prompt, unless a custom one has been specified. # def self.init_prompt # set the prompt if IRB.conf[:PROMPT_MODE] == :DEFAULT IRB.conf[:PROMPT_MODE] = :SIMPLE end end # # Load all Ruby internal features. # def self.init(opt = nil) init_libraries unless opt && opt[:skip_libraries] init_prompt unless opt && opt[:skip_prompt] end end # # Basic IRB history support. This is based on the tips from # http://wiki.rubygarden.org/Ruby/page/show/Irb/TipsAndTricks # class History DEFAULTS = { :history_path => ENV['IRB_HISTORY_FILE'] || "~/.irb_history", :history_size => (ENV['IRB_HISTORY_SIZE'] || 1000).to_i, :history_perms => File::WRONLY | File::CREAT | File::TRUNC, } private def say(*args) puts(*args) if @verbose end def cfg(key) @opt["history_#{key}".intern] end def save_history path, max_size, perms = %w{path size perms}.map { |v| cfg(v) } # read lines from history, and truncate the list (if necessary) lines = Readline::HISTORY.to_a.uniq lines = lines[-max_size, -1] if lines.size > max_size # write the history file real_path = File.expand_path(path) File.open(real_path, perms) { |fh| fh.puts lines } say 'Saved %d lines to history file %s.' % [lines.size, path] end def load_history # expand history file and make sure it exists real_path = File.expand_path(cfg('path')) unless File.exist?(real_path) say "History file #{real_path} doesn't exist." return end # read lines from file and add them to history lines = File.readlines(real_path).map { |line| line.chomp } Readline::HISTORY.push(*lines) say 'Read %d lines from history file %s' % [lines.size, cfg('path')] end public def initialize(opt = nil) @opt = DEFAULTS.merge(opt || {}) return unless defined? Readline::HISTORY load_history Kernel.at_exit { save_history } end end # # Add color support to IRB. # module Colorize # # Tokenize an inspection string. # module Tokenizer def self.tokenize(str) raise 'missing block' unless block_given? chars = str.split(//) # $stderr.puts "DEBUG: chars = #{chars.join(',')}" state, val, i, lc = [], '', 0, nil while i <= chars.size repeat = false c = chars[i] # $stderr.puts "DEBUG: state = #{state}" case state[-1] when nil case c when ':' state << :symbol when '"' state << :string when '#' state << :object when /[a-z]/i state << :keyword repeat = true when /[0-9-]/ state << :number repeat = true when '{' yield :open_hash, '{' when '[' yield :open_array, '[' when ']' yield :close_array, ']' when '}' yield :close_hash, '}' when /\s/ yield :whitespace, c when ',' yield :comma, ',' when '>' yield :refers, '=>' if lc == '=' when '.' yield :range, '..' if lc == '.' when '=' # ignore these, they're used elsewhere nil else # $stderr.puts "DEBUG: ignoring char #{c}" end when :symbol case c # XXX: should have =, but that messes up foo=>bar when /[a-z0-9_!?]/ val << c else yield :symbol_prefix, ':' yield state[-1], val state.pop; val = '' repeat = true end when :string case c when '"' if lc == "\\" val[-1] = ?" else yield :open_string, '"' yield state[-1], val state.pop; val = '' yield :close_string, '"' end else val << c end when :keyword case c when /[a-z0-9_]/i val << c else # is this a class? st = val =~ /^[A-Z]/ ? :class : state[-1] yield st, val state.pop; val = '' repeat = true end when :number case c when /[0-9e-]/ val << c when '.' if lc == '.' val[/\.$/] = '' yield state[-1], val state.pop; val = '' yield :range, '..' else val << c end else yield state[-1], val state.pop; val = '' repeat = true end when :object case c when '<' yield :open_object, '#<' state << :object_class when ':' state << :object_addr when '@' state << :object_line when '>' yield :close_object, '>' state.pop; val = '' end when :object_class case c when ':' yield state[-1], val state.pop; val = '' repeat = true else val << c end when :object_addr case c when '>' when '@' yield :object_addr_prefix, ':' yield state[-1], val state.pop; val = '' repeat = true else val << c end when :object_line case c when '>' yield :object_line_prefix, '@' yield state[-1], val state.pop; val = '' repeat = true else val << c end else raise "unknown state #{state}" end unless repeat i += 1 lc = c end end end end # # Terminal escape codes for colors. # module Color COLORS = { :nothing => '0;0', :black => '0;30', :red => '0;31', :green => '0;32', :brown => '0;33', :blue => '0;34', :cyan => '0;36', :purple => '0;35', :light_gray => '0;37', :dark_gray => '1;30', :light_red => '1;31', :light_green => '1;32', :yellow => '1;33', :light_blue => '1;34', :light_cyan => '1;36', :light_purple => '1;35', :white => '1;37', } # # Return the escape code for a given color. # def self.escape(key) COLORS.key?(key) && "\033[#{COLORS[key]}m" end end # # Default Wirble color scheme. # DEFAULT_COLORS = { # delimiter colors :comma => :blue, :refers => :blue, # container colors (hash and array) :open_hash => :green, :close_hash => :green, :open_array => :green, :close_array => :green, # object colors :open_object => :light_red, :object_class => :white, :object_addr_prefix => :blue, :object_line_prefix => :blue, :close_object => :light_red, # symbol colors :symbol => :yellow, :symbol_prefix => :yellow, # string colors :open_string => :red, :string => :cyan, :close_string => :red, # misc colors :number => :cyan, :keyword => :green, :class => :light_green, :range => :red, } # # Fruity testing colors. # TESTING_COLORS = { :comma => :red, :refers => :red, :open_hash => :blue, :close_hash => :blue, :open_array => :green, :close_array => :green, :open_object => :light_red, :object_class => :light_green, :object_addr => :purple, :object_line => :light_purple, :close_object => :light_red, :symbol => :yellow, :symbol_prefix => :yellow, :number => :cyan, :string => :cyan, :keyword => :white, :range => :light_blue, } # # Set color map to hash # def self.colors=(hash) @colors = hash end # # Get current color map # def self.colors @colors ||= {}.update(DEFAULT_COLORS) end # # Return a string with the given color. # def self.colorize_string(str, color) col, nocol = [color, :nothing].map { |key| Color.escape(key) } col ? "#{col}#{str}#{nocol}" : str end # # Colorize the results of inspect # def self.colorize(str) begin ret, nocol = '', Color.escape(:nothing) Tokenizer.tokenize(str) do |tok, val| # c = Color.escape(colors[tok]) ret << colorize_string(val, colors[tok]) end ret rescue # catch any errors from the tokenizer (just in case) str end end # # Enable colorized IRB results. # def self.enable(custom_colors = nil) # if there's a better way to do this, I'm all ears. ::IRB::Irb.class_eval do alias :non_color_output_value :output_value def output_value if @context.inspect? val = Colorize.colorize(@context.last_value.inspect) printf @context.return_format, val else printf @context.return_format, @context.last_value end end end colors = custom_colors if custom_colors end # # Disable colorized IRB results. # def self.disable ::IRB::Irb.class_eval do alias :output_value :non_color_output_value end end end # # Convenient shortcut methods. # module Shortcuts # # Print object methods, sorted by name. (excluding methods that # exist in the class Object) . # def po(o) o.methods.sort - Object.methods end # # Print object constants, sorted by name. # def poc(o) o.constants.sort end end # # Convenient shortcut for ri # module RiShortcut def self.init Kernel.class_eval { def ri(arg) puts `ri '#{arg}'` end } Module.instance_eval { def ri(meth=nil) if meth if instance_methods(false).include? meth.to_s puts `ri #{self}##{meth}` else super end else puts `ri #{self}` end end } end end # # Enable color results. # def self.colorize(custom_colors = nil) Colorize.enable(custom_colors) end # # Load everything except color. # def self.init(opt = nil) # make sure opt isn't nil opt ||= {} # load internal irb/ruby features Internals.init(opt) unless opt && opt[:skip_internals] # load the history History.new(opt) unless opt && opt[:skip_history] # load shortcuts unless opt && opt[:skip_shortcuts] # load ri shortcuts RiShortcut.init # include common shortcuts Object.class_eval { include Shortcuts } end colorize(opt[:colors]) if opt && opt[:init_colors] end end wirble-0.1.3/Rakefile0000644000175000017500000000555011573730144013474 0ustar gwolfgwolf # load libraries require 'rake/rdoctask' require 'rake/packagetask' require 'rake/gempackagetask' require 'lib/wirble.rb' def package_info require 'ostruct' require 'rubygems' # create package ret = OpenStruct.new # set package information ret.name = 'Wirble' ret.blurb = 'Handful of common Irb features, made easy.' ret.description = <<-EOF A handful of useful Irb features, including colorized results, tab-completion, history, a simple prompt, and several helper methods, all rolled into one easy to use package. EOF ret.version = Wirble::VERSION ret.platform = Gem::Platform::RUBY ret.url = 'http://pablotron.org/software/wirble/' # author information ret.author_name = 'Paul Duncan' ret.author_email = 'pabs@pablotron.org' # requirements and files ret.reqs = ['none'] ret.include_files = Dir['**/*'].delete_if { |path| %w{CVS .svn .hg}.any? { |chunk| path.include?(chunk) } } # rdoc info ret.rdoc_title = "#{ret.name} #{ret.version} API Documentation" ret.rdoc_options = %w{--webcvs http://hg.pablotron.org/wirble} ret.rdoc_dir = 'doc' ret.rdoc_files = %w{lib/**/*.rb README} # runtime info ret.auto_require = 'wirble' ret.require_path = 'lib' ret.package_name = 'wirble' # package release dir if path = ENV['RAKE_PACKAGE_DIR'] ret.pkg_dir = File.join(File.expand_path(path), ret.package_name) end if files = ret.rdoc_files ret.rdoc_files = files.map { |e| Dir.glob(e) }.flatten.compact end # return package ret end pkg = package_info gem_spec = Gem::Specification.new do |s| # package information s.name = pkg.name.downcase s.platform = pkg.platform s.version = pkg.version s.summary = s.description = pkg.blurb s.rubyforge_project = 'pablotron' # files pkg.reqs.each { |req| s.requirements << req } s.files = pkg.include_files # runtime info s.executables = pkg.executables s.require_path = pkg.require_path s.autorequire = pkg.auto_require # dependencies # pkg.dependencies.each { |dep| s.add_dependency(dep) } # rdoc info s.has_rdoc = true s.rdoc_options = ['--title', pkg.rdoc_title] + pkg.rdoc_options + pkg.rdoc_files # author and project details s.author = pkg.author_name s.email = pkg.author_email s.homepage = pkg.url # gem crypto stuff if pkg.signing_key && pkg.signing_chain s.signing_key = pkg.signing_key s.signing_chain = pkg.signing_chain end end Rake::GemPackageTask.new(gem_spec) do |p| p.need_tar_gz = true # p.need_pgp_signature = true p.package_dir = pkg.pkg_dir if pkg.pkg_dir end Rake::RDocTask.new do |rd| rd.title = pkg.rdoc_title rd.rdoc_dir = pkg.rdoc_dir rd.rdoc_files.include(*pkg.rdoc_files) rd.options.concat(pkg.rdoc_options) end task :clean => [:clobber] task :release => [:clean, :package] wirble-0.1.3/README0000644000175000017500000003232611573730144012710 0ustar gwolfgwolfWirble 0.1.3 README =================== This document was last updated on 2009-05-30. See the file COPYING for licensing and warranty information. The latest version of this software is available at the following URL: http://pablotron.org/software/wirble/ Table of Contents ================= * Introduction to Wirble * Installing Wirble o Via RubyGems o Via a Tarball o As a User * Using Wirble o Editing Your ~/.irbrc o Enabling Color * Configuring Wirble * Color Settings o Color Keys o Color Values o Default Color Map * Frequently Asked Questions (FAQ) * Reporting Bugs * About the Author Introduction to Wirble ====================== Wirble is a set of enhancements to Irb all included together in one easy-to-use package. Specifically, Wirble adds a saved history, a couple of useful shortcuts, and color to Irb. Wirble also enables a Irb's built-in tab-completion and a simpler prompt. Before we begin, I should mention that several of Wirble's features were shamelessly inspired (read: borrowed with extreme prejudice) from the "Irb Tips and Tricks" page of the Ruby Garden Wiki, which you can find at the following URL: http://wiki.rubygarden.org/Ruby/page/show/Irb/TipsAndTricks In particular, the Irb history and ri features bear a striking resemblence to their Ruby Garden counterparts. Installing Wirble ================= The easiest way to install Wirble is via RubyGems (http://rubygems.org/). If you've already got RubyGems installed, simply do the following, then skip to the "Using Wirble" section below: # install wirble via RubyGems sudo gem install wirble If you don't have RubyGems, you can also install the Wirble using setup.rb: # install wirble using setup.rb ruby ./setup.rb config && ruby ./setup.rb setup sudo ruby ./setup.rb install Or, install Wirble by hand using sudo: # install wirble to library directory sudo cp -v wirble.rb $(ruby -e 'puts $LOAD_PATH[0]') Or, if you don't use sudo, you can do the same thing with su, like so: # install wirble to library directory su -c "cp -v wirble.rb $(ruby -e 'puts $LOAD_PATH[0]')" Finally, if you don't have an administrator account, you can still install Wirble in your local home directory like so: # create local ruby library directory mkdir ~/.ruby && chmod 700 ~/.ruby cp -v wirble.rb ~/.ruby Then add the following line at the _top_ of your ~/.irbrc file: # add ~/.ruby to the library search path $LOAD_PATH << File.expand_path('~/.ruby') Using Wirble ============ A sample ~/.irbrc is available in the file "_irbrc". If you just want to get Wirble up quickly, copy that to your home directory and be done with it. Otherwise. read on: Using Wirble is easy: just add the following lines to your ~/.irbrc file: begin require 'wirble' # init wirble Wirble.init rescue LoadError => err $stderr.puts "Couldn't load Wirble: #{err}" end A lot of people really don't like colors, so I've kept the color disabled by default. To enable it, add the following bit to your ~/.irbrc file immediately after the call to "Wirble.init": # enable color Wirble.colorize If you want to terrify your grandmother and impress your buddies, your entire ~/.irbrc can also be written like so: %w{rubygems wirble}.each do |lib| begin require lib rescue LoadError => err $stderr.puts "Couldn't load #{lib}: #{err}" end end %w{init colorize}.each { |str| Wirble.send(str) } Configuring Wirble ================== You can pass a hash of options to Wirble.init in order to adjust the behavior of Wirble. Here's a full list of options and a brief description of each one: * :skip_internals Don't load the internal Irb features. Equivalent to setting both :skip_libraries and :skip_prompt (see below). * :skip_libraries Don't load any libraries. At the moment, Wirble attempts to load the following libraries: "pp", "irb/completion", and "rubygems". * :skip_prompt Down't load the simple prompt. Shouldn't ever be necessary, but I've included it for the sake of completeness. Wirble's default behavior is to the prompt setting before making any changes. If the prompt is anything other than :DEFAULT, Wirble won't override it. * :skip_history Don't load the Irb history. There are a few additional history options as well; see :history_path, :history_size, and :history_perms below. * :history_path Set the path to the Irb history file. Defaults to "~/.irb_history". If an environment variable named IRB_HISTORY_FILE is set, Wirble will use that instead of the default value. * :history_size Set the size (in lines) of the Irb history file. Defaults to 1000 lines. If an environment variable named IRB_HISTORY_SIZE is set, Wirble will use that instead of the default value. * :history_perms Set the permissions of the Irb history file. Defaults to File::WRONLY. * :skip_shortcuts Don't load any shortcut methods. at the moment there are three shortcut methods: "ri", "po", and "poc". The first calls the "ri" command on the specified value -- you"ll need to use proper quoting to pass the name properly. As for "po" and "poc": the former lists an object's instance methods (excluding methods that belong to Object), sorted by name, and the latter lists an object's constants, sorted by name. * :init_colors Enable colors. Equivalent to calling Wirble.colorize directly. * :colors A hash of colors. Only makes sense in conjunction with the :init_colors option. See below for additional information on customizing color settings. Here's an example of passing a list of options to Wirble.init(): wirble_opts = { # skip shortcuts :skip_shortcuts => true, # don't set the prompt :skip_prompt => true, # override some of the default colors :colors => { :open_hash => :green. :close_hash => :green. :string => :blue, }, # enable color :init_color => true, } # initialize wirble with options above Wirble.init(wirble_opts) For a full description of the color options, see the next section. Color Settings ============== You can set colors in Wirble by passing a hash of color options via Wirble.init (see the :color option for Wirble.init above), or by setting Wirble::Colorize.color directly. For example: # get the default colors and add in your own colors = Wirble::Colorize.colors.merge({ # set the comma color to blue :comma => :blue, }) # set the colors used by Wirble Wirble::Colorize.colors = colors Below is a list of all the recognized color keys. * :comma (',') A comma character. The element delimiter in arrays and hashes. * :refers ('=>') The hash reference operator. The key/value delimiter in hashes. * :open_hash ('{') The opening curly brace for a hash. * :close_hash ('}') The opening curly brace for a hash. * :open_array ('[') The opening brace for a array. * :close_array (']') The opening brace for a array. * :open_object ('#<') The opening delimiter for an object. * :close_object ('>') The closing delimiter for an object inspection. * :object_class The class attribute of an object inspection. For example, in the string "#", the string "Proc" is the class attribute. * :object_addr_prefix (':') The colon prefixing the address attribute of an object inspection. For example, in the string "#", the string "0xb7be4968" is the memory address attribute, so the ':' is the address prefix. * :object_addr The memory address attribute of an object inspection. For example, in the string "#", the string "0xb7be4968" is the memory address attribute. * :object_addr_prefix ('@') The at symbol prefixing the line attribute of an object inspection. For example, in the string "#", the string "(irb):8" is the line attribute, so the '@' is the line attribute prefix. * :object_line The line number attribute of an object inspection. For example, in the string "#", the string "(irb):8" is the line number attribute. * :symbol_prefix (':') The colon prefix for a symbol object. * :symbol The string of a symbol object. * :open_string ('"') The opening quote of a string object. * :close_string ('"') The closing quote of a string object. * :number A number (integer or float). * :range ('..') The delimeter of a range object. * :keyword A built-in Ruby keyword. This includes values like "true", "false", and "nil". * :class A class. This includes strings like "Class" and "Object". * :whitespace Whitespace character (i.e. space, newline, tab, etc). The highlighting is implemented with a simple hand-rolled state-based tokenizer (wow, that was a mouthful). This should be adequate most of the time, but since it's not a actual LALR parser, Wirble can get confused in a few specific instances. If you find a serious highlighting problem, please let me know. Oh yeah, before I forget, here's a list of the valid color codes: :nothing :green :light_purple :black :light_blue :purple :blue :light_cyan :red :brown :light_gray :white :cyan :light_green :yellow :dark_gray :light_red Note that I'm not a designer, and I also use a terminal with a dark background. I've also been accused of having a Vim color scheme that looks like "a beat up clown". With those caveats in mind, here's the default color scheme for Wirble: # # Default Wirble color scheme. # DEFAULT_COLORS = { # delimiter colors :comma => :blue, :refers => :blue, # container colors (hash and array) :open_hash => :green, :close_hash => :green, :open_array => :green, :close_array => :green, # object colors :open_object => :light_red, :object_class => :white, :object_addr_prefix => :blue, :object_line_prefix => :blue, :close_object => :light_red, # symbol colors :symbol => :yellow, :symbol_prefix => :yellow, # string colors :open_string => :red, :string => :cyan, :close_string => :red, # misc colors :number => :cyan, :keyword => :green, :class => :light_green, :range => :red, } This map is also available via programmatically via Wirble::Colorize::DEFAULT_COLORS. Frequently Asked Questions (FAQ) ================================ Q. Where did the name come from? A. Beats me. It's the only thing I could find in the dictionary, and the only name I came up with that I could pronounce. Q. How do I use color in my Irb prompts? A. You can use standard color escape codes in the format string used by Irb. For example, to set the user prompt to cyan, you could do something like this: ctx = IRB.CurrentContext ctx.prompt_i = Wirble::Colorize.colorize_string(ctx.prompt_i, :cyan) Q. How can I do syntax highlighting as I type? A. I don't know. If there is an answer, I suspect it's not very portable and probably requires some modification to Irb. There's a sneaky hack called eval.rb that seems to do a little bit of highlight, but it doesn't use Irb, and it doesn't really do what you're asking. That said, you can find it here: http://www.rubyist.net/~slagell/ruby/eval.txt Incidentally, part of the problem is that there's no real easy way to do the following: 1. Access to the token stream or parser state incrementally. 2. Process partial strings in readline. A bit more about #1: both Irb and the internal Ruby lexer kind of muddle the traditionally separate concepts of lexer and parser, so it's difficult to, say, parse a string into components and do syntax highlighting on them. Vim and Emacs both handle this with sneaky regular expressions, and a simple Ruby parser, respectively. Wirble and Irb both roll their own (albeit limited) Ruby lexers. Reporting Bugs ============== Have a bug to report or a feature you'd like me to add to Wirble? Feel free to email me at the address below. Alternatively, you can submit your feature request or bug directly to my bug-tracking web interface at the following URL: http://redmine.pablotron.org/projects/show/wirble Note: you'll need to create an account in order to submit a feature request or a bug report via the web interface. Also, I'm a busy guy! I make every effort to respond quickly to bug reports, but detailed descriptions and or patches really do make my life a whole lot easier. About the Author ================ Paul Duncan http://pablotron.org/ And of course, all the fine folks from the Ruby Garden Wiki. :) wirble-0.1.3/wirble.gemspec0000644000175000017500000000221611573730144014654 0ustar gwolfgwolfrequire 'rubygems' spec = Gem::Specification.new do |s| #### Basic information. s.name = 'wirble' s.version = '0.1.3' s.summary = <<-EOF Handful of common Irb features, made easy. EOF s.description = <<-EOF A handful of useful Irb features, including colorized results, tab-completion, history, a simple prompt, and several helper methods, all rolled into one easy to use package. EOF s.requirements << 'Ruby, version 1.8.0 (or newer)' # Which files are to be included in this gem? Everything! (Except .hg directories.) s.files = Dir.glob("**/*").delete_if { |item| item.include?(".hg") } # C code extensions. s.require_path = '.' # is this correct? # Load-time details: library and application (you will need one or both). s.autorequire = 'wirble' s.has_rdoc = true s.rdoc_options = ['--webcvs', 'http://hg.pablotron.org/wirble', '--title', 'Wirble API Documentation', 'wirble.rb', 'README', 'ChangeLog', 'COPYING'] # Author and project details. s.author = 'Paul Duncan' s.email = 'pabs@pablotron.org' s.homepage = 'http://pablotron.org/software/wirble/' s.rubyforge_project = 'wirble' end wirble-0.1.3/_irbrc0000644000175000017500000000114711573730144013210 0ustar gwolfgwolf###################################################################### # _irbrc - Sample .irbrc file to enable Wirble. # ###################################################################### # # Uncomment the block below if you want to load RubyGems in Irb. # # begin # require 'rubygems' # rescue LoadError => err # warn "Couldn't load RubyGems: #{err}" # end begin # load and initialize wirble require 'wirble' Wirble.init # # Uncomment the line below to enable Wirble colors. # # Wirble.colorize rescue LoadError => err warn "Couldn't load Wirble: #{err}" end wirble-0.1.3/setup.rb0000644000175000017500000010713611573730144013517 0ustar gwolfgwolf# # setup.rb # # Copyright (c) 2000-2006 Minero Aoki # # This program is free software. # You can distribute/modify this program under the terms of # the GNU LGPL, Lesser General Public License version 2.1. # unless Enumerable.method_defined?(:map) # Ruby 1.4.6 module Enumerable alias map collect end end unless File.respond_to?(:read) # Ruby 1.6 def File.read(fname) open(fname) {|f| return f.read } end end unless Errno.const_defined?(:ENOTEMPTY) # Windows? module Errno class ENOTEMPTY # We do not raise this exception, implementation is not needed. end end end def File.binread(fname) open(fname, 'rb') {|f| return f.read } end # for corrupted Windows' stat(2) def File.dir?(path) File.directory?((path[-1,1] == '/') ? path : path + '/') end class ConfigTable include Enumerable def initialize(rbconfig) @rbconfig = rbconfig @items = [] @table = {} # options @install_prefix = nil @config_opt = nil @verbose = true @no_harm = false end attr_accessor :install_prefix attr_accessor :config_opt attr_writer :verbose def verbose? @verbose end attr_writer :no_harm def no_harm? @no_harm end def [](key) lookup(key).resolve(self) end def []=(key, val) lookup(key).set val end def names @items.map {|i| i.name } end def each(&block) @items.each(&block) end def key?(name) @table.key?(name) end def lookup(name) @table[name] or setup_rb_error "no such config item: #{name}" end def add(item) @items.push item @table[item.name] = item end def remove(name) item = lookup(name) @items.delete_if {|i| i.name == name } @table.delete_if {|name, i| i.name == name } item end def load_script(path, inst = nil) if File.file?(path) MetaConfigEnvironment.new(self, inst).instance_eval File.read(path), path end end def savefile '.config' end def load_savefile begin File.foreach(savefile()) do |line| k, v = *line.split(/=/, 2) self[k] = v.strip end rescue Errno::ENOENT setup_rb_error $!.message + "\n#{File.basename($0)} config first" end end def save @items.each {|i| i.value } File.open(savefile(), 'w') {|f| @items.each do |i| f.printf "%s=%s\n", i.name, i.value if i.value? and i.value end } end def load_standard_entries standard_entries(@rbconfig).each do |ent| add ent end end def standard_entries(rbconfig) c = rbconfig rubypath = File.join(c['bindir'], c['ruby_install_name'] + c['EXEEXT']) major = c['MAJOR'].to_i minor = c['MINOR'].to_i teeny = c['TEENY'].to_i version = "#{major}.#{minor}" # ruby ver. >= 1.4.4? newpath_p = ((major >= 2) or ((major == 1) and ((minor >= 5) or ((minor == 4) and (teeny >= 4))))) if c['rubylibdir'] # V > 1.6.3 libruby = "#{c['prefix']}/lib/ruby" librubyver = c['rubylibdir'] librubyverarch = c['archdir'] siteruby = c['sitedir'] siterubyver = c['sitelibdir'] siterubyverarch = c['sitearchdir'] elsif newpath_p # 1.4.4 <= V <= 1.6.3 libruby = "#{c['prefix']}/lib/ruby" librubyver = "#{c['prefix']}/lib/ruby/#{version}" librubyverarch = "#{c['prefix']}/lib/ruby/#{version}/#{c['arch']}" siteruby = c['sitedir'] siterubyver = "$siteruby/#{version}" siterubyverarch = "$siterubyver/#{c['arch']}" else # V < 1.4.4 libruby = "#{c['prefix']}/lib/ruby" librubyver = "#{c['prefix']}/lib/ruby/#{version}" librubyverarch = "#{c['prefix']}/lib/ruby/#{version}/#{c['arch']}" siteruby = "#{c['prefix']}/lib/ruby/#{version}/site_ruby" siterubyver = siteruby siterubyverarch = "$siterubyver/#{c['arch']}" end parameterize = lambda {|path| path.sub(/\A#{Regexp.quote(c['prefix'])}/, '$prefix') } if arg = c['configure_args'].split.detect {|arg| /--with-make-prog=/ =~ arg } makeprog = arg.sub(/'/, '').split(/=/, 2)[1] else makeprog = 'make' end [ ExecItem.new('installdirs', 'std/site/home', 'std: install under libruby; site: install under site_ruby; home: install under $HOME')\ {|val, table| case val when 'std' table['rbdir'] = '$librubyver' table['sodir'] = '$librubyverarch' when 'site' table['rbdir'] = '$siterubyver' table['sodir'] = '$siterubyverarch' when 'home' setup_rb_error '$HOME was not set' unless ENV['HOME'] table['prefix'] = ENV['HOME'] table['rbdir'] = '$libdir/ruby' table['sodir'] = '$libdir/ruby' end }, PathItem.new('prefix', 'path', c['prefix'], 'path prefix of target environment'), PathItem.new('bindir', 'path', parameterize.call(c['bindir']), 'the directory for commands'), PathItem.new('libdir', 'path', parameterize.call(c['libdir']), 'the directory for libraries'), PathItem.new('datadir', 'path', parameterize.call(c['datadir']), 'the directory for shared data'), PathItem.new('mandir', 'path', parameterize.call(c['mandir']), 'the directory for man pages'), PathItem.new('sysconfdir', 'path', parameterize.call(c['sysconfdir']), 'the directory for system configuration files'), PathItem.new('localstatedir', 'path', parameterize.call(c['localstatedir']), 'the directory for local state data'), PathItem.new('libruby', 'path', libruby, 'the directory for ruby libraries'), PathItem.new('librubyver', 'path', librubyver, 'the directory for standard ruby libraries'), PathItem.new('librubyverarch', 'path', librubyverarch, 'the directory for standard ruby extensions'), PathItem.new('siteruby', 'path', siteruby, 'the directory for version-independent aux ruby libraries'), PathItem.new('siterubyver', 'path', siterubyver, 'the directory for aux ruby libraries'), PathItem.new('siterubyverarch', 'path', siterubyverarch, 'the directory for aux ruby binaries'), PathItem.new('rbdir', 'path', '$siterubyver', 'the directory for ruby scripts'), PathItem.new('sodir', 'path', '$siterubyverarch', 'the directory for ruby extentions'), PathItem.new('rubypath', 'path', rubypath, 'the path to set to #! line'), ProgramItem.new('rubyprog', 'name', rubypath, 'the ruby program using for installation'), ProgramItem.new('makeprog', 'name', makeprog, 'the make program to compile ruby extentions'), SelectItem.new('shebang', 'all/ruby/never', 'ruby', 'shebang line (#!) editing mode'), BoolItem.new('without-ext', 'yes/no', 'no', 'does not compile/install ruby extentions') ] end private :standard_entries def load_multipackage_entries multipackage_entries().each do |ent| add ent end end def multipackage_entries [ PackageSelectionItem.new('with', 'name,name...', '', 'ALL', 'package names that you want to install'), PackageSelectionItem.new('without', 'name,name...', '', 'NONE', 'package names that you do not want to install') ] end private :multipackage_entries ALIASES = { 'std-ruby' => 'librubyver', 'stdruby' => 'librubyver', 'rubylibdir' => 'librubyver', 'archdir' => 'librubyverarch', 'site-ruby-common' => 'siteruby', # For backward compatibility 'site-ruby' => 'siterubyver', # For backward compatibility 'bin-dir' => 'bindir', 'bin-dir' => 'bindir', 'rb-dir' => 'rbdir', 'so-dir' => 'sodir', 'data-dir' => 'datadir', 'ruby-path' => 'rubypath', 'ruby-prog' => 'rubyprog', 'ruby' => 'rubyprog', 'make-prog' => 'makeprog', 'make' => 'makeprog' } def fixup ALIASES.each do |ali, name| @table[ali] = @table[name] end end def options_re /\A--(#{@table.keys.join('|')})(?:=(.*))?\z/ end def parse_opt(opt) m = options_re().match(opt) or setup_rb_error "config: unknown option #{opt}" m.to_a[1,2] end def dllext @rbconfig['DLEXT'] end def value_config?(name) lookup(name).value? end class Item def initialize(name, template, default, desc) @name = name.freeze @template = template @value = default @default = default @description = desc end attr_reader :name attr_reader :description attr_accessor :default alias help_default default def help_opt "--#{@name}=#{@template}" end def value? true end def value @value end def resolve(table) @value.gsub(%r<\$([^/]+)>) { table[$1] } end def set(val) @value = check(val) end private def check(val) setup_rb_error "config: --#{name} requires argument" unless val val end end class BoolItem < Item def config_type 'bool' end def help_opt "--#{@name}" end private def check(val) return 'yes' unless val case val when /\Ay(es)?\z/i, /\At(rue)?\z/i then 'yes' when /\An(o)?\z/i, /\Af(alse)\z/i then 'no' else setup_rb_error "config: --#{@name} accepts only yes/no for argument" end end end class PathItem < Item def config_type 'path' end private def check(path) setup_rb_error "config: --#{@name} requires argument" unless path path[0,1] == '$' ? path : File.expand_path(path) end end class ProgramItem < Item def config_type 'program' end end class SelectItem < Item def initialize(name, selection, default, desc) super @ok = selection.split('/') end def config_type 'select' end private def check(val) unless @ok.include?(val.strip) setup_rb_error "config: use --#{@name}=#{@template} (#{val})" end val.strip end end class ExecItem < Item def initialize(name, selection, desc, &block) super name, selection, nil, desc @ok = selection.split('/') @action = block end def config_type 'exec' end def value? false end def resolve(table) setup_rb_error "$#{name()} wrongly used as option value" end undef set def evaluate(val, table) v = val.strip.downcase unless @ok.include?(v) setup_rb_error "invalid option --#{@name}=#{val} (use #{@template})" end @action.call v, table end end class PackageSelectionItem < Item def initialize(name, template, default, help_default, desc) super name, template, default, desc @help_default = help_default end attr_reader :help_default def config_type 'package' end private def check(val) unless File.dir?("packages/#{val}") setup_rb_error "config: no such package: #{val}" end val end end class MetaConfigEnvironment def initialize(config, installer) @config = config @installer = installer end def config_names @config.names end def config?(name) @config.key?(name) end def bool_config?(name) @config.lookup(name).config_type == 'bool' end def path_config?(name) @config.lookup(name).config_type == 'path' end def value_config?(name) @config.lookup(name).config_type != 'exec' end def add_config(item) @config.add item end def add_bool_config(name, default, desc) @config.add BoolItem.new(name, 'yes/no', default ? 'yes' : 'no', desc) end def add_path_config(name, default, desc) @config.add PathItem.new(name, 'path', default, desc) end def set_config_default(name, default) @config.lookup(name).default = default end def remove_config(name) @config.remove(name) end # For only multipackage def packages raise '[setup.rb fatal] multi-package metaconfig API packages() called for single-package; contact application package vendor' unless @installer @installer.packages end # For only multipackage def declare_packages(list) raise '[setup.rb fatal] multi-package metaconfig API declare_packages() called for single-package; contact application package vendor' unless @installer @installer.packages = list end end end # class ConfigTable # This module requires: #verbose?, #no_harm? module FileOperations def mkdir_p(dirname, prefix = nil) dirname = prefix + File.expand_path(dirname) if prefix $stderr.puts "mkdir -p #{dirname}" if verbose? return if no_harm? # Does not check '/', it's too abnormal. dirs = File.expand_path(dirname).split(%r<(?=/)>) if /\A[a-z]:\z/i =~ dirs[0] disk = dirs.shift dirs[0] = disk + dirs[0] end dirs.each_index do |idx| path = dirs[0..idx].join('') Dir.mkdir path unless File.dir?(path) end end def rm_f(path) $stderr.puts "rm -f #{path}" if verbose? return if no_harm? force_remove_file path end def rm_rf(path) $stderr.puts "rm -rf #{path}" if verbose? return if no_harm? remove_tree path end def remove_tree(path) if File.symlink?(path) remove_file path elsif File.dir?(path) remove_tree0 path else force_remove_file path end end def remove_tree0(path) Dir.foreach(path) do |ent| next if ent == '.' next if ent == '..' entpath = "#{path}/#{ent}" if File.symlink?(entpath) remove_file entpath elsif File.dir?(entpath) remove_tree0 entpath else force_remove_file entpath end end begin Dir.rmdir path rescue Errno::ENOTEMPTY # directory may not be empty end end def move_file(src, dest) force_remove_file dest begin File.rename src, dest rescue File.open(dest, 'wb') {|f| f.write File.binread(src) } File.chmod File.stat(src).mode, dest File.unlink src end end def force_remove_file(path) begin remove_file path rescue end end def remove_file(path) File.chmod 0777, path File.unlink path end def install(from, dest, mode, prefix = nil) $stderr.puts "install #{from} #{dest}" if verbose? return if no_harm? realdest = prefix ? prefix + File.expand_path(dest) : dest realdest = File.join(realdest, File.basename(from)) if File.dir?(realdest) str = File.binread(from) if diff?(str, realdest) verbose_off { rm_f realdest if File.exist?(realdest) } File.open(realdest, 'wb') {|f| f.write str } File.chmod mode, realdest File.open("#{objdir_root()}/InstalledFiles", 'a') {|f| if prefix f.puts realdest.sub(prefix, '') else f.puts realdest end } end end def diff?(new_content, path) return true unless File.exist?(path) new_content != File.binread(path) end def command(*args) $stderr.puts args.join(' ') if verbose? system(*args) or raise RuntimeError, "system(#{args.map{|a| a.inspect }.join(' ')}) failed" end def ruby(*args) command config('rubyprog'), *args end def make(task = nil) command(*[config('makeprog'), task].compact) end def extdir?(dir) File.exist?("#{dir}/MANIFEST") or File.exist?("#{dir}/extconf.rb") end def files_of(dir) Dir.open(dir) {|d| return d.select {|ent| File.file?("#{dir}/#{ent}") } } end DIR_REJECT = %w( . .. CVS SCCS RCS CVS.adm .svn ) def directories_of(dir) Dir.open(dir) {|d| return d.select {|ent| File.dir?("#{dir}/#{ent}") } - DIR_REJECT } end end # This module requires: #srcdir_root, #objdir_root, #relpath module HookScriptAPI def get_config(key) @config[key] end alias config get_config # obsolete: use metaconfig to change configuration def set_config(key, val) @config[key] = val end # # srcdir/objdir (works only in the package directory) # def curr_srcdir "#{srcdir_root()}/#{relpath()}" end def curr_objdir "#{objdir_root()}/#{relpath()}" end def srcfile(path) "#{curr_srcdir()}/#{path}" end def srcexist?(path) File.exist?(srcfile(path)) end def srcdirectory?(path) File.dir?(srcfile(path)) end def srcfile?(path) File.file?(srcfile(path)) end def srcentries(path = '.') Dir.open("#{curr_srcdir()}/#{path}") {|d| return d.to_a - %w(. ..) } end def srcfiles(path = '.') srcentries(path).select {|fname| File.file?(File.join(curr_srcdir(), path, fname)) } end def srcdirectories(path = '.') srcentries(path).select {|fname| File.dir?(File.join(curr_srcdir(), path, fname)) } end end class ToplevelInstaller Version = '3.4.1' Copyright = 'Copyright (c) 2000-2006 Minero Aoki' TASKS = [ [ 'all', 'do config, setup, then install' ], [ 'config', 'saves your configurations' ], [ 'show', 'shows current configuration' ], [ 'setup', 'compiles ruby extentions and others' ], [ 'install', 'installs files' ], [ 'test', 'run all tests in test/' ], [ 'clean', "does `make clean' for each extention" ], [ 'distclean',"does `make distclean' for each extention" ] ] def ToplevelInstaller.invoke config = ConfigTable.new(load_rbconfig()) config.load_standard_entries config.load_multipackage_entries if multipackage? config.fixup klass = (multipackage?() ? ToplevelInstallerMulti : ToplevelInstaller) klass.new(File.dirname($0), config).invoke end def ToplevelInstaller.multipackage? File.dir?(File.dirname($0) + '/packages') end def ToplevelInstaller.load_rbconfig if arg = ARGV.detect {|arg| /\A--rbconfig=/ =~ arg } ARGV.delete(arg) load File.expand_path(arg.split(/=/, 2)[1]) $".push 'rbconfig.rb' else require 'rbconfig' end ::Config::CONFIG end def initialize(ardir_root, config) @ardir = File.expand_path(ardir_root) @config = config # cache @valid_task_re = nil end def config(key) @config[key] end def inspect "#<#{self.class} #{__id__()}>" end def invoke run_metaconfigs case task = parsearg_global() when nil, 'all' parsearg_config init_installers exec_config exec_setup exec_install else case task when 'config', 'test' ; when 'clean', 'distclean' @config.load_savefile if File.exist?(@config.savefile) else @config.load_savefile end __send__ "parsearg_#{task}" init_installers __send__ "exec_#{task}" end end def run_metaconfigs @config.load_script "#{@ardir}/metaconfig" end def init_installers @installer = Installer.new(@config, @ardir, File.expand_path('.')) end # # Hook Script API bases # def srcdir_root @ardir end def objdir_root '.' end def relpath '.' end # # Option Parsing # def parsearg_global while arg = ARGV.shift case arg when /\A\w+\z/ setup_rb_error "invalid task: #{arg}" unless valid_task?(arg) return arg when '-q', '--quiet' @config.verbose = false when '--verbose' @config.verbose = true when '--help' print_usage $stdout exit 0 when '--version' puts "#{File.basename($0)} version #{Version}" exit 0 when '--copyright' puts Copyright exit 0 else setup_rb_error "unknown global option '#{arg}'" end end nil end def valid_task?(t) valid_task_re() =~ t end def valid_task_re @valid_task_re ||= /\A(?:#{TASKS.map {|task,desc| task }.join('|')})\z/ end def parsearg_no_options unless ARGV.empty? task = caller(0).first.slice(%r<`parsearg_(\w+)'>, 1) setup_rb_error "#{task}: unknown options: #{ARGV.join(' ')}" end end alias parsearg_show parsearg_no_options alias parsearg_setup parsearg_no_options alias parsearg_test parsearg_no_options alias parsearg_clean parsearg_no_options alias parsearg_distclean parsearg_no_options def parsearg_config evalopt = [] set = [] @config.config_opt = [] while i = ARGV.shift if /\A--?\z/ =~ i @config.config_opt = ARGV.dup break end name, value = *@config.parse_opt(i) if @config.value_config?(name) @config[name] = value else evalopt.push [name, value] end set.push name end evalopt.each do |name, value| @config.lookup(name).evaluate value, @config end # Check if configuration is valid set.each do |n| @config[n] if @config.value_config?(n) end end def parsearg_install @config.no_harm = false @config.install_prefix = '' while a = ARGV.shift case a when '--no-harm' @config.no_harm = true when /\A--prefix=/ path = a.split(/=/, 2)[1] path = File.expand_path(path) unless path[0,1] == '/' @config.install_prefix = path else setup_rb_error "install: unknown option #{a}" end end end def print_usage(out) out.puts 'Typical Installation Procedure:' out.puts " $ ruby #{File.basename $0} config" out.puts " $ ruby #{File.basename $0} setup" out.puts " # ruby #{File.basename $0} install (may require root privilege)" out.puts out.puts 'Detailed Usage:' out.puts " ruby #{File.basename $0} " out.puts " ruby #{File.basename $0} [] []" fmt = " %-24s %s\n" out.puts out.puts 'Global options:' out.printf fmt, '-q,--quiet', 'suppress message outputs' out.printf fmt, ' --verbose', 'output messages verbosely' out.printf fmt, ' --help', 'print this message' out.printf fmt, ' --version', 'print version and quit' out.printf fmt, ' --copyright', 'print copyright and quit' out.puts out.puts 'Tasks:' TASKS.each do |name, desc| out.printf fmt, name, desc end fmt = " %-24s %s [%s]\n" out.puts out.puts 'Options for CONFIG or ALL:' @config.each do |item| out.printf fmt, item.help_opt, item.description, item.help_default end out.printf fmt, '--rbconfig=path', 'rbconfig.rb to load',"running ruby's" out.puts out.puts 'Options for INSTALL:' out.printf fmt, '--no-harm', 'only display what to do if given', 'off' out.printf fmt, '--prefix=path', 'install path prefix', '' out.puts end # # Task Handlers # def exec_config @installer.exec_config @config.save # must be final end def exec_setup @installer.exec_setup end def exec_install @installer.exec_install end def exec_test @installer.exec_test end def exec_show @config.each do |i| printf "%-20s %s\n", i.name, i.value if i.value? end end def exec_clean @installer.exec_clean end def exec_distclean @installer.exec_distclean end end # class ToplevelInstaller class ToplevelInstallerMulti < ToplevelInstaller include FileOperations def initialize(ardir_root, config) super @packages = directories_of("#{@ardir}/packages") raise 'no package exists' if @packages.empty? @root_installer = Installer.new(@config, @ardir, File.expand_path('.')) end def run_metaconfigs @config.load_script "#{@ardir}/metaconfig", self @packages.each do |name| @config.load_script "#{@ardir}/packages/#{name}/metaconfig" end end attr_reader :packages def packages=(list) raise 'package list is empty' if list.empty? list.each do |name| raise "directory packages/#{name} does not exist"\ unless File.dir?("#{@ardir}/packages/#{name}") end @packages = list end def init_installers @installers = {} @packages.each do |pack| @installers[pack] = Installer.new(@config, "#{@ardir}/packages/#{pack}", "packages/#{pack}") end with = extract_selection(config('with')) without = extract_selection(config('without')) @selected = @installers.keys.select {|name| (with.empty? or with.include?(name)) \ and not without.include?(name) } end def extract_selection(list) a = list.split(/,/) a.each do |name| setup_rb_error "no such package: #{name}" unless @installers.key?(name) end a end def print_usage(f) super f.puts 'Inluded packages:' f.puts ' ' + @packages.sort.join(' ') f.puts end # # Task Handlers # def exec_config run_hook 'pre-config' each_selected_installers {|inst| inst.exec_config } run_hook 'post-config' @config.save # must be final end def exec_setup run_hook 'pre-setup' each_selected_installers {|inst| inst.exec_setup } run_hook 'post-setup' end def exec_install run_hook 'pre-install' each_selected_installers {|inst| inst.exec_install } run_hook 'post-install' end def exec_test run_hook 'pre-test' each_selected_installers {|inst| inst.exec_test } run_hook 'post-test' end def exec_clean rm_f @config.savefile run_hook 'pre-clean' each_selected_installers {|inst| inst.exec_clean } run_hook 'post-clean' end def exec_distclean rm_f @config.savefile run_hook 'pre-distclean' each_selected_installers {|inst| inst.exec_distclean } run_hook 'post-distclean' end # # lib # def each_selected_installers Dir.mkdir 'packages' unless File.dir?('packages') @selected.each do |pack| $stderr.puts "Processing the package `#{pack}' ..." if verbose? Dir.mkdir "packages/#{pack}" unless File.dir?("packages/#{pack}") Dir.chdir "packages/#{pack}" yield @installers[pack] Dir.chdir '../..' end end def run_hook(id) @root_installer.run_hook id end # module FileOperations requires this def verbose? @config.verbose? end # module FileOperations requires this def no_harm? @config.no_harm? end end # class ToplevelInstallerMulti class Installer FILETYPES = %w( bin lib ext data conf man ) include FileOperations include HookScriptAPI def initialize(config, srcroot, objroot) @config = config @srcdir = File.expand_path(srcroot) @objdir = File.expand_path(objroot) @currdir = '.' end def inspect "#<#{self.class} #{File.basename(@srcdir)}>" end def noop(rel) end # # Hook Script API base methods # def srcdir_root @srcdir end def objdir_root @objdir end def relpath @currdir end # # Config Access # # module FileOperations requires this def verbose? @config.verbose? end # module FileOperations requires this def no_harm? @config.no_harm? end def verbose_off begin save, @config.verbose = @config.verbose?, false yield ensure @config.verbose = save end end # # TASK config # def exec_config exec_task_traverse 'config' end alias config_dir_bin noop alias config_dir_lib noop def config_dir_ext(rel) extconf if extdir?(curr_srcdir()) end alias config_dir_data noop alias config_dir_conf noop alias config_dir_man noop def extconf ruby "#{curr_srcdir()}/extconf.rb", *@config.config_opt end # # TASK setup # def exec_setup exec_task_traverse 'setup' end def setup_dir_bin(rel) files_of(curr_srcdir()).each do |fname| update_shebang_line "#{curr_srcdir()}/#{fname}" end end alias setup_dir_lib noop def setup_dir_ext(rel) make if extdir?(curr_srcdir()) end alias setup_dir_data noop alias setup_dir_conf noop alias setup_dir_man noop def update_shebang_line(path) return if no_harm? return if config('shebang') == 'never' old = Shebang.load(path) if old $stderr.puts "warning: #{path}: Shebang line includes too many args. It is not portable and your program may not work." if old.args.size > 1 new = new_shebang(old) return if new.to_s == old.to_s else return unless config('shebang') == 'all' new = Shebang.new(config('rubypath')) end $stderr.puts "updating shebang: #{File.basename(path)}" if verbose? open_atomic_writer(path) {|output| File.open(path, 'rb') {|f| f.gets if old # discard output.puts new.to_s output.print f.read } } end def new_shebang(old) if /\Aruby/ =~ File.basename(old.cmd) Shebang.new(config('rubypath'), old.args) elsif File.basename(old.cmd) == 'env' and old.args.first == 'ruby' Shebang.new(config('rubypath'), old.args[1..-1]) else return old unless config('shebang') == 'all' Shebang.new(config('rubypath')) end end def open_atomic_writer(path, &block) tmpfile = File.basename(path) + '.tmp' begin File.open(tmpfile, 'wb', &block) File.rename tmpfile, File.basename(path) ensure File.unlink tmpfile if File.exist?(tmpfile) end end class Shebang def Shebang.load(path) line = nil File.open(path) {|f| line = f.gets } return nil unless /\A#!/ =~ line parse(line) end def Shebang.parse(line) cmd, *args = *line.strip.sub(/\A\#!/, '').split(' ') new(cmd, args) end def initialize(cmd, args = []) @cmd = cmd @args = args end attr_reader :cmd attr_reader :args def to_s "#! #{@cmd}" + (@args.empty? ? '' : " #{@args.join(' ')}") end end # # TASK install # def exec_install rm_f 'InstalledFiles' exec_task_traverse 'install' end def install_dir_bin(rel) install_files targetfiles(), "#{config('bindir')}/#{rel}", 0755, strip_ext? end def strip_ext? /mswin|mingw/ !~ RUBY_PLATFORM end def install_dir_lib(rel) install_files libfiles(), "#{config('rbdir')}/#{rel}", 0644 end def install_dir_ext(rel) return unless extdir?(curr_srcdir()) install_files rubyextentions('.'), "#{config('sodir')}/#{File.dirname(rel)}", 0555 end def install_dir_data(rel) install_files targetfiles(), "#{config('datadir')}/#{rel}", 0644 end def install_dir_conf(rel) # FIXME: should not remove current config files # (rename previous file to .old/.org) install_files targetfiles(), "#{config('sysconfdir')}/#{rel}", 0644 end def install_dir_man(rel) install_files targetfiles(), "#{config('mandir')}/#{rel}", 0644 end def install_files(list, dest, mode, stripext = false) mkdir_p dest, @config.install_prefix list.each do |fname| if stripext install fname, "#{dest}/#{File.basename(fname, '.*')}", mode, @config.install_prefix else install fname, dest, mode, @config.install_prefix end end end def libfiles glob_reject(%w(*.y *.output), targetfiles()) end def rubyextentions(dir) ents = glob_select("*.#{@config.dllext}", targetfiles()) if ents.empty? setup_rb_error "no ruby extention exists: 'ruby #{$0} setup' first" end ents end def targetfiles mapdir(existfiles() - hookfiles()) end def mapdir(ents) ents.map {|ent| if File.exist?(ent) then ent # objdir else "#{curr_srcdir()}/#{ent}" # srcdir end } end # picked up many entries from cvs-1.11.1/src/ignore.c JUNK_FILES = %w( core RCSLOG tags TAGS .make.state .nse_depinfo #* .#* cvslog.* ,* .del-* *.olb *~ *.old *.bak *.BAK *.orig *.rej _$* *$ *.org *.in .* ) def existfiles glob_reject(JUNK_FILES, (files_of(curr_srcdir()) | files_of('.'))) end def hookfiles %w( pre-%s post-%s pre-%s.rb post-%s.rb ).map {|fmt| %w( config setup install clean distclean ).map {|t| sprintf(fmt, t) } }.flatten end def glob_select(pat, ents) re = globs2re([pat]) ents.select {|ent| re =~ ent } end def glob_reject(pats, ents) re = globs2re(pats) ents.reject {|ent| re =~ ent } end GLOB2REGEX = { '.' => '\.', '$' => '\$', '#' => '\#', '*' => '.*' } def globs2re(pats) /\A(?:#{ pats.map {|pat| pat.gsub(/[\.\$\#\*]/) {|ch| GLOB2REGEX[ch] } }.join('|') })\z/ end # # TASK test # TESTDIR = 'test' def exec_test unless File.directory?('test') $stderr.puts 'no test in this package' if verbose? return end $stderr.puts 'Running tests...' if verbose? begin require 'test/unit' rescue LoadError setup_rb_error 'test/unit cannot loaded. You need Ruby 1.8 or later to invoke this task.' end runner = Test::Unit::AutoRunner.new(true) runner.to_run << TESTDIR runner.run end # # TASK clean # def exec_clean exec_task_traverse 'clean' rm_f @config.savefile rm_f 'InstalledFiles' end alias clean_dir_bin noop alias clean_dir_lib noop alias clean_dir_data noop alias clean_dir_conf noop alias clean_dir_man noop def clean_dir_ext(rel) return unless extdir?(curr_srcdir()) make 'clean' if File.file?('Makefile') end # # TASK distclean # def exec_distclean exec_task_traverse 'distclean' rm_f @config.savefile rm_f 'InstalledFiles' end alias distclean_dir_bin noop alias distclean_dir_lib noop def distclean_dir_ext(rel) return unless extdir?(curr_srcdir()) make 'distclean' if File.file?('Makefile') end alias distclean_dir_data noop alias distclean_dir_conf noop alias distclean_dir_man noop # # Traversing # def exec_task_traverse(task) run_hook "pre-#{task}" FILETYPES.each do |type| if type == 'ext' and config('without-ext') == 'yes' $stderr.puts 'skipping ext/* by user option' if verbose? next end traverse task, type, "#{task}_dir_#{type}" end run_hook "post-#{task}" end def traverse(task, rel, mid) dive_into(rel) { run_hook "pre-#{task}" __send__ mid, rel.sub(%r[\A.*?(?:/|\z)], '') directories_of(curr_srcdir()).each do |d| traverse task, "#{rel}/#{d}", mid end run_hook "post-#{task}" } end def dive_into(rel) return unless File.dir?("#{@srcdir}/#{rel}") dir = File.basename(rel) Dir.mkdir dir unless File.dir?(dir) prevdir = Dir.pwd Dir.chdir dir $stderr.puts '---> ' + rel if verbose? @currdir = rel yield Dir.chdir prevdir $stderr.puts '<--- ' + rel if verbose? @currdir = File.dirname(rel) end def run_hook(id) path = [ "#{curr_srcdir()}/#{id}", "#{curr_srcdir()}/#{id}.rb" ].detect {|cand| File.file?(cand) } return unless path $stderr.puts "invoking hook script #{path}" if verbose? begin instance_eval File.read(path), path, 1 rescue raise if $DEBUG setup_rb_error "hook #{path} failed:\n" + $!.message end end end # class Installer class SetupError < StandardError; end def setup_rb_error(msg) raise SetupError, msg end if $0 == __FILE__ begin ToplevelInstaller.invoke rescue SetupError raise if $DEBUG $stderr.puts $!.message $stderr.puts "Try 'ruby #{$0} --help' for detailed usage." exit 1 end end wirble-0.1.3/ChangeLog0000644000175000017500000000156611573730144013604 0ustar gwolfgwolf * Wed Sep 06 00:01:21 2006, pabs * initial import * Wed Sep 06 00:10:13 2006, pabs * wirble.rb: remove symbol hackery to prevent ri/rdoc from barfing * Wed Sep 6 02:49:02 EDT 2006, Paul Duncan * wirble.rb: fix typo * re-release 0.1.0 * Fri Sep 8 04:01:40 EDT 2006, Paul Duncan * README: updated version to 0.1.1 * wirble.gemspec: ditto * wirble.rb: ditto * wirble.rb: wrap colorize in an exception (just in case) * Fri Sep 08 13:11:05 2006, pabs * increment version to 0.1.2 * wirble.gemspec: remove rubilicious dependency * Fri Sep 8 13:17:29 EDT 2006, Paul Duncan * README: increment version to 0.1.2 * wirble.gemspec: ditto * wirble.rb: ditto * Fri Sep 08 13:18:15 2006, pabs * releasing 0.1.2 wirble-0.1.3/metadata.yml0000644000175000017500000000231511573730144014326 0ustar gwolfgwolf--- !ruby/object:Gem::Specification name: wirble version: !ruby/object:Gem::Version version: 0.1.3 platform: ruby authors: - Paul Duncan autorequire: wirble bindir: bin cert_chain: [] date: 2009-05-30 00:00:00 -04:00 default_executable: dependencies: [] description: Handful of common Irb features, made easy. email: pabs@pablotron.org executables: [] extensions: [] extra_rdoc_files: [] files: - _irbrc - wirble.gemspec - Rakefile - setup.rb - README - lib/wirble.rb - ChangeLog - COPYING has_rdoc: true homepage: http://pablotron.org/software/wirble/ licenses: [] post_install_message: rdoc_options: - --title - Wirble 0.1.3 API Documentation - --webcvs - http://hg.pablotron.org/wirble - lib/wirble.rb - README require_paths: - lib required_ruby_version: !ruby/object:Gem::Requirement requirements: - - ">=" - !ruby/object:Gem::Version version: "0" version: required_rubygems_version: !ruby/object:Gem::Requirement requirements: - - ">=" - !ruby/object:Gem::Version version: "0" version: requirements: - none rubyforge_project: pablotron rubygems_version: 1.3.3 signing_key: specification_version: 3 summary: Handful of common Irb features, made easy. test_files: [] wirble-0.1.3/COPYING0000644000175000017500000000206311573730144013056 0ustar gwolfgwolfCopyright (C) 2006-2009 Paul Duncan Permission is hereby granted, free of charge, to any person obtaining a copy of this software and associated documentation files (the "Software"), to deal in the Software without restriction, including without limitation the rights to use, copy, modify, merge, publish, distribute, sublicense, and/or sell copies of the Software, and to permit persons to whom the Software is furnished to do so, subject to the following conditions: The above copyright notice and this permission notice shall be included in all copies or substantial portions of the of the Software. THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE AUTHORS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM, OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE SOFTWARE.