homeschool 0.0.1

data/README

@@ -0,0 +1,3 @@
+Ruby-Subversion Bindings
+
+sudo port install subversion-ruby

data/Rakefile

@@ -0,0 +1,72 @@
+require 'rubygems'
+require 'rake/gempackagetask'
+
+task :default => :package
+
+#REV = File.read(".svn/entries")[/committed-rev="(\d+)"/, 1] rescue nil
+#VERS = ENV['VERSION'] || "0.1" + (REV ? ".#{REV}" : "")
+
+PKG_VERSION = '0.0.1' #{}`ruby -Ilib bin/homeschool -v`.chomp
+
+summary = "The homeschool gem"
+dependencies = [
+#  ['rails', '>= 1.2.2'],
+  ['metaid', '>= 1.0']
+]
+
+spec = Gem::Specification.new do |s|
+  s.name = 'homeschool'
+  s.version = PKG_VERSION
+  s.platform = Gem::Platform::RUBY
+  s.author = ['Paul Nicholson', 'Austin Taylor']
+  s.email = 'paul@webpowerdesign.net'
+  s.homepage = 'http://homeschool.rubyforge.org/'
+  s.rubyforge_project = 'homeschool'
+  s.summary = summary
+  s.description = <<EOF
+The Homeschool Way
+EOF
+#    s.test_file = "test/test_homeschool.rb"
+
+  s.has_rdoc = true
+  s.rdoc_options << '--title' << 'homeschool' << '--main' << 'README' << '--line-numbers' << '--inline-source'
+  s.extra_rdoc_files = %w(README)
+
+  s.required_ruby_version = '>= 1.8.4'
+  dependencies.each do |dep|
+      s.add_dependency(*dep)
+  end
+  s.requirements << 'none'
+  s.require_path = 'lib'
+  s.autorequire = "homeschool"
+
+  s.bindir = "bin"
+  s.executables = Dir.glob('bin/*').collect{|f| File.basename(f)}.flatten
+  s.default_executable = "homeschool"
+
+  s.files = %w(README Rakefile) + Dir.glob("{bin,doc,test,lib}/**/*")
+end
+
+Rake::GemPackageTask.new(spec) do |pkg|
+  pkg.need_zip = true
+  pkg.need_tar = true
+end
+
+desc "Run homeschool with ENV['ARGS']"
+task :run do
+  ruby %(-Ilib bin/homeschool #{ENV['ARGS']})
+end
+
+desc "Run svm with ENV['ARGS']"
+task :svm do
+  ruby %(-Ilib bin/svm #{ENV['ARGS']})
+end
+
+desc "Install the homeschool gem package"
+task :install => :package do
+  if RUBY_PLATFORM =~ /mswin32/
+    sh %(gem.bat install pkg\\homeschool-#{PKG_VERSION}.gem)
+  else
+    sh %(sudo gem install pkg/homeschool-#{PKG_VERSION}.gem)
+  end
+end

data/bin/bfight

@@ -0,0 +1,31 @@
+#!/usr/bin/env ruby
+require File.join(File.dirname(__FILE__), '../lib/fight')
+class BibleFight < Fight
+  TRANSLATIONS = {
+    :niv => 31,
+    :nasb => 49,
+    :nlt => 51,
+    :kjv => 9,
+    :esv => 47,
+    :nkjv => 50,
+    :asv => 8,
+    :hcsb => 77,
+  }
+  def url_for(contestant)
+    "http://www.biblegateway.com/quicksearch/?quicksearch=#{CGI::escape(contestant)}&qs_version=#{@translation[1]}"
+  end
+  def pattern
+    /Keyword search results<\/div><span[^>]*>([\d]+) Results<\/span>/
+  end
+  def process_options
+    @translation = TRANSLATIONS.detect(lambda{[:kjv, 9]}) do |pair|
+      ARGV.delete("-#{pair[0]}")
+    end
+    super
+  end
+  def fight!
+    super
+    puts "(#{@translation[0].to_s.upcase})"
+  end
+end
+BibleFight.new

data/bin/gfight

@@ -0,0 +1,12 @@
+#!/usr/bin/env ruby
+require File.join(File.dirname(__FILE__), '../lib/fight')
+# TODO: +suffix
+class GoogleFight < Fight
+  def url_for(contestant)
+    "http://google.com/search?q=#{CGI::escape(contestant)}"
+  end
+  def pattern
+    /Results <b>1<\/b> - <b>\d+<\/b> of (?:about )?<b>([\d,]+)<\/b>/
+  end
+end
+GoogleFight.new

data/bin/homeschool

@@ -0,0 +1,2 @@
+#!/usr/bin/env ruby
+p 0.0.1

data/bin/svm

@@ -0,0 +1,388 @@
+#!/usr/bin/env ruby
+require 'homeschool'
+require 'svn/core'
+require 'svn/client'
+require 'svn/wc'
+require 'svn/repos'
+require 'rubygems'
+gem 'activesupport'
+require 'active_support'
+# Copyright (c) 2006 Nathaniel Talbott and Terralien. All Rights Reserved.
+# Licensed under the RUBY license.
+require 'optparse'
+class CoolOptions
+  def self.parse!(*args)
+    o = new
+    yield o
+    o.parse!(*args)
+  rescue RuntimeError => e
+      puts e.message
+      o.help true
+  end
+  
+  def initialize
+    @options = []
+  end
+  
+  def on(key, long, message, default=nil, short=nil)
+    unless short
+      short = if /^\[/ =~ long
+        long.split(/\]/).last
+      else
+        long
+      end[0,1]
+    end
+    @options << [key, short, long, message, default]
+  end
+  
+  def parse!(banner="[options]", version = nil)
+    result = {}
+    required = []
+    OptionParser.new do |o|
+      @o = o
+      o.banner = "Usage: #{File.basename($0)} #{banner}"
+
+      @options.each do |(key, short, long, message, default)|
+        if short != ''
+          args = ["-#{short}", "--#{long}", message]
+        else
+          args = ["--#{long}", message]
+        end
+        if default.nil?
+          required << key
+        else
+          result[key] = default == '' ? nil : default
+          args << "Default is: #{default}" unless default == ''
+        end
+        o.on(*args){|e| result[key] = e}
+      end
+      
+      o.on('--version', "Version info."){puts version; exit(0)} if version
+      o.on('-h', '--help', "This help info."){help}
+    end.parse!
+    required.reject!{|e| result.key?(e)}
+    raise "Missing required options: #{required.join(', ')}" unless required.empty?
+    result[:help] = method(:help).to_proc
+    @after.call(result) if @after
+    result
+  end
+  
+  def after(&after)
+    @after = after
+  end
+  
+  def help(error=false)
+    puts @o
+    exit (error ? 1 : 0)
+  end
+end
+
+class SVM
+  def self.run
+    new
+  end
+  
+  def initialize
+    @argv = ARGV.dup
+    @options = CoolOptions.parse!("<subcommand> [options] [args]", '0.0.1') do |o|
+      SVM.send(%{options_for_#{ARGV.first}}.to_sym, o) if SVM.respond_to?(%{options_for_#{ARGV.first}}.to_sym)
+      o.on :show_updates, 'show-updates', 'display update information', false, 'u'
+      o.on :non_recursive, 'non-recursive', 'operate on single directory only', false, 'N'
+      o.on :ignore_externals, 'ignore-externals', 'ignore externals definitions', false, ''
+      o.on :verbose, 'verbose', 'print extra information', false, 'v'
+      o.on :repository,       "repository URL",        "Remote subversion repository.", ''          
+      #  
+      o.after do |options|
+        @subcommand = ARGV.first
+        @args = ARGV[1...ARGV.length]
+      end
+    end
+    send(@subcommand || :help)
+  end
+  
+  def self.options_for_ignore(cool_opts)
+    cool_opts.on :recursive, 'recursive', 'descend recursively', false, 'R'
+  end
+  
+  def add
+    if @args.first == ':all'
+      p 'all'
+    else
+      SVN.add(File.expand_path(@args.first||""), @options)
+    end
+  end
+  
+  def ignore
+    puts @args.inspect
+    path = File.expand_path(@args.first||"")
+    SVN.ignore(path, @options)
+  end
+  
+  def proplist
+    SVN.proplist(File.expand_path(@args.first||""), @options)
+  end
+    
+  def update
+    SVN.update(File.expand_path(@args.first||""), @options)
+  end
+  alias :up :update
+  
+  def method_missing(method)
+    exec "svn #{@argv.join ' '}"
+  rescue
+    help
+  end
+end
+
+class SVN
+  class << self
+    def ignore(path, options={})
+      svn_client.propset('svn:ignore', File.basename(path), File.dirname(path), *options.list(:recursive, :force))
+    rescue 
+      puts exception($!, path)
+    end
+    
+    def notify(msg)
+      p msg.inspect
+      p msg.action
+      p clean_path(msg.path)
+    end
+    
+    private
+      def svn_client
+        @svn_client ||= initialize_client
+      end
+      
+      def initialize_client
+        ctx = Svn::Client::Context.new
+        ctx.add_simple_provider
+        ctx.set_notify_func(&method(:notify))
+        ctx
+      end
+      
+      def exception(type, path=nil)
+        case type
+          when Svn::Error::ENTRY_EXISTS
+            %(svm: warning: '#{clean_path(path)}' is already under version control)
+          when Svn::Error::WC_PATH_NOT_FOUND
+            %(svm: warning: '#{clean_path(path)}' not found)
+          when Svn::Error::WC_NOT_DIRECTORY
+            %(svm: '#{clean_path(path)}' is not a working copy)
+          else
+            raise
+        end
+      end
+      
+      def clean_path(path)
+        path.gsub!(%{#{Dir.getwd}/}, '')
+      end
+  end
+  
+  def self.method_missing(method, *args)
+    new.send(method, *args)
+  end
+  
+  def initialize
+    @svn_client = ctx = Svn::Client::Context.new
+    ctx.add_simple_provider
+    ctx.set_notify_func(&method(:notify))
+  end
+  
+  def initialize_statuses
+    SvnStatus.add(0, :default => { :short_status => ' ' })
+  end
+  
+  def add(path, options={})
+    @svn_client.add(path)
+  rescue 
+    puts exception($!, path)
+  end
+  
+  def update(path, options={})
+    p 'update'
+  end
+  
+  def notify(msg)
+    p msg.action
+    p clean_path(msg.path)
+  end
+  
+  def exception(type, path=nil)
+    case type
+      when Svn::Error::ENTRY_EXISTS
+        %(svm: warning: '#{clean_path(path)}' is already under version control)
+      when Svn::Error::WC_PATH_NOT_FOUND
+        %(svm: warning: '#{clean_path(path)}' not found)
+      else
+        raise
+    end
+  end
+  
+  private
+    def clean_path(path)
+      path.gsub!(%{#{Dir.getwd}/}, '')
+    end
+end
+
+# class SVNproxy
+#   def initialize
+#     @argv = ARGV.dup
+#     @options = CoolOptions.parse!("<subcommand> [options] [args]", '0.0.1') do |o|
+#       o.on :show_updates, 'show-updates', 'display update information', false, 'u'
+#       o.on :non_recursive, 'non-recursive', 'operate on single directory only', false, 'N'
+#       o.on :ignore_externals, 'ignore-externals', 'ignore externals definitions', false, ''
+#       o.on :verbose, 'verbose', 'print extra information', false, 'v'
+#       o.on :repository,       "repository URL",        "Remote subversion repository.", ''          
+#       #  
+#       o.after do |options|
+#         @subcommand = ARGV.first
+#         @args = ARGV[1...ARGV.length]
+#       end
+#     end
+#     @status = [
+#         :none,
+#         :unversioned,
+#         :normal,
+#         :added,
+#         :missing,
+#         :deleted,
+#         :replaced,
+#         :modified,
+#         :merged,
+#         :conflicted,
+#         :ignored,
+#         :obstructed,
+#         :external,
+#         :incomplete
+#       ]
+#     @svn_client = ctx = Svn::Client::Context.new
+#     ctx.add_simple_provider
+#     send(@subcommand || :help)
+#   end
+#   
+#   def add
+#     #support :all
+#   end
+#   
+#   def remove
+#     #support :all
+#   end
+#   
+#   def commit
+#     #prompt
+#     #prompt if new_files?
+#   end
+#   alias ci commit
+#   
+#   def revert
+#     #support :all
+#   end
+#   
+#   def update
+#     #update externals in background
+#   end
+#   def status(type=nil)
+#     modified, unversioned = [], []
+#     #status(path, rev=nil, recurse=true, get_all=false, update=true, no_ignore=false, ignore_externals=false, &status_func)
+#     @svn_client.status(File.expand_path(@args.first||""), 'HEAD', !@options[:non_recursive], false, *@options.list(:show_updates, :no_ignore, :ignore_externals)) do |path, status|
+#       path.gsub!(%{#{Dir.getwd}/}, '')
+#       case get_status(status.text_status, status.repos_text_status)
+#         when [:added, :none]
+#           puts status_line('A', status) + path
+#         when [:modified, :none]
+#           puts status_line('M', status) + path
+#           modified << path
+#         when [:conflicted, :none]
+#           puts status_line('C', status) + path
+#           conflicted << path
+#         when [:external, :none]
+#           puts status_line('X', status) + path
+#           external << path
+#         when [:unversioned, :none]
+#           puts status_line('?', status) + path
+#           unversioned << path
+#         when [:normal, :none]
+#           puts status_line(' ', status) + path
+#         else
+#           puts %{#{path} :: #{get_status(status.text_status, status.repos_text_status).inspect} :: #{status.entry.nil?}}
+#       end
+#       if verbose?
+#         puts get_status(status.text_status, status.repos_text_status).inspect
+#         $stdout.puts path
+#         status.public_methods.each{|name|
+#           puts(".....#{name}: #{status.send(name)}") unless name =~/=$/ || Object.new.public_methods.include?(name) || [].include?(name)
+#         }
+#         puts "\n"
+#         status.entry.public_methods.each{|name|
+#           puts(".....#{name}: #{status.entry.send(name)}") unless name =~/=$/ || Object.new.public_methods.include?(name) || ['conflicted?','conflicted','prop_conflicted?','text_conflicted?'].include?(name)
+#         } unless status.entry.nil?
+#         puts "\n"
+#       
+#         status.repos_lock.public_methods.each{|name|
+#           puts(".....#{name}: #{status.repos_lock.send(name)}") unless name =~/=$/ || Object.new.public_methods.include?(name) || [].include?(name)
+#         } if status.repos_lock
+#       end
+#       [unversioned, modified]
+#     end
+#   end
+#   alias st status
+#   
+#   def help
+#     @options[:help].call
+#   end
+#   
+#   def verbose?
+#     return @options[:verbose]
+#   end
+#   
+#   def method_missing(method)
+#       #exec "svn #{@argv.join ' '}"
+#     rescue
+#       help
+#     end
+#   private
+#     def get_status(*status_ids)
+#       status_ids.collect{|status_id| @status[status_id -1]}.flatten
+#     end
+#     
+#     def status_line(text, status)
+#       %{#{text}   #{status.switched ? 'S' : ' '}#{lock_type(status)} }
+#     end
+#     
+#     def locked?
+#     
+#     end
+#     
+#     def lock_type(status)
+#       case true
+#         when !status.entry.nil? && !status.entry.lock_token.nil?
+#           'K'
+#         when status.repos_lock && status.entry.lock_token.nil?
+#           'O'
+#         else
+#           '$'
+#       end 
+#     end
+# end
+SVM.run
+#SVNproxy.new
+
+class SvnStatus
+  class << self
+    def add(integer, status)
+      statuses[integer].update(status)
+    end
+    
+    def short_status(integer, type)
+      statuses[integer][type||:default][:short_status]
+    end
+    
+    def status(integer, type)
+      statuses[integer][type||:default][:status]
+    end
+    
+    def statuses
+      @statuses || []
+    end
+  end
+end

data/lib/fight.rb

@@ -0,0 +1,26 @@
+require 'open-uri'
+require 'cgi'
+
+class Fight
+  def initialize
+    process_options
+    fight!
+  end
+  def process_options
+    @quote = !!ARGV.delete("-q")
+  end
+  def contestants
+    ARGV.to_a
+  end
+  def fight!
+    contestants.collect do |contestant|
+      contestant = %{"#{contestant}"} if @quote
+      page = open(url_for(contestant)).read
+      match = page.match(pattern)
+      count = match ? match[1] : '0'
+      [count, contestant]
+    end.sort_by {|result| result[0].gsub(',', '').to_i}.reverse.each do |result|
+      puts result * ' -- '
+    end
+  end
+end

data/lib/form_buildr.rb

@@ -0,0 +1,48 @@
+#
+# == Provides an additional set of methods for working with forms.
+#  See ActionView::Helpers::FormHelper in the Rails API docs
+#
+# Author::    Paul Nicholson  (mailto:paul@webpowerdesign.net)
+# Co-Author:: Austin Taylor
+# Copyright:: Copyright (c) 2006 Paul Nicholson & Austin Taylor
+# License::   Distributes under the same terms as Rails
+#
+# ==== Usage
+#   <% form_for :person, @person, :url => { :action => "update" } do |f| %>
+#     <%= f.label_for :first_name %> <%= f.text_field :first_name %>
+#     <%= f.labeled_text_field :last_name %>
+#   <% end %>
+#
+# === Methods
+# ==== label_for(method, options={})
+# Returns a label opening and closing tag set tailored for accessing a specified form element(identified by 
+# Additional options on the label tag can be passed as a hash with options.
+#
+# ====== Additional Options
+# * :label => The text used as the label(default is method.humanize)
+#
+# ====== Example (call, result):
+#   label_for(:name)
+#     <label class="fieldLabel" for="person_name">Name:</label>
+#
+# ==== labeled_*(method, options={})
+# Returns a label opening and closing tag set and calls the referenced form builder method
+#
+# ====== Additional Options
+# * See <tt>label_for</tt> and the form builder method docs 
+#
+# ====== Example (call, result):
+#   labeled_text_field(:name)
+#     <label class="fieldLabel" for="person_name">Name:</label>
+#     <input id="person_name" name="person[name]" size="30" type="text" />
+#   
+class ActionView::Helpers::FormBuilder
+  rdef(/labeled_(.*)/) do |match, *args|
+    return send(:label_for, *args) + send(match[1].to_sym, *args)
+  end
+  
+  def label_for(method, options={})
+    options = {:label => options} if options.is_a? String
+    %{<label class="fieldLabel" for="#{@object_name}_#{method}">#{options[:label] || method.to_s.humanize.singularize}#{":" if !options[:no_colon]}</label>}
+  end
+end

data/lib/homeschool.rb

@@ -0,0 +1,136 @@
+require 'rubygems'
+require 'metaid'
+require 'active_support'
+
+class Symbol
+  def self.pattern(name, pattern, &formation)
+    define_method(name) {to_s.match(pattern) ? self : formation.call(self).to_sym}
+    define_method(name.question) {to_s.match(pattern)}
+  end
+  pattern(:question, /\?$/) {|s| "#{s}?"}
+  pattern(:bang, /!$/) {|s| "#{s}!"}
+  pattern(:writer, /=$/) {|s| "#{s}="}
+  pattern(:iv, /^@[^@]/) {|s| "@#{s}"}
+end
+
+class Range
+  def intersect?(other)
+    include?(other.first) || include?(other.last)
+  end
+end
+
+class Object
+  def iv_cache(method)
+    method = method.to_sym.iv
+    instance_variable_set(method, yield) unless instance_variable_get(method)
+    instance_variable_get(method)
+  end
+
+  def dom_ids
+    @dom_ids ||= Hash.new
+  end
+  def dom_id(*suffixes)
+    name = suffixes.empty? ? 'element' : suffixes.collect(&:to_s).join('_')
+    dom_ids[name] = [self.class.name.underscore, self.id, *suffixes].compact.join('_')
+  end
+  
+  def self.pattern_methods
+    @pattern_methods ||= (superclass && superclass.pattern_methods && superclass.pattern_methods.dup) || []
+  end
+  
+  def self.rdef(pattern, &block)
+    pattern_methods << [/^#{pattern.source}$/, block]
+  end
+  private
+  def method_missing(method, *args, &block)
+    match = self.class.pattern_methods.detect do |(pattern, block)|
+      method.to_s =~ pattern
+    end
+    raise super unless match
+    match[1].bind(self).call(*([$~] + args), &block)
+  end
+  
+  def once(*args)
+    args << :called_once
+    key = args.map(&:to_s).join('_').to_sym.iv
+    yield unless instance_variable_get(key)
+  ensure
+    instance_variable_set(key, true)
+  end
+end
+
+class Module
+  def attr_with_default(name, default=nil, &block)
+    attr_writer name
+    define_method(name) do
+      once(name, :set_default) do
+        instance_variable_set(name.iv, block_given? ? block.call : default.dup) unless instance_variable_get(name.iv)
+      end
+      instance_variable_get(name.iv)
+    end
+  end
+
+  def pattern_methods
+    @pattern_methods ||= []
+  end
+  def rdef(pattern, &block)
+    pattern_methods << [/^#{pattern.source}$/, block]
+  end
+  def append_features_with_pattern_methods(target)
+    append_features_without_pattern_methods(target)
+    target.pattern_methods.push(*pattern_methods) if (@pattern_methods)
+  end
+  alias_method :append_features_without_pattern_methods, :append_features
+  alias_method :append_features, :append_features_with_pattern_methods
+end
+
+module Enumerable
+  def without(*args)
+    reject &args.method(:include?)
+  end
+  def intersect(other)
+    select &other.method(:include?)
+  end
+  def min_by(&block)
+    min {|a,b| block.call(a) <=> block.call(b)}
+  end
+  def max_by(&block)
+    max {|a,b| block.call(a) <=> block.call(b)}
+  end
+  def average(&block)
+    sum(&block)/length
+  end
+end
+
+class Array
+  def includes_any?(array)
+    array.any? &method(:include?)
+  end
+  def includes_all?(array)
+    array.all? &method(:include?)
+  end
+  def includes_only?(array)
+    array.length == length && includes_all?(array)
+  end
+end
+
+class Hash
+  def to_obj
+    returning Object.new do |obj|
+      each do |key, value|
+        obj.meta_def key.to_sym do value end
+      end
+    end
+  end
+  def filter(*keys)
+    keys.inject({}) do |h, key|
+      h[key] = self[key]; h
+    end
+  end
+  def list(*keys)
+    keys.collect &method(:[])
+  end
+end
+
+require 'standardized_test' if defined?(RAILS_ENV) && RAILS_ENV  == 'test'
+require 'tame_rails' if defined?(RAILS_ENV)

data/lib/standardized_test.rb

@@ -0,0 +1,71 @@
+require 'test/unit'
+module Test::Unit::Assertions
+  def diff(one, two)
+    prefix = 0
+    (0...[one, two].min_by(&:length).length).each do |i|
+      if one[i] == two[i]
+        prefix = i + 1
+      else
+        break
+      end
+    end
+    "Expected <#{diff_format(one, prefix)}> but was <#{diff_format(two, prefix)}>"
+  end
+  def diff_format(string, prefix)
+    prefix > 0 ? "...#{string[prefix..-1]}" : string
+  end
+  def assert_equal_with_diffing(expected, actual, message=nil)
+    if message == :diff
+      assert_block(diff(expected, actual)) {expected == actual}
+    else
+      assert_equal_without_diffing(expected, actual, message)
+    end
+  end
+  alias_method :assert_equal_without_diffing, :assert_equal
+  alias_method :assert_equal, :assert_equal_with_diffing
+end
+
+module HomeschoolTestHelper
+  def assert_json(expected, actual)
+    assert_equal JSON.parse(expected), JSON.parse(actual)
+  end
+  def assert_difference(klass, method, difference=1, &block)
+    old = klass.send(method)
+    block.call
+    assert_equal old + difference, klass.send(method)
+  end
+  def assert_no_difference(klass, method, &block)
+    assert_difference(klass, method, 0, &block)
+  end
+  def assert_fails
+    yield
+    passed = true
+  rescue
+  ensure
+    assert !passed
+  end
+
+  def HomeschoolTestHelper.included(klass)
+    klass.rdef(/last_(.*)/) do |match|
+      match[1].classify.constantize.find(:all).last
+    end
+    class << klass; alias_method :old_fixtures, :fixtures; end if klass.respond_to?(:fixtures)
+    class << klass
+      def fixtures(*fixtures)
+        old_fixtures(*fixtures) if respond_to?(:old_fixtures) && !fixtures.delete(:ignore_old_fixtures)
+        fixtures.each do |fixture|
+          fixture_class = fixture.to_s.classify.constantize
+          rdef(/.*#{fixture_class.name.underscore}.*/) do |match, *options|
+            iv_cache(match[0]) do
+              options = {:save => true}.merge(options[0] || {})
+              save = options.delete(:save)
+              instance = fixture_class.new(options)
+              instance.save if save && instance.respond_to?(:save)
+              instance
+            end
+          end
+        end
+      end
+    end
+  end
+end

data/lib/tame_rails.rb

@@ -0,0 +1,19 @@
+require 'form_buildr'
+
+# Add find_object, model_name
+class ActionController::Base
+  def self.find_object(options={})
+    find_by_id(model_name, {:only => [:update, :edit, :show, :destroy]}.merge(options))
+  end
+
+  def self.find_by_id(klass, options={})
+    options = {:name => klass.name.underscore, :param => :id}.merge(options)
+    before_filter options.filter(:only, :except) do |controller|
+      controller.send(:instance_variable_set, options[:name].to_sym.iv, klass.find(controller.params[options[:param]]))
+    end
+  end
+
+  def self.model_name
+    name.sub(/Controller$/, '').singularize.constantize
+  end
+end

metadata

@@ -0,0 +1,73 @@
+--- !ruby/object:Gem::Specification 
+rubygems_version: 0.9.2
+specification_version: 1
+name: homeschool
+version: !ruby/object:Gem::Version 
+  version: 0.0.1
+date: 2007-08-24 00:00:00 -04:00
+summary: The homeschool gem
+require_paths: 
+- lib
+email: paul@webpowerdesign.net
+homepage: http://homeschool.rubyforge.org/
+rubyforge_project: homeschool
+description: The Homeschool Way
+autorequire: homeschool
+default_executable: homeschool
+bindir: bin
+has_rdoc: true
+required_ruby_version: !ruby/object:Gem::Version::Requirement 
+  requirements: 
+  - - ">="
+    - !ruby/object:Gem::Version 
+      version: 1.8.4
+  version: 
+platform: ruby
+signing_key: 
+cert_chain: 
+post_install_message: 
+authors: 
+- - Paul Nicholson
+  - Austin Taylor
+files: 
+- README
+- Rakefile
+- bin/bfight
+- bin/gfight
+- bin/homeschool
+- bin/svm
+- lib/fight.rb
+- lib/form_buildr.rb
+- lib/homeschool.rb
+- lib/standardized_test.rb
+- lib/tame_rails.rb
+test_files: []
+
+rdoc_options: 
+- --title
+- homeschool
+- --main
+- README
+- --line-numbers
+- --inline-source
+extra_rdoc_files: 
+- README
+executables: 
+- bfight
+- gfight
+- homeschool
+- svm
+extensions: []
+
+requirements: 
+- none
+dependencies: 
+- !ruby/object:Gem::Dependency 
+  name: metaid
+  version_requirement: 
+  version_requirements: !ruby/object:Gem::Version::Requirement 
+    requirements: 
+    - - ">="
+      - !ruby/object:Gem::Version 
+        version: "1.0"
+    version: