gauntlet 1.0.0

data/History.txt

@@ -0,0 +1,6 @@
+=== 1.0.0 / 2008-12-04
+
+* 1 major enhancement
+
+  * Birthday!
+

data/Manifest.txt

@@ -0,0 +1,7 @@
+History.txt
+Manifest.txt
+README.txt
+Rakefile
+bin/gauntlet
+lib/gauntlet.rb
+test/test_gauntlet.rb

data/README.txt

@@ -0,0 +1,67 @@
+= gauntlet
+
+* http://rubyforge.org/projects/seattlerb
+
+== DESCRIPTION:
+
+Gauntlet is a pluggable means of running code against all the latest
+gems and storing off the data.
+
+== FEATURES/PROBLEMS:
+
+* Downloads all the latest gems and converts them to tarballs for easy access.
+* Iterates through all downloaded gems, unpacks them, and then runs your code.
+* Automates storage of results to YAML files.
+* Easily skips over projects that already have results (overridable).
+* gauntlet commandline locates your gauntlet library via rubygems:
+  * eg. `gauntlet flog` finds gauntlet_flog.rb in the flog gem.
+
+== SYNOPSIS:
+
+  require 'gauntlet'
+  
+  class MyGauntlet < Gauntlet
+    def run name
+      data[name] = Dir["**/*.rb"]
+      self.dirty = true
+    end
+  end
+  
+  filter = ARGV.shift
+  filter = Regexp.new filter if filter
+  
+  gauntlet = MyGauntlet.new
+  gauntlet.run_the_gauntlet filter
+
+== REQUIREMENTS:
+
+* rubygems
+
+== INSTALL:
+
+* sudo gem install gauntlet
+
+== LICENSE:
+
+(The MIT License)
+
+Copyright (c) 2008 Ryan Davis, Seattle.rb
+
+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 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 OR COPYRIGHT HOLDERS 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.

data/Rakefile

@@ -0,0 +1,12 @@
+# -*- ruby -*-
+
+require 'rubygems'
+require 'hoe'
+require './lib/gauntlet.rb'
+
+Hoe.new('gauntlet', Gauntlet::VERSION) do |p|
+  p.rubyforge_name = 'seattlerb'
+  p.developer('Ryan Davis', 'ryand-ruby@zenspider.com')
+end
+
+# vim: syntax=Ruby

data/bin/gauntlet

@@ -0,0 +1,12 @@
+#!/usr/bin/ruby -ws
+
+if ARGV.empty? then
+  warn "usage: gauntlet <project>"
+  warn "  runs gauntlet_<project>.rb"
+  exit 1
+end
+
+name = ARGV.shift
+
+require "rubygems"
+require "gauntlet_#{name}"

data/lib/gauntlet.rb

