blacklight_cql 0.9.0

data/MIT-LICENSE

@@ -0,0 +1,20 @@
+Copyright (c) 2010 [name of plugin creator]
+
+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/README.rdoc

@@ -0,0 +1,142 @@
+= Blacklight-cql
+
+An extension for the Blacklight solr search front-end.  
+
+http://projectblacklight.org
+
+http://github.com/projectblacklight/blacklight
+
+Provides for CQL search queries that map to Solr and Blacklight fields.
+
+
+= Installation
+
+Add to your local app's environment.rb:
+ config.gem "blacklight_cql"
+
+Run "rake gems:install".  That's it, you now have CQL support in your Blacklight.  
+
+See below for optional configuration to change default behavior.  
+
+= Use
+
+ http://your.blacklight.com/catalog?search_field=cql&q=[uri-encoded cql query]
+ 
+Or for an atom response for instance, 
+
+ http://your.blacklight.com/catalog.atom?search_field=cql&q=[uri-encoded cql query]
+
+See http://www.loc.gov/standards/sru/specs/cql.html for more info on CQL syntax and semantics. 
+ 
+Any search_field you have configured in Blacklight.config[:search_fields] (probably in your config/blacklight_config.rb) is available as a CQL index.  These search fields are only available with the custom "solr.dismax" CQL relation, taking a CQL expression as a value.
+
+  some_field solr.dismax "term +required -negate \"a phrase\" "
+  
+For dismax fields, the "=" server-choice relation means the same thing:
+
+  some_field = "term +required -negate \"a phrase\" "
+
+Any Solr indexed field is also available as a CQL index. A much greater range of CQL relations are supported when you specify a Solr indexed field directly.  
+
+  solr_field cql.adj "some phrase" AND solr_year within "1990 2000"
+  
+Solr indexed field CQL support is provided by the cql_ruby gem, for details on relations supported see: http://cql-ruby.rubyforge.org/svn/trunk/lib/cql_ruby/cql_to_solr.rb
+  
+If there is a direct solr indexed field with the same name as a Blacklight-configured dismax field, the BL field will take precedence. You can use explicit CQL "context set" prefixes to disambiguate.
+
+[lsolr.field]
+  "lsolr" prefix means a direct solr indexed field
+[local.some_field]
+  "local" prefix means a dismax field configured in Blacklight.config[:search_fields]
+
+These prefixes can be changed, see configuration below. 
+
+Raw solr fields and Blacklight config'ed fields CAN be mixed together in a single CQL query. 
+
+  (lsolr.title_t any "one two three" AND lsolr.author_t all "smith john") OR local.title = "my dismax title query"
+  
+CQL *does* need to be URL escaped in a URL, of course:
+
+  http://some.blacklight.com/catalog.atom?search_field=cql&q=%28lsolr.title_t+any+%22one+two+three%22+AND+lsolr.author_t+all+%22smith+john%22%29+OR+local.title+%3D+%22my+dismax+title+query%22
+
+For "solr.dismax" or "=" relations, the the cql.serverChoice index maps to your default blacklight-configed field and solr.dismax relation.  Otherwise, it maps to a direct solr field query with "adj", and the solr indexed field generally ends up being "text", although this depends on your configuration. 
+
+= SRU/ZeeRex Explain
+
+This plugin does *not* provide a full SRU server. However, a ZeeRex/SRU explain document is provided by the plugin to advertise, in machine-readable format, what CQL indexes (ie, search fields) are provided by the server, and what relations are supported on each search field. 
+
+The explain document can be found at /catalog/explain on your server. (This URL end-point is not presently configurable). 
+
+For solr fields themselves, the plugin finds them via a Solr luke request, looking for any field that is Indexed in solr,  and advertising it. (If you have configured lucene indexes directly not through solr, they will likely be erroneously included in the explain as well). 
+
+For Blacklight fields, Blacklight.config[:search_fields] is used to discover fields to put in the Explain.  
+
+Note that at present only the custom solr.dismax relation is supported on Blacklight fields. Most of the standard CQL relations are supported on raw solr fields. 
+
+
+= Configuration
+
+== URL cql key, and cql label
+
+A psuedo-blacklight-search-field is added by the Cql plugin to indicate a CQL search in the URL and BL processing.  You can change the definition of this psuedo-field however you want to change the URL search_field key, the label for a CQL search echoed back to the user in HTML, or even to add some additional Solr parameters for the top-level Solr query for CQL searches. The value is a hash with the same semantics as other Blacklight.config[:search_fields] elements.  
+
+In an initializer:
+ BlacklightCql::SolrHelperExtension.psuedo_search_field = {
+  :key => "super_search", 
+  :display_label => "The Super Search",
+  :solr_parameters => { "mm" => "100%" }
+ }
+
+== Dismax search field configuration
+ 
+All fields configured in Blacklight.config[:search_fields] are available as CQL indexes. If you'd like to make more dismax-configured search fields available in CQL but not the standard HTML search select menu, simply add them with :show_in_simple_select = false, eg:
+
+  Blacklight.config[:search_fields] << {:key => "only_in_cql", :show_in_simple_select => false, :local_solr_parameters => { :qf => "$my_special_qf"}} 
+
+As in the example above, you may want to use :local_solr_parameters referencing dollar-sign parameters that will be defined in your solrconfig.xml and de-referenced by Solr. This will keep your CQL-generated Solr querries a lot more readable in your logs and debugging. However, this feature is not available in Blacklight 2.5 (edge, or future 2.6). 
+  
+Simply supplying literal values in :solr_paramaters is also supported and will work fine, it will just result in very long search querries in your solr query log.
+
+== CQL context set prefixes
+
+You can change the CQL "context set" prefix used for specifying a CQL index that is a direct solr field, or a Blacklight dismax configured field.  In a Rails initializer:
+
+ CqlRuby.to_solr_defaults[:solr_field_prefix] = "my_solr"
+ CqlRuby.to_solr_defaults[:blacklight_field_prefix] = "my_blacklight_fields"
+
+== Defaults from CqlRuby for direct solr indexed field querries. 
+
+For direct-solr-field operations, there are additional defaults that can be set, supported by CqlRuby. See: http://cql-ruby.rubyforge.org/svn/trunk/lib/cql_ruby/cql_to_solr.rb
+
+Eg:
+
+  CqlRuby.to_solr_defaults[:default_index] = "solr_index"
+  CqlRuby.to_solr_defaults[:all_index] = "solr_mega_index"
+  CqlRuby.to_solr_defaults[:default_relation] = "cql.any"
+  
+= TO DO
+
+* Support more CQL relations on blacklight dismax fields. Right now only dismax queries are supported. We could also support:
+  * cql.all (set mm to 100%)
+  * cql.adj (phrase search with qs set to 0)
+  * cql.any 
+  * range querries on dismax fields? Maybe. <, <=, >, >=, within
+  * <> on dismax fields, similar to how it works on raw solr. 
+* Is there a simple way to support CQL PROX boolean operator? Not sure. That's a weird operator in CQL, it makes it possible to specify things which make no sense, like onefield = val PROX anotherfield=val2 
+* Support CQL sortBy clauses mapped to Blacklight sort param. We can't tell which solr fields are available for sorting solely from luke, will need additional config to advertise in Explain. 
+* Add CQL relation modifiers on solr.dismax that let you specify arbitrary solr/dismax query parameters. (Add to solr context set too). 
+* Support relation modifier on cql.adj that maps to qs
+* support CQL context set 'fuzzy' modifier, to have some effect on mm, ps, qs, etc. 
+* *Big one*:  Figure out how to embed the explain and advertise the CQL in the BL OpenSearch description (including OpenSearch response in Atom).  Tricky from BL architecture to inject this into BL, also some dispute about the best way for the actual XML to look to support this. 
+
+= Use without Blacklight?
+
+Most of the code in this plugin was written to potentially be useful in other projects, not Blacklight, not neccesarily even Rails.  However, the gem initialization code assumes Blacklight in order to insert it's hooks into Blacklight properly. This can probably be refactored to make it easier to use this gem in a non-BL or even non-Rails app, let me know if you are someone who has an actual need/plan for this, and I can possibly help.  
+
+= Acknolwedgements
+
+Thanks to Chick Markley for writing the CqlRuby gem that provides the fundamental functionality here, and for making me a committer on the project. Thanks to Mike Taylor for writing the original Java CQL parser that Chick's work was based on. 
+
+
+
+Copyright 2010 Jonathan Rochkind/Johns Hopkins University, released under the MIT license

