rails_product 0.5

data/lib/breakpoint_client.rb

@@ -0,0 +1,196 @@
+require 'breakpoint'
+require 'optparse'
+require 'timeout'
+
+Options = {
+  :ClientURI  => nil,
+  :ServerURI  => "druby://localhost:42531",
+  :RetryDelay => 2,
+  :Permanent  => true,
+  :Verbose    => false
+}
+
+ARGV.options do |opts|
+  script_name = File.basename($0)
+  opts.banner = [
+    "Usage: ruby #{script_name} [Options] [server uri]",
+    "",
+    "This tool lets you connect to a breakpoint service ",
+    "which was started via Breakpoint.activate_drb.",
+    "",
+    "The server uri defaults to druby://localhost:42531"
+  ].join("\n")
+
+  opts.separator ""
+
+  opts.on("-c", "--client-uri=uri",
+    "Run the client on the specified uri.",
+    "This can be used to specify the port",
+    "that the client uses to allow for back",
+    "connections from the server.",
+    "Default: Find a good URI automatically.",
+    "Example: -c druby://localhost:12345"
+  ) { |Options[:ClientURI]| }
+
+  opts.on("-s", "--server-uri=uri",
+    "Connect to the server specified at the",
+    "specified uri.",
+    "Default: druby://localhost:42531"
+  ) { |Options[:ServerURI]| }
+
+  opts.on("-R", "--retry-delay=delay", Integer,
+    "Automatically try to reconnect to the",
+    "server after delay seconds when the",
+    "connection failed or timed out.",
+    "A value of 0 disables automatical",
+    "reconnecting completely.",
+    "Default: 10"
+  ) { |Options[:RetryDelay]| }
+
+  opts.on("-P", "--[no-]permanent",
+    "Run the breakpoint client in permanent mode.",
+    "This means that the client will keep continue",
+    "running even after the server has closed the",
+    "connection. Useful for example in Rails."
+  ) { |Options[:Permanent]| }
+
+  opts.on("-V", "--[no-]verbose",
+    "Run the breakpoint client in verbose mode.",
+    "Will produce more messages, for example between",
+    "individual breakpoints. This might help in seeing",
+    "that the breakpoint client is still alive, but adds",
+    "quite a bit of clutter."
+  ) { |Options[:Verbose]| }
+
+  opts.separator ""
+
+  opts.on("-h", "--help",
+    "Show this help message."
+  ) { puts opts; exit }
+  opts.on("-v", "--version",
+    "Display the version information."
+  ) do
+    id = %q$Id: breakpoint_client.rb 91 2005-02-04 22:34:08Z flgr $
+    puts id.sub("Id: ", "")
+    puts "(Breakpoint::Version = #{Breakpoint::Version})"
+    exit
+  end
+
+  opts.parse!
+end
+
+Options[:ServerURI] = ARGV[0] if ARGV[0]
+
+module Handlers
+  extend self
+
+  def breakpoint_handler(workspace, message)
+    puts message
+    IRB.start(nil, nil, workspace)
+
+    puts ""
+    if Options[:Verbose] then
+      puts "Resumed execution. Waiting for next breakpoint...", ""
+    end
+  end
+
+  def eval_handler(code)
+    result = eval(code, TOPLEVEL_BINDING)
+    if result then
+      DRbObject.new(result)
+    else
+      result
+    end
+  end
+
+  def collision_handler()
+    msg = [
+      "  *** Breakpoint service collision ***",
+      "  Another Breakpoint service tried to use the",
+      "  port already occupied by this one. It will",
+      "  keep waiting until this Breakpoint service",
+      "  is shut down.",
+      "  ",
+      "  If you are using the Breakpoint library for",
+      "  debugging a Rails or other CGI application",
+      "  this likely means that this Breakpoint",
+      "  session belongs to an earlier, outdated",
+      "  request and should be shut down via 'exit'."
+    ].join("\n")
+
+    if RUBY_PLATFORM["win"] then
+      # This sucks. Sorry, I'm not doing this because
+      # I like funky message boxes -- I need to do this
+      # because on Windows I have no way of displaying
+      # my notification via puts() when gets() is still
+      # being performed on STDIN. I have not found a
+      # better solution.
+      begin
+        require 'tk'
+        root = TkRoot.new { withdraw }
+        Tk.messageBox('message' => msg, 'type' => 'ok')
+        root.destroy
+      rescue Exception
+        puts "", msg, ""
+      end
+    else
+      puts "", msg, ""
+    end
+  end
+end
+
+# Used for checking whether we are currently in the reconnecting loop.
+reconnecting = false
+
+loop do
+  DRb.start_service(Options[:ClientURI])
+
+  begin
+    service = DRbObject.new(nil, Options[:ServerURI])
+
+    begin
+      ehandler = Handlers.method(:eval_handler)
+      chandler = Handlers.method(:collision_handler)
+      handler = Handlers.method(:breakpoint_handler)
+      service.eval_handler = ehandler
+      service.collision_handler = chandler
+      service.handler = handler
+
+      reconnecting = false
+      if Options[:Verbose] then
+        puts "Connection established. Waiting for breakpoint...", ""
+      end
+
+      loop do
+        begin
+          service.ping
+        rescue DRb::DRbConnError => error
+          puts "Server exited. Closing connection...", ""
+          exit! unless Options[:Permanent]
+          break
+        end
+
+        sleep(0.5)
+      end
+    ensure
+      service.eval_handler = nil
+      service.collision_handler = nil
+      service.handler = nil
+    end
+  rescue Exception => error
+    if Options[:RetryDelay] > 0 then
+      if not reconnecting then
+        reconnecting = true
+        puts "No connection to breakpoint service at #{Options[:ServerURI]} " +
+           "(#{error.class})"
+        puts error.backtrace if $DEBUG
+        puts "Tries to connect will be made every #{Options[:RetryDelay]} seconds..."
+      end
+
+      sleep Options[:RetryDelay]
+      retry
+    else
+      raise
+    end
+  end
+end