@@ -0,0 +1,356 @@
+require 'rubygems/remote_fetcher'
+require 'thread'
+require 'yaml'
+
+$u ||= false
+$f ||= false
+$F ||= false
+
+Thread.abort_on_exception = true
+
+class Gauntlet
+  VERSION = '1.0.0'
+
+  GEMURL = URI.parse 'http://gems.rubyforge.org'
+  GEMDIR = File.expand_path "~/.gauntlet"
+  DATADIR = File.expand_path "~/.gauntlet/data"
+
+  # stupid dups usually because of "dash" renames
+  STUPID_GEMS = %w(ajax-scaffold-generator
+                   extract_curves
+                   flickr-fu
+                   hpricot-scrub
+                   html_me
+                   merb-builder
+                   merb-jquery
+                   merb-parts
+                   merb_exceptions
+                   merb_helpers
+                   merb_param_protection
+                   model_graph
+                   not_naughty
+                   rfeedparser-ictv
+                   spec-converter
+                   spec_unit)
+
+  attr_accessor :dirty, :data_file, :data
+
+  def initialize
+    name = self.class.name.downcase.sub(/gauntlet/, '')
+    self.data_file = "#{DATADIR}/#{name}-data.yml"
+    self.dirty = false
+  end
+
+  def initialize_dir
+    Dir.mkdir GEMDIR unless File.directory? GEMDIR
+    Dir.mkdir DATADIR unless File.directory? DATADIR
+    in_gem_dir do
+      File.symlink ".", "cache" unless File.exist? "cache"
+    end
+  end
+
+  def source_index
+    @index ||= in_gem_dir do
+      dump = if ($u and not $F) or not File.exist? '.source_index' then
+               url = GEMURL + "Marshal.#{Gem.marshal_version}.Z"
+               dump = Gem::RemoteFetcher.fetcher.fetch_path url
+               require 'zlib'
+               dump = Gem.inflate dump
+               open '.source_index', 'wb' do |io| io.write dump end
+               dump
+             else
+               open '.source_index', 'rb' do |io| io.read end
+             end
+
+      Marshal.load dump
+    end
+  end
+
+  def latest_gems
+    @cache ||= source_index.latest_specs
+  end
+
+  def gems_by_name
+    @by_name ||= Hash[*latest_gems.map { |gem|
+                        [gem.name, gem, gem.full_name, gem]
+                      }.flatten]
+  end
+
+  def dependencies_of name
+    index = source_index
+    gems_by_name[name].dependencies.map { |dep| index.search(dep).last }
+  end
+
+  def dependent_upon name
+    latest_gems.find_all { |gem|
+      gem.dependencies.any? { |dep| dep.name == name }
+    }
+  end
+
+  def find_stupid_gems
+    gems   = Hash.new { |h,k| h[k] = [] }
+    stupid = []
+    latest = {}
+
+    latest_gems.each do |spec|
+      name = spec.name.gsub(/-/, '_')
+      next unless name =~ /_/
+      gems[name] << spec
+    end
+
+    gems.reject! { |k,v| v.size == 1 || v.map { |s| s.name }.uniq.size == 1 }
+
+    gems.each do |k,v|
+      sorted = v.sort_by { |spec| spec.version }
+      latest[sorted.last.name] = true
+      sorted.each do |spec|
+        stupid << spec.name unless latest[spec.name]
+      end
+    end
+
+    stupid.uniq
+  end
+
+  def update_gem_tarballs
+    initialize_dir
+
+    latest = self.latest_gems
+
+    puts "updating mirror"
+
+    in_gem_dir do
+      gems = Dir["*.gem"]
+      tgzs = Dir["*.tgz"]
+
+      old = tgzs - latest.map { |spec| "#{spec.full_name}.tgz" }
+      unless old.empty? then
+        puts "deleting #{old.size} tgzs"
+        old.each do |tgz|
+          File.unlink tgz
+        end
+      end
+
+      tasks = Queue.new
+      latest.sort!
+      latest.reject! { |spec| tgzs.include? "#{spec.full_name}.tgz" }
+      tasks.push(latest.shift) until latest.empty? # LAME
+
+      puts "fetching #{tasks.size} gems"
+
+      threads = []
+      10.times do
+        threads << Thread.new do
+          fetcher = Gem::RemoteFetcher.new nil # fuck proxies
+          until tasks.empty? do
+            spec = tasks.shift
+            full_name = spec.full_name
+            tgz_name = "#{full_name}.tgz"
+            gem_name = "#{full_name}.gem"
+
+            unless gems.include? gem_name then
+              begin
+                warn "downloading #{full_name}"
+                fetcher.download(spec, GEMURL, Dir.pwd)
+              rescue Gem::RemoteFetcher::FetchError
+                warn "  failed"
+                next
+              end
+            end
+
+            warn "  converting #{gem_name} to tarball"
+
+            unless File.directory? full_name then
+              system "gem unpack cache/#{gem_name} &> /dev/null"
+              system "gem spec -l cache/#{gem_name} > #{full_name}/gemspec"
+            end
+
+            system "chmod -R u+rwX #{full_name} && tar zmcf #{tgz_name} #{full_name} && rm -rf   #{full_name} #{gem_name}"
+          end
+        end
+      end
+
+      threads.each do |thread|
+        thread.join
+      end
+    end
+  rescue Interrupt
+    warn "user cancelled... quitting"
+    exit 1
+  end
+
+  def each_gem filter = nil
+    filter ||= /^[\w-]+-\d+(\.\d+)*\.tgz$/
+    in_gem_dir do
+      Dir["*.tgz"].each do |tgz|
+        next unless tgz =~ filter
+
+        yield File.basename(tgz, ".tgz")
+      end
+    end
+  end
+
+  def with_gem name
+    in_gem_dir do
+      begin
+        system "tar zxmf #{name}.tgz 2> /dev/null"
+        Dir.chdir name do
+          yield name
+        end
+      ensure
+        system "rm -r #{name}"
+      end
+    end
+  end
+
+  def load_yaml path, default = {}
+    YAML.load(File.read(path)) rescue default
+  end
+
+  def save_yaml path, data
+    File.open("#{path}.new", 'w') do |f|
+      warn "*** saving #{path}"
+      YAML.dump data, f
+    end
+    File.rename "#{path}.new", path
+  end
+
+  def in_gem_dir
+    Dir.chdir GEMDIR do
+      yield
+    end
+  end
+
+  ##
+  # Override this to customize gauntlet. See run_the_gauntlet for
+  # other ways of adding behavior.
+
+  def run name
+    raise "subclass responsibility"
+  end
+
+  ##
+  # Override this to return true if the gem should be skipped.
+
+  def should_skip? name
+    self.data[name]
+  end
+
+  ##
+  # This is the main driver for gauntlet. filter allows you to pass in
+  # a regexp to only run against a subset of the gems available. You
+  # can pass a block to run_the_gauntlet or it will call run. Both are
+  # passed the name of the gem and are executed within the gem
+  # directory.
+
+  def run_the_gauntlet filter = nil
+    initialize_dir
+    update_gem_tarballs if $u
+
+    self.data ||= load_yaml data_file
+
+    each_gem filter do |name|
+      next if should_skip? name
+      with_gem name do
+        if block_given? then
+          yield name
+        else
+          run name
+        end
+      end
+    end
+  rescue Interrupt
+    warn "user cancelled. quitting"
+  ensure
+    save_yaml data_file, data if dirty
+  end
+end
+
+############################################################
+# Extensions and Overrides
+
+# bug in RemoteFetcher#download prevents multithreading. Remove after 1.3.2
+class Gem::RemoteFetcher
+  def download(spec, source_uri, install_dir = Gem.dir)
+    if File.writable?(install_dir)
+      cache_dir = File.join install_dir, 'cache'
+    else
+      cache_dir = File.join(Gem.user_dir, 'cache')
+    end
+
+    gem_file_name = "#{spec.full_name}.gem"
+    local_gem_path = File.join cache_dir, gem_file_name
+
+    FileUtils.mkdir_p cache_dir rescue nil unless File.exist? cache_dir
+
+    source_uri = URI.parse source_uri unless URI::Generic === source_uri
+    scheme = source_uri.scheme
+
+    # URI.parse gets confused by MS Windows paths with forward slashes.
+    scheme = nil if scheme =~ /^[a-z]$/i
+
+    case scheme
+    when 'http', 'https' then
+      unless File.exist? local_gem_path then
+        begin
+          say "Downloading gem #{gem_file_name}" if
+            Gem.configuration.really_verbose
+
+          remote_gem_path = source_uri + "gems/#{gem_file_name}"
+
+          gem = self.fetch_path remote_gem_path
+        rescue Gem::RemoteFetcher::FetchError
+          raise if spec.original_platform == spec.platform
+
+          alternate_name = "#{spec.original_name}.gem"
+
+          say "Failed, downloading gem #{alternate_name}" if
+            Gem.configuration.really_verbose
+
+          remote_gem_path = source_uri + "gems/#{alternate_name}"
+
+          gem = self.fetch_path remote_gem_path
+        end
+
+        File.open local_gem_path, 'wb' do |fp|
+          fp.write gem
+        end
+      end
+    when nil, 'file' then # TODO test for local overriding cache
+      begin
+        FileUtils.cp source_uri.to_s, local_gem_path
+      rescue Errno::EACCES
+        local_gem_path = source_uri.to_s
+      end
+
+      say "Using local gem #{local_gem_path}" if
+        Gem.configuration.really_verbose
+    else
+      raise Gem::InstallError, "unsupported URI scheme #{source_uri.scheme}"
+    end
+
+    local_gem_path
+  end
+end
+
+class Array
+  def sum
+    sum = 0
+    self.each { |i| sum += i }
+    sum
+  end
+
+  def average
+    return self.sum / self.length.to_f
+  end
+
+  def sample_variance
+    avg = self.average
+    sum = 0
+    self.each { |i| sum += (i - avg) ** 2 }
+    return (1 / self.length.to_f * sum)
+  end
+
+  def stddev
+    return Math.sqrt(self.sample_variance)
+  end
+end