data/Rakefile

@@ -0,0 +1,43 @@
+require 'rake'
+require 'rake/testtask'
+require 'rake/rdoctask'
+
+desc 'Default: run unit tests.'
+task :default => :test
+
+desc 'Test the blacklight_cql plugin.'
+Rake::TestTask.new(:test) do |t|
+  t.libs << 'lib'
+  t.libs << 'test'
+  t.pattern = 'test/**/*_test.rb'
+  t.verbose = true
+end
+
+desc 'Generate documentation for the blacklight_cql plugin.'
+Rake::RDocTask.new(:rdoc) do |rdoc|
+  rdoc.rdoc_dir = 'rdoc'
+  rdoc.title    = 'Blacklight-cql'
+  rdoc.options << '--line-numbers' << '--inline-source'
+  rdoc.rdoc_files.include('README')
+  rdoc.rdoc_files.include('lib/**/*.rb')
+end
+
+begin
+  require 'jeweler'
+  Jeweler::Tasks.new do |gemspec|
+    gemspec.name = "blacklight_cql"
+    gemspec.summary = "Add CQL query support to a Blacklight app"
+    gemspec.description = "May have parts that can be used outside a Blacklight app too with a big of refactoring, let me know if interested."
+    gemspec.email = "rochkind@jhu.edu"
+    gemspec.homepage = "http://github.com/projectblacklight/blacklight_cql"
+    gemspec.authors = ["Jonathan Rochkind"]
+    
+    gemspec.add_dependency("cql-ruby", ">=0.8.1")
+    
+    gemspec.add_development_dependency("markup_validity")
+  end
+  Jeweler::GemcutterTasks.new
+rescue LoadError
+  puts "Jeweler not available. Install it with: gem install jeweler"
+end
+

data/VERSION

@@ -0,0 +1 @@
+0.9.0

data/app/controllers/blacklight_cql/explain_controller.rb

@@ -0,0 +1,17 @@
+require 'rsolr-ext'
+
+module BlacklightCql
+  class ExplainController < ApplicationController
+    layout false
+    
+    def index
+       @luke_response = Blacklight.solr.luke
+       @field_config = Blacklight
+       
+       render "explain.xml.builder", :content_type => "application/xml"
+    end
+    
+  end
+
+  
+end

data/app/helpers/blacklight_cql/explain_helper.rb

@@ -0,0 +1,44 @@
+module BlacklightCql::ExplainHelper
+
+  # Arg is a Builder instance. 
+  def luke_to_explain_index(xml)    
+    @luke_response[:fields].each_pair do |solr_field, defn|
+      # only if it's an indexed
+      if defn[:schema].include?("I")
+        xml.index("search" => "true", "scan"=>false, "sort" => false) do
+          xml.title solr_field.to_s
+          xml.map do
+            xml.name(solr_field.to_s, "set" => CqlRuby.to_solr_defaults[:solr_field_prefix])             
+          end
+          # What relations do we support for this index?
+          xml.configInfo do
+            ["==", "=", ">=", ">", "<", "<=", "<>", "within", "adj", "all", "any"].each do |rel|
+              xml.supports(rel, "type"=>"relation")
+            end                                    
+          end
+        end
+      end    
+    end
+  end
+
+  # Expects an object in @field_config that implements
+  # Blacklight::SearchFields to provide search field config.
+  # argument is a Builder object we can write to. 
+  def blacklight_config_to_explain_index(xml)
+    @field_config.search_field_list.each do |search_field|
+      xml.index("search" => "true", "scan" => "false", "sort" => "false") do
+        xml.title search_field[:display_label]
+        xml.map do
+          xml.name(search_field[:key], "set" => CqlRuby.to_solr_defaults[:blacklight_field_prefix]) 
+        end
+        # What relations do we support for this index? Right now,
+        # just the custom solr.dismax one
+        xml.configInfo do
+          xml.supports("=", "type"=>"relation")
+          xml.supports("solr.dismax", "type"=>"relation")
+        end
+      end
+    end
+  end
+  
+end