data/lib/code_statistics.rb

@@ -0,0 +1,104 @@
+class CodeStatistics
+  def initialize(*pairs)
+    @pairs      = pairs
+    @statistics = calculate_statistics
+    @total      = calculate_total if pairs.length > 1
+  end
+
+  def to_s
+    print_header
+    @pairs.each { |pair| print_line(pair.first, @statistics[pair.first]) }
+    print_splitter
+  
+    if @total
+      print_line("Total", @total)
+      print_splitter
+    end
+
+    print_code_test_stats
+  end
+
+  private
+    def calculate_statistics
+      @pairs.inject({}) { |stats, pair| stats[pair.first] = calculate_directory_statistics(pair.last); stats }
+    end
+
+    def calculate_directory_statistics(directory, pattern = /.*\.rb$/)
+      stats = { "lines" => 0, "codelines" => 0, "classes" => 0, "methods" => 0 }
+
+      Dir.foreach(directory) do |file_name| 
+        if File.stat(directory + "/" + file_name).directory? and (/^\./ !~ file_name)
+          newstats = calculate_directory_statistics(directory + "/" + file_name, pattern)
+          stats.each { |k, v| stats[k] += newstats[k] }
+        end
+
+        next unless file_name =~ pattern
+
+        f = File.open(directory + "/" + file_name)
+
+        while line = f.gets
+          stats["lines"]     += 1
+          stats["classes"]   += 1 if line =~ /class [A-Z]/
+          stats["methods"]   += 1 if line =~ /def [a-z]/
+          stats["codelines"] += 1 unless line =~ /^\s*$/ || line =~ /^\s*#/
+        end
+      end
+
+      stats
+    end
+
+    def calculate_total
+      total = { "lines" => 0, "codelines" => 0, "classes" => 0, "methods" => 0 }
+      @statistics.each_value { |pair| pair.each { |k, v| total[k] += v } }
+      total
+    end
+
+    def calculate_code
+      code_loc = 0
+      @statistics.each { |k, v| code_loc += v['codelines'] unless ['Units', 'Functionals'].include? k }
+      code_loc
+    end
+
+    def calculate_tests
+      test_loc = 0
+      @statistics.each { |k, v| test_loc += v['codelines'] if ['Units', 'Functionals'].include? k }
+      test_loc
+    end
+
+    def print_header
+      print_splitter
+      puts "| Name                 | Lines |   LOC | Classes | Methods | M/C | LOC/M |"
+      print_splitter
+    end
+
+    def print_splitter
+      puts "+----------------------+-------+-------+---------+---------+-----+-------+"
+    end
+
+    def print_line(name, statistics)
+      m_over_c   = (statistics["methods"] / statistics["classes"])   rescue m_over_c = 0
+      loc_over_m = (statistics["codelines"] / statistics["methods"]) - 2 rescue loc_over_m = 0
+
+      start = if ['Units', 'Functionals'].include? name
+        "|   #{name.ljust(18)} "
+      else
+        "| #{name.ljust(20)} " 
+      end
+
+      puts start + 
+           "| #{statistics["lines"].to_s.rjust(5)} " +
+           "| #{statistics["codelines"].to_s.rjust(5)} " +
+           "| #{statistics["classes"].to_s.rjust(7)} " +
+           "| #{statistics["methods"].to_s.rjust(7)} " +
+           "| #{m_over_c.to_s.rjust(3)} " +
+           "| #{loc_over_m.to_s.rjust(5)} |"
+    end
+
+    def print_code_test_stats
+      code  = calculate_code
+      tests = calculate_tests
+
+      puts "  Code LOC: #{code}     Test LOC: #{tests}     Code to Test Ratio: 1:#{sprintf("%.1f", tests.to_f/code)}"
+      puts ""
+    end
+  end

data/lib/console_sandbox.rb

@@ -0,0 +1,6 @@
+ActiveRecord::Base.lock_mutex
+ActiveRecord::Base.connection.begin_db_transaction
+at_exit do
+  ActiveRecord::Base.connection.rollback_db_transaction
+  ActiveRecord::Base.unlock_mutex
+end

data/lib/dispatcher.rb

@@ -0,0 +1,59 @@
+#--
+# Copyright (c) 2004 David Heinemeier Hansson
+#
+# 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.
+#++
+
+require 'breakpoint'
+
+class Dispatcher
+  class << self
+    def dispatch(cgi = CGI.new, session_options = ActionController::CgiRequest::DEFAULT_SESSION_OPTIONS, output = $stdout)
+      begin
+        request, response = ActionController::CgiRequest.new(cgi, session_options), ActionController::CgiResponse.new(cgi)
+        prepare_application
+        ActionController::Routing::Routes.recognize!(request).process(request, response).out(output)
+      rescue Object => exception
+        ActionController::Base.process_with_exception(request, response, exception).out(output)
+      ensure
+        reset_after_dispatch
+      end
+    end
+
+    def reset_application!
+      Controllers.clear!
+      Dependencies.clear
+      Dependencies.remove_subclasses_for(ActiveRecord::Base, ActiveRecord::Observer, ActionController::Base)
+      Dependencies.remove_subclasses_for(ActionMailer::Base) if defined?(ActionMailer::Base)
+    end
+    
+    private
+      def prepare_application
+        ActionController::Routing::Routes.reload if Dependencies.load?
+        Breakpoint.activate_drb("druby://localhost:#{BREAKPOINT_SERVER_PORT}", nil, !defined?(FastCGI)) if defined?(BREAKPOINT_SERVER_PORT) rescue nil
+        Controllers.const_load!(:ApplicationController, "application") unless Controllers.const_defined?(:ApplicationController)
+      end
+    
+      def reset_after_dispatch
+        reset_application! if Dependencies.load?
+        Breakpoint.deactivate_drb if defined?(BREAKPOINT_SERVER_PORT)
+      end
+  end
+end

data/lib/fcgi_handler.rb

@@ -0,0 +1,156 @@
+require 'fcgi'
+require 'logger'
+require 'dispatcher'
+
+class RailsFCGIHandler
+  SIGNALS = {
+    'HUP'  => :reload,
+    'TERM' => :graceful_exit,
+    'USR1' => :graceful_exit
+  }
+
+  attr_reader :when_ready
+
+  attr_accessor :log_file_path
+  attr_accessor :gc_request_period
+
+
+  # Initialize and run the FastCGI instance, passing arguments through to new.
+  def self.process!(*args, &block)
+    new(*args, &block).process!
+  end
+
+  # Initialize the FastCGI instance with the path to a crash log
+  # detailing unhandled exceptions (default RAILS_ROOT/log/fastcgi.crash.log)
+  # and the number of requests to process between garbage collection runs
+  # (default nil for normal GC behavior.)  Optionally, pass a block which
+  # takes this instance as an argument for further configuration.
+  def initialize(log_file_path = nil, gc_request_period = nil)
+    @when_ready = nil
+
+    self.log_file_path = log_file_path || "#{RAILS_ROOT}/log/fastcgi.crash.log"
+    self.gc_request_period = gc_request_period
+
+    # Yield for additional configuration.
+    yield self if block_given?
+
+    # Safely install signal handlers.
+    install_signal_handlers
+
+    # Start error timestamp at 11 seconds ago.
+    @last_error_on = Time.now - 11
+
+    dispatcher_log(:info, "starting")
+  end
+
+  def process!(provider = FCGI)
+    # Make a note of $" so we can safely reload this instance.
+    mark!
+
+    # Begin countdown to garbage collection.
+    run_gc! if gc_request_period
+
+    provider.each_cgi do |cgi| 
+      # Safely reload this instance if requested.
+      if when_ready == :reload
+        run_gc! if gc_request_period
+        restore!
+        @when_ready = nil
+        dispatcher_log(:info, "reloaded")
+      end
+
+      process_request(cgi)
+
+      # Break if graceful exit requested.
+      break if when_ready == :exit
+
+      # Garbage collection countdown.
+      if gc_request_period
+        @gc_request_countdown -= 1
+        run_gc! if @gc_request_countdown <= 0
+      end
+    end
+
+    GC.enable
+    dispatcher_log(:info, "terminated gracefully")
+
+  rescue SystemExit => exit_error
+    dispatcher_log(:info, "terminated by explicit exit")
+
+  rescue Object => fcgi_error
+    # retry on errors that would otherwise have terminated the FCGI process,
+    # but only if they occur more than 10 seconds apart.
+    if !(SignalException === fcgi_error) && Time.now - @last_error_on > 10
+      @last_error_on = Time.now
+      dispatcher_error(fcgi_error, "almost killed by this error")
+      retry
+    else
+      dispatcher_error(fcgi_error, "killed by this error")
+    end
+  end
+  
+  
+  private
+    def logger
+      @logger ||= Logger.new(@log_file_path)
+    end
+
+    def dispatcher_log(level, msg)
+      time_str = Time.now.strftime("%d/%b/%Y:%H:%M:%S")
+      logger.send(level, "[#{time_str} :: #{$$}] #{msg}")
+    rescue Object => log_error
+      STDERR << "Couldn't write to #{@log_file_path.inspect}: #{msg}\n"
+      STDERR << "  #{log_error.class}: #{log_error.message}\n"
+    end
+
+    def dispatcher_error(e,msg="")
+      error_message =
+        "Dispatcher failed to catch: #{e} (#{e.class})\n" +
+        "  #{e.backtrace.join("\n  ")}\n#{msg}"
+      dispatcher_log(:error, error_message)
+    end
+
+    def install_signal_handlers
+      SIGNALS.each do |signal, handler_name|
+        install_signal_handler signal, method("#{handler_name}_handler").to_proc
+      end
+    end
+
+    def install_signal_handler(signal, handler)
+      trap signal, handler
+    rescue ArgumentError
+      dispatcher_log :warn, "Ignoring unsupported signal #{signal}."
+    end
+
+    def graceful_exit_handler(signal)
+      dispatcher_log :info, "asked to terminate ASAP"
+      @when_ready = :exit
+    end
+
+    def reload_handler(signal)
+      @when_ready = :reload
+      dispatcher_log :info, "asked to reload ASAP"
+    end
+
+    def process_request(cgi)
+      Dispatcher.dispatch(cgi)
+    rescue Object => e
+      raise if SignalException === e
+      dispatcher_error(e)
+    end
+
+    def mark!
+      @features = $".clone
+    end
+
+    def restore!
+      $".replace @features
+      Dispatcher.reset_application!
+      ActionController::Routing::Routes.reload
+    end
+
+    def run_gc!
+      @gc_request_countdown = gc_request_period
+      GC.enable; GC.start; GC.disable
+    end
+end

data/lib/productize.rb

@@ -0,0 +1,116 @@
+SITE_ROOT = File.join(RAILS_ROOT, 'sites', SITE)
+
+# Load site-specific controllers and let them re-open their corresponding class
+module Dependencies
+  def require_or_load(file_name)
+    file_name = "#{file_name}.rb" unless ! load? || file_name[-3..-1] == '.rb'
+    load? ? load(file_name) : require(file_name)
+    if file_name.include? 'controller'
+      file_name = File.join(SITE_ROOT, 'app', 'controllers', File.basename(file_name))
+      if File.exist? file_name
+        load? ? load(file_name) : require(file_name)
+      end
+    end
+  end
+end
+
+# Prefer site-specific templates, partials etc. if they exist.  Otherwise, use the base
+# application's generic files.
+module ActionView
+  class Base
+    private
+      def full_template_path(template_path, extension)
+        # Check to see if the partial exists in our 'sites' folder first
+        site_specific_path = File.join(SITE_ROOT, 'app', 'views', template_path + '.' + extension)
+
+        if File.exist?(site_specific_path)
+          site_specific_path
+        else
+          "#{@base_path}/#{template_path}.#{extension}"
+        end
+      end
+  end
+end
+
+# Scoop up both the base's migration files (those that should apply to ALL sites), plus
+# the site-specific migration files.  Sort them.  Apply them in turn.
+module ActiveRecord
+  class Migrator
+  private
+    def migration_files
+      generic_files = Dir["#{@migrations_path}/[0-9]*_*.rb"].sort
+      puts generic_files.inspect
+      # Include the site-specific files in our complete list of migration files
+      if defined? SITE_ROOT and File.exist?("#{SITE_ROOT}/db/migrate")
+        # Note that a tilde (~) is used intentionally because its ascii value
+        # is greater than both the lower-case and upper-case alphabets (thereby
+        # causing the sort! below to behave as expected).
+        site_specific_files = Dir["#{SITE_ROOT}/db/migrate/[0-9]*\.[0-9]*_*.rb"]
+        files = generic_files + site_specific_files
+        # Sort by filename, ignoring the path to get there.  Also convert '.'
+        # to '~' so that sorting occurs in the correct order.
+        files.sort! { |a,b| a.gsub(".", "~").match(/.+[\/\\](.+)/)[1] <=> b.gsub(".", "~").match(/.+[\/\\](.+)/)[1] }
+      else
+        files = generic_files
+      end
+      down? ? files.reverse : files
+    end
+
+  end
+end
+
+# Make routes site-specific for sites whose config/routes.rb exists
+module ActionController
+  module Routing #:nodoc:
+    class RouteSet
+      def replace(*args)
+        new_route = Route.new(*args)
+        # Remove the old route that we're replacing
+        @routes.delete_if { |r| r.path == args[0] }
+        # Add the new one back
+        @routes << new_route
+        return new_route
+      end
+
+      def draw_append
+        yield self
+        write_generation
+        write_recognition
+      end
+
+      # Get both the base routes.rb file AND the site-specific routes.rb file
+      def reload
+        NamedRoutes.clear
+
+        loaded_routes = false
+
+        # Load the initial set of routes for the base application
+        if defined?(RAILS_ROOT) and File.exist?(File.join(RAILS_ROOT, 'config', 'routes.rb'))
+          load(File.join(RAILS_ROOT, 'config', 'routes.rb'))
+          loaded_routes = true
+        end
+
+        # Add on site-specific routes
+        if defined?(SITE_ROOT) and File.exist?(File.join(SITE_ROOT, 'config', 'routes.rb'))
+          load(File.join(SITE_ROOT, 'config', 'routes.rb'))
+          loaded_routes = true
+        end
+
+        # Use a sensible default if nothing could be loaded
+        unless loaded_routes
+          connect(':controller/:action/:id', :action => 'index', :id => nil)
+        end
+
+        NamedRoutes.install
+      end
+    end
+  end
+end
+
+# Put cached pages in the site-specific public folder
+ActionController::Base.page_cache_directory = "#{SITE_ROOT}/public"
+
+# Load any site-specific models
+# TODO: Make site-specific models re-open classes rather than
+# this temporary either/or hack
+ADDITIONAL_LOAD_PATHS.concat(Dir["#{SITE_ROOT}/app/models/[_a-z]*"])