metadata

@@ -0,0 +1,72 @@
+--- !ruby/object:Gem::Specification 
+name: gauntlet
+version: !ruby/object:Gem::Version 
+  version: 1.0.0
+platform: ruby
+authors: 
+- Ryan Davis
+autorequire: 
+bindir: bin
+cert_chain: []
+
+date: 2008-12-04 00:00:00 -08:00
+default_executable: 
+dependencies: 
+- !ruby/object:Gem::Dependency 
+  name: hoe
+  type: :development
+  version_requirement: 
+  version_requirements: !ruby/object:Gem::Requirement 
+    requirements: 
+    - - ">="
+      - !ruby/object:Gem::Version 
+        version: 1.8.2
+    version: 
+description: Gauntlet is a pluggable means of running code against all the latest gems and storing off the data.
+email: 
+- ryand-ruby@zenspider.com
+executables: 
+- gauntlet
+extensions: []
+
+extra_rdoc_files: 
+- History.txt
+- Manifest.txt
+- README.txt
+files: 
+- History.txt
+- Manifest.txt
+- README.txt
+- Rakefile
+- bin/gauntlet
+- lib/gauntlet.rb
+- test/test_gauntlet.rb
+has_rdoc: true
+homepage: http://rubyforge.org/projects/seattlerb
+post_install_message: 
+rdoc_options: 
+- --main
+- README.txt
+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: []
+
+rubyforge_project: seattlerb
+rubygems_version: 1.3.1
+signing_key: 
+specification_version: 2
+summary: Gauntlet is a pluggable means of running code against all the latest gems and storing off the data.
+test_files: 
+- test/test_gauntlet.rb