data/app/views/blacklight_cql/explain/explain.xml.builder

@@ -0,0 +1,30 @@
+xml.instruct!
+xml.explain("xmlns" => "http://explain.z3950.org/dtd/2.0/") do
+
+  # Made up protocol "http-cql", oh well.
+  xml.serverInfo("protocol" => "http-cql") do
+    xml.host request.host
+    xml.port request.port
+    xml.database url_for(:controller => "/catalog", :action => "index", :search_field => BlacklightCql::SolrHelperExtension.pseudo_search_field[:key])
+  end
+
+  xml.indexInfo do
+    xml.set(:name => CqlRuby.to_solr_defaults[:solr_field_prefix], 
+            :identifier => 
+              url_for(:controller => "/catalog", 
+                      :action => "index",
+                      :anchor => "local_solr_field",
+                      :only_path => false))
+    xml.set(:name => CqlRuby.to_solr_defaults[:blacklight_field_prefix],
+            :identifier => 
+              url_for(:controller => "/catalog", 
+                      :action => "index",
+                      :anchor => "local_app_field",
+                      :only_path => false))
+    #context set for our solr.dismax relation
+    xml.set(:name => "solr", :identifier => "http://purl.org/net/cql-context-set/solr")
+
+    blacklight_config_to_explain_index(xml)
+    luke_to_explain_index(xml)  
+  end
+end            

data/config/routes.rb

@@ -0,0 +1,10 @@
+# Fix this for Rails3, this is a weird way to do it, but oh well.
+# We want to map catalog/explain but not touch the app's own mappings
+# for catalog resource. So we do it with just old style routing.
+
+ActionController::Routing::Routes.draw do |map|
+  map.connect 'catalog/explain', :controller => "blacklight_cql/explain", :action => "index"
+
+  
+end
+

data/init.rb

@@ -0,0 +1 @@
+File.dirname(__FILE__) + "/rails/init".

data/install.rb

@@ -0,0 +1 @@
+# Install hook code here

data/lib/blacklight_cql/blacklight_to_solr.rb

@@ -0,0 +1,115 @@
+require 'cql_ruby'
+
+# Patch CqlRuby to provide a #to_bl_solr implementation, which is like
+# to_solr, but aware of Blacklight search_field defintions for dismax relation
+# queries.
+#
+# The relation "solr.dismax" is used to mean that the value string is a
+# query in the solr dismax query parsing language.
+#
+# CQL indexes can refer to direct solr fields, or Blacklight-defined dismax
+# search_fields, specified by CQL prefix.  By default, "lsolr" means a local
+# solr field, and "local" means a blacklight search_field. Indexes specified
+# with no index will use a blacklight search_field if one exists, otherwise
+# assumed to be solr field.
+# 
+# "Context set" prefixed used to identify bl and solr fields
+# can be changed in CqlRuby.to_solr_defaults, keys solr_field_prefix,
+# blacklight_field_prefix.
+#
+# argument to #to_bl_solr is a 'config' object that duck-types to
+# Blacklight::SearchFields , for accessing search fields config.
+module CqlRuby
+  to_solr_defaults[:solr_field_prefix] = "lsolr"
+  to_solr_defaults[:blacklight_field_prefix] = "local"
+  to_solr_defaults[:dismax_relation] = "solr.dismax"
+
+
+  CqlNode.send(:include,
+    Module.new do
+      def to_bl_solr(config)
+         raise CqlException.new("#to_bl_solr not supported for #{self.class}:  #{self.to_cql}")
+      end  
+    end  
+  )
+  
+  
+  CqlBooleanNode.send(:include,
+    Module.new do 
+      def to_bl_solr(config)
+        "( #{@left_node.to_bl_solr(config) } #{@modifier_set.to_solr} #{@right_node.to_bl_solr(config) } )"
+      end
+    end
+  )
+  
+  
+  CqlTermNode.send(:include,
+    Module.new do 
+      def to_bl_solr(config)
+        (index_prefix, index) = parse_index(@index, config)
+                                                        
+        if (index_prefix == CqlRuby.to_solr_defaults[:blacklight_field_prefix])                
+           field_def = config.search_field_def_for_key(index)
+           
+           # Merge together solr params and local ones; they're ALL
+           # going to be provided as LocalParams in our nested query.
+           # Merge so :solr_local_parameters take precedence.
+           per_field_params = (field_def[:solr_parameters] || {}).merge( field_def[:solr_local_parameters] || {} )
+           
+           local_params = 
+           per_field_params.collect do |key, val|
+             key.to_s + "=" + BlacklightCql.solr_param_quote(val) 
+           end.join(" ")          
+  
+           relation = @relation.modifier_set.base
+           relation = "solr.dismax" if relation == "=" # default server choice
+           relation = "cql.#{relation}" unless relation.index(".") || ["<>", "<=", ">=", "<", ">", "=", "=="].include?(relation)
+  
+           
+           case relation
+             when "solr.dismax"
+               return " _query_:\"{!dismax #{local_params}} #{BlacklightCql.escape_quotes(@term)} \" "
+             else
+               raise CqlException.new("relation #{relation} not supported for #{CqlRuby.to_solr_defaults[:blacklight_field_prefix]} indexes: #{self.to_cql}")
+           end
+  
+        elsif (index_prefix == CqlRuby.to_solr_defaults[:solr_field_prefix])
+          return to_solr
+        else
+          raise CqlException.new("Index prefix not recognized: #{index_prefix}")
+        end
+      end    
+      
+      
+      protected 
+    
+      # Parse CQL index string into namespace and base name, filling in default
+      # namespace. Returns array of [namespace, basename]
+      def parse_index(index, config)
+          index_prefix, index =   @index.index(".") ?
+                                  @index.split(".", 2) : 
+                                  [nil, @index]
+                                                              
+          #for cql.serverChoice and dismax relation, we do dismax with
+          #default field, otherwise we'll let it fall through to #to_solr
+          if( @index.downcase == "cql.serverchoice" &&
+              [CqlRuby.to_solr_defaults[:dismax_relation].downcase,
+               "="].include?(@relation.modifier_set.base.downcase)
+             )
+             index_prefix = CqlRuby.to_solr_defaults[:blacklight_index_prefix]
+             index = config.default_search_field[:key]
+          end
+          # If no prefix, we use local one if we can
+          if ( index_prefix == nil)
+            if ( config.search_field_def_for_key(index) )
+                index_prefix = CqlRuby.to_solr_defaults[:blacklight_field_prefix]
+            else
+                index_prefix = CqlRuby.to_solr_defaults[:solr_field_prefix]
+            end
+          end
+          return [index_prefix, index]
+      end    
+    end
+    )
+  
+end

data/lib/blacklight_cql/solr_helper_extension.rb

@@ -0,0 +1,24 @@
+# We over-ride methods on CatalogController simply by include'ing this
+# module into CatalogController, which this plugins setup will do.
+#
+# This works ONLY becuase the methods we're over-riding come from
+# a module themsleves (SolrHelper) -- if they were defined on CatalogController
+# itself, it would not, and we'd have to use some ugly monkey patching
+# alias_method_chain instead, thankfully we do not. 
+module BlacklightCql::SolrHelperExtension
+    mattr_accessor :pseudo_search_field
+    self.pseudo_search_field = {:key => "cql", :display_label => "External Search (CQL)", :include_in_simple_select => false}
+
+    # Over-ride solr_search_params to do special CQL-to-complex-solr-query
+    # processing iff the "search_field" is our pseudo-search-field indicating
+    # a CQL query. 
+    def solr_search_params(extra_controller_params = {})
+      solr_params = super(extra_controller_params)
+    
+      if params["search_field"] == self.pseudo_search_field[:key] && ! params["q"].blank?
+        parser = CqlRuby::CqlParser.new
+        solr_params[:q] = "{!lucene} " + parser.parse( params["q"] ).to_bl_solr(Blacklight)     
+      end
+      return solr_params
+    end
+end

data/lib/blacklight_cql/template_helper_extension.rb

@@ -0,0 +1,19 @@
+# We can over-ride a default Blacklight template helper and still call
+# super on it, by inserting this module as a helper into CatalogController.
+# This plugins setup will do that. 
+module BlacklightCql::TemplateHelperExtension
+
+  # Make sure the CQL pseudo-search_field is included in the 'select'
+  # when we're displaying a CQL search, so the select makes sense. 
+  def search_fields
+    field = BlacklightCql::SolrHelperExtension.pseudo_search_field
+    
+    if params[:q].blank? || params[:search_field] != field[:key]
+      super
+    else      
+      super.clone.push([field[:display_label], field[:key]]).uniq
+    end
+  end
+  
+  
+end

data/lib/blacklight_cql.rb

@@ -0,0 +1,25 @@
+# Blacklight-cql
+
+require 'blacklight_cql/blacklight_to_solr'
+
+module BlacklightCql
+mattr_accessor :cql_search_field_key
+  self.cql_search_field_key = "cql"
+
+  # Escape single or double quote marks with backslash
+  def self.escape_quotes(input)
+    input.gsub("'", "\\\'").gsub('"', "\\\"")
+  end
+
+  # Escapes value for Solr LocalParam. Will wrap in
+  # quotes only if needed (if not needed, and the value
+  # turns out to have been a $param, then quotes will mess
+  # things up!), and escapes value inside quotes. 
+  def self.solr_param_quote(val)
+    unless val =~ /^[a-zA-Z$_\-\^]+$/
+      val = "'" + escape_quotes(val) + "'"
+    end
+    return val
+  end
+  
+end

data/rails/init.rb

@@ -0,0 +1,32 @@
+# Include hook code here
+require 'cql_ruby'
+require 'blacklight_cql'
+require 'dispatcher'
+
+
+# Call in after_initialze to make sure the default search_fields are
+# already created, AND the local app has had the opportunity to customize
+# our placeholder search_field. 
+config.after_initialize do 
+  Blacklight.config[:search_fields] << BlacklightCql::SolrHelperExtension.pseudo_search_field
+end
+
+# Wrapping in Dispatcher.to_prepare will, theoretically, take care of things
+# working properly even in development mode with cache_classes=false (per-request
+# class reloading). 
+Dispatcher.to_prepare("blacklight_cql.setup") do 
+
+
+    #Check in  case CatalogController _hasn't_ really been re-loaded
+    unless (CatalogController.kind_of?( BlacklightCql::SolrHelperExtension ))
+        # Will over-ride #solr_params to deal with CQL
+        CatalogController.send(:include, BlacklightCql::SolrHelperExtension)
+
+        # Will over-ride helper methods for search form select,  to ensure
+        # query is echo'd properly. 
+        CatalogController.send(:helper, BlacklightCql::TemplateHelperExtension)
+    end
+        
+
+end
+

data/spec/app_root/app/controllers/application_controller.rb

@@ -0,0 +1,2 @@
+class ApplicationController < ActionController::Base
+end

data/spec/app_root/config/boot.rb

@@ -0,0 +1,115 @@
+# Allow customization of the rails framework path
+RAILS_FRAMEWORK_ROOT = (ENV['RAILS_FRAMEWORK_ROOT'] || "#{File.dirname(__FILE__)}/../../../../../../vendor/rails") unless defined?(RAILS_FRAMEWORK_ROOT) 
+
+# Don't change this file!
+# Configure your app in config/environment.rb and config/environments/*.rb
+
+RAILS_ROOT = "#{File.dirname(__FILE__)}/.." unless defined?(RAILS_ROOT)
+
+module Rails
+  class << self
+    def boot!
+      unless booted?
+        preinitialize
+        pick_boot.run
+      end
+    end
+
+    def booted?
+      defined? Rails::Initializer
+    end
+
+    def pick_boot
+      (vendor_rails? ? VendorBoot : GemBoot).new
+    end
+
+    def vendor_rails?
+      File.exist?(RAILS_FRAMEWORK_ROOT)
+    end
+
+    def preinitialize
+      load(preinitializer_path) if File.exist?(preinitializer_path)
+    end
+
+    def preinitializer_path
+      "#{RAILS_ROOT}/config/preinitializer.rb"
+    end
+  end
+
+  class Boot
+    def run
+      load_initializer
+      Rails::Initializer.run(:set_load_path)
+    end
+  end
+
+  class VendorBoot < Boot
+    def load_initializer
+      require "#{RAILS_FRAMEWORK_ROOT}/railties/lib/initializer"
+      Rails::Initializer.run(:install_gem_spec_stubs)
+      Rails::GemDependency.add_frozen_gem_path
+    end
+  end
+
+  class GemBoot < Boot
+    def load_initializer
+      self.class.load_rubygems
+      load_rails_gem
+      require 'initializer'
+    end
+
+    def load_rails_gem
+      if version = self.class.gem_version
+        gem 'rails', version
+      else
+        gem 'rails'
+      end
+    rescue Gem::LoadError => load_error
+      $stderr.puts %(Missing the Rails #{version} gem. Please `gem install -v=#{version} rails`, update your RAILS_GEM_VERSION setting in config/environment.rb for the Rails version you do have installed, or comment out RAILS_GEM_VERSION to use the latest version installed.)
+      exit 1
+    end
+
+    class << self
+      def rubygems_version
+        Gem::RubyGemsVersion rescue nil
+      end
+
+      def gem_version
+        if defined? RAILS_GEM_VERSION
+          RAILS_GEM_VERSION
+        elsif ENV.include?('RAILS_GEM_VERSION')
+          ENV['RAILS_GEM_VERSION']
+        else
+          parse_gem_version(read_environment_rb)
+        end
+      end
+
+      def load_rubygems
+        require 'rubygems'
+        min_version = '1.3.1'
+        unless rubygems_version >= min_version
+          $stderr.puts %Q(Rails requires RubyGems >= #{min_version} (you have #{rubygems_version}). Please `gem update --system` and try again.)
+          exit 1
+        end
+ 
+      rescue LoadError
+        $stderr.puts %Q(Rails requires RubyGems >= #{min_version}. Please install RubyGems and try again: http://rubygems.rubyforge.org)
+        exit 1
+      end
+
+      def parse_gem_version(text)
+        $1 if text =~ /^[^#]*RAILS_GEM_VERSION\s*=\s*["']([!~<>=]*\s*[\d.]+)["']/
+      end
+
+      private
+        def read_environment_rb
+          environment_rb = "#{RAILS_ROOT}/config/environment.rb"
+          environment_rb = "#{HELPER_RAILS_ROOT}/config/environment.rb" unless File.exists?(environment_rb)
+          File.read(environment_rb)
+        end
+    end
+  end
+end
+
+# All that for this:
+Rails.boot!