blacklight 4.9.0 → 5.0.0.pre1

data/doc/Release-Notes-And-Upgrade-Guides.md

@@ -1,20 +0,0 @@
-This is for upgrade guides for each version.
-* [Blacklight 4.5 Release Notes and Upgrade Guide](https://github.com/projectblacklight/blacklight/releases/tag/v4.5.0) (???)
-* [Blacklight 4.4 Release Notes And Upgrade Guide](https://github.com/projectblacklight/blacklight/releases/tag/v4.4.0) (September 17, 2013)
-* [Blacklight 4.3 Release Notes And Upgrade Guide](https://github.com/projectblacklight/blacklight/releases/tag/v4.3.0) (July 30, 2013)
-* [Blacklight 4.2.2 Release Notes And Upgrade Guide](https://github.com/projectblacklight/blacklight/releases/tag/v4.2.2) (2013)
-* [Blacklight 4.2.1 Release Notes And Upgrade Guide](https://github.com/projectblacklight/blacklight/releases/tag/v4.2.1) (2013)
-* [Blacklight 4.2.0 Release Notes And Upgrade Guide](https://github.com/projectblacklight/blacklight/releases/tag/v4.2.0) (Mar 29, 2013)
-* [Blacklight 4.1 Release Notes And Upgrade Guide](https://github.com/projectblacklight/blacklight/releases/tag/v4.1.0) (Mar 7, 2013)
-* [Blacklight 4.0 Release Notes And Upgrade Guide](https://github.com/projectblacklight/blacklight/releases/tag/v4.0.0) (Nov 29, 2012)
-* [[Blacklight 3.8 Release Notes And Upgrade Guide]] (Nov 2, 2012)
-* [[Blacklight 3.7 Release Notes And Upgrade Guide]] (Sep 25, 2012)
-* [[Blacklight 3.6 Release Notes And Upgrade Guide]] (Sep 10, 2012)
-* [[Blacklight 3.5 Release Notes And Upgrade Guide]] (Jun 25, 2012)
-* [[Blacklight 3.4 Release Notes And Upgrade Guide]] (Apr 24, 2012)
-* [[Blacklight 3.3 Release Notes And Upgrade Guide]] (Mar 19, 2012)
-* [[Blacklight 3.2 Release Notes And Upgrade Guide]] (Dec 15, 2011)
-* [[Blacklight 3.1 Release Notes And Upgrade Guide]] (Sep 28, 2011)
-* [[Blacklight 3.0 Release Notes And Upgrade Guide]] (July 11, 2011)
-
-Unreleased

data/doc/Roadmap.md

@@ -1,43 +0,0 @@
-<table>
-<thead><td>Feature</td><td>What can be reused?</td><td>Who wants this</td><td>Who can work on this</td></thead>
-<tbody>
-<tr>
-  <td>Document Index view toggles</td>
-  <td><a href="https://revs-lib.stanford.edu/catalog?f%5Bpub_year_isim%5D%5B%5D=1930&q=&utf8=%E2%9C%93">Stanford</a>, <a href="http://levysheetmusic.mse.jhu.edu/catalog?utf8=%E2%9C%93&q=&f%5Bmods_subject_facet%5D%5B%5D=African+Americans">JHU</a></td>
-  <td></td>
-  <td></td>
-</tr>
-<tr>
-  <td>i18n files in blacklight</td>
-  <td>Stanford has fr + it</td>
-  <td></td>
-  <td></td>
-</tr>
-
-<tr>
-  <td><a href="https://groups.google.com/forum/?fromgroups=#!topic/blacklight-development/Brz3ePltc3w">Thumbnails in search results</a></td>
-  <td>Many places</td>
-  <td></td>
-  <td>cbeer</td>
-</tr>
-
-<tr>
-  <td><a href="https://groups.google.com/forum/?fromgroups#!topic/blacklight-development/LGk2DtsA8rA">Blacklight curriculum for RailsBridge</a></td>
-  <td></td>
-  <td></td>
-  <td>bess</td>
-</tr>
-<tr>
-  <td>Tags and Comments</td>
-  <td></td>
-  <td>afred,awead</td>
-  <td></td>
-</tr>
-<tr>
-  <td>Caching</td>
-  <td></td>
-  <td>jronallo</td>
-  <td></td>
-</tr>
-</tbody>
-</table>

data/doc/Sunspot-for-indexing.md

@@ -1,46 +0,0 @@
-If you have a Rails application as your data store, you may look to [Sunspot](http://outoftime.github.com/sunspot/) to help index your ActiveRecord models. Sunspot provides a nice DSL that makes it easy to index your models and associations. There is one gotcha, though, for using Sunspot with Blacklight. Both Sunspot and Blacklight expect the Solr uniqueKey to be in the "id" field. Sunspot will use the class of your model plus the primary key of that instance as the value for the id field. So a value for the id field may look like this: "Resource 123". 
-
-When a Sunspot-indexed Solr is used with Blacklight your model names and primary keys are exposed in your URLs. You may want to use a different value as your id value for Blacklight to use for document recall and URLs. For instance you want to use a unique filename as your id value for Blacklight.  
-
-You can use something like the following monkeypatch of Sunspot (1.2) by placing it in config/initializers/sunspot_monkeypatch_id.rb. It takes the value of the id field that Sunspot creates (Resource 123) and places it in the resource_id_ss field. It then overwrites the id value with the value from the filename field. The second part then takes a Solr hit and reverses it so that Sunspot can retrieve your models.
-
-```ruby
-     # for using a different value for the id field of your Solr documents
-     Sunspot::Indexer.module_eval do
-       alias :old_prepare :prepare
-       def prepare(model)
-         document = old_prepare(model)
-         document.fields_by_name(:resource_id_ss).first.value = document.fields_by_name(:id).first.value
-         if !document.fields_by_name(:filename).blank? and !document.fields_by_name(:filename).first.blank?
-            document.fields_by_name(:id).first.value = document.fields_by_name(:filename).first.value
-         end
-         document
-       end
-
-       alias :old_remove :remove  
-       def remove(*models)
-         @connection.delete_by_id(
-           models.map do |model| 
-             prepare(model).fields_by_name(:id).first.value
-           end
-         )
-       end
-
-     end
-
-     # to allow searching with Sunspot's DSL as well to retrieve your models
-     class Sunspot::Search::Hit
-       def initialize(raw_hit, highlights, search) 
-         raw_hit['id'] = raw_hit['resource_id_ss']
-         @class_name, @primary_key = *raw_hit['id'].match(/([^ ]+) (.+)/)[1..2]
-         @score = raw_hit['score']
-         @search = search
-         @stored_values = raw_hit
-         @stored_cache = {}
-         @highlights = highlights
-       end
-     end
-```
-
-
-

data/doc/Theming.md

@@ -1,64 +0,0 @@
-# Theming Blacklight
-
-## Bootswatches
-
-The Blacklight 4.x styling is [[Twitter Bootstrap|http://twitter.github.com/bootstrap]] based. While there is some Blacklight-specific code for handling layouts and positions, most (if not all) the "styling" (colors, fonts, etc) are handled by Bootstrap.
-
-There are many sources for Bootstrap themes. We'll look at bootswatches because they are fairly painless to integrate into a Rails application.
-
-First, add the [[bootswatch-rails gem|https://github.com/maxim/bootswatch-rails]]  to your Gemfile (and run ```bundle install```):
-
-```ruby
-gem 'bootswatch-rails'
-```
-
-This will give you the set of themes from [[http://bootswatch.com/]], converted to SASS and exposed to the Rails asset pipeline. 
-
-Out of the box, your application's blacklight stylesheet (generated by default to ```app/assets/stylesheets/blacklight.css.scss```) looks something like:
-
-```css
-@import 'bootstrap';
-@import 'bootstrap-responsive';
-
-@import 'blacklight/blacklight';
-```
-
-To add the one of the bootswatch themes ('cerulean' in this example):
-
-```css
-@import "bootswatch/cerulean/variables";
-
-@import "bootstrap";
-@import "bootstrap-responsive";
-
-@import "bootswatch/cerulean/bootswatch";
-
-@import 'blacklight/blacklight'
-```
-
-![Blacklight with the Cerulean theme applied](http://projectblacklight.org/images/blacklight-cerulean.png)
-
-The [[bootswatch-rails|https://github.com/maxim/bootswatch-rails]] documentation provides similar directions, a list of available out-of-the-box themes, and more.
-
-> As of this writing, not all bootswatch-rails themes seem to be bootstrap 2.1.x compatible, or do weird things to the Blacklight navbar, etc. Your milage may vary.
-
-## Developing a Customized "Local" Theme
-
-In most cases, you will want to develop your own theme within your Blacklight app, outside of the Bootswatch gem.  To do this, you can do the following in your ```app/assets/stylesheets``` directory:
-
-1. create your own _variables.scss and _bootswatch.scss files in stylesheets/ (easiest way to do this is to copy those files from the [[bootstrap-sass project|https://github.com/thomas-mcdonald/bootstrap-sass/tree/master/vendor/assets/stylesheets/bootstrap]] or an existing theme and customize from there)
-2. change application.css to application.css.scss 
-3. add the import statements given in the above "theming" example to application.css.scss
-4. delete blacklight.css.scss
-
-So, your application.css.scss should look like this:
-```css
-@import "variables";
-
-@import "bootstrap";
-@import "bootstrap-responsive";
-
-@import "bootswatch";
-
-@import 'blacklight/blacklight'
-```

data/doc/User-Authentication.md

@@ -1,60 +0,0 @@
-Blacklight does not require user authentication, however, if included, Blacklight can provide additional features for users ([[Bookmarks]], [[Saved Searches]], etc). Because of the wide range of institutional needs and capabilities, Blacklight does not require a specific user authentication provider. 
-
-## Installing with Devise
-
-If you are rolling your own user authentication system, we highly recommend [[Devise|https://github.com/plataformatec/devise]], an extremely flexible authentication solution that is relatively straightforward. For directions to install the Blacklight gem using devise, see the [[Quickstart]].
-
-## Install and Use (with a custom user authentication system)
-
-Create a new rails 3 application
-```bash
-$ rails new my_app
-```
-
-Add blacklight to your gem file 
-```bash
-edit ./my_app/Gemfile
-```
-```ruby.
-# Append this line to the end of the file:
-gem 'blacklight'
-```
-
-```bash
-$ bundle install
-```
-
-If you have a `User` model already, the Blacklight generator will connect to it automatically during installation.  However, you will need to make sure the following named routes are included in your /config/routes.rb file:
-
-```ruby
-  match 'your_login',          :to => 'Your User Session Controller # Log in action',       :as => 'new_user_session'
-  match 'your_logout',         :to => 'Your User Session Controller # Log Out action',      :as => 'destroy_user_session'
-  match 'your_account_page',   :to => 'Your User Session Controller # Account edit action', :as => 'edit_user_registration'
-```
-
-One blacklight view partial uses `#to_s` on your user model to get a user-displayable account name/identifier for the currently logged in account, so you probably want to have such a method. 
-
-Finally, you will need to make sure the following methods are available both on controllers and as helpers:
-
-* `current_user`   - Which should return an ActiveRecord-based user object that include Blacklight::User
-* `user_session`   - Which are included in your /config/routes.rb file:
-
-Optionally,
-* `guest_user` -  Which should return an ActiveRecord-based temporary guest user object available across the current user session.
-* `current_or_guest_user` - Which should return the `current_user`, if available, or `guest_user`. If you don't provide this method, a stub method (that just returns `current_user`) will be provided for you.
-
-If you are supporting guest users, if a guest user logs in, you should call `#transfer_guest_user_actions_to_current_user` to move any persisted data to the permanent user.
-
-> The `devise-guests` gem implements the `guest_user`, `current_or_guest_user` and callbacks for Blacklight applications using devise. It may be a useful reference for rolling your own functionality. See [DeviseGuests::Controllers::Helpers](https://github.com/cbeer/devise-guests/blob/master/lib/devise-guests/controllers/helpers.rb)
-
-Once these are in place, you can run the Blacklight Installation Generator:
-
-```bash
-$ rails generate blacklight [MODEL NAME]
-```
-Where model name is the name of your user model.
-
-Execute your migrations, and you should be good to go.
-```bash
-$ rake db:migrate
-```

data/doc/testing.md

@@ -1,57 +0,0 @@
-## Using Blacklight source checkout as gem for development
-
-The ordinary install instructions install the BL gem (which is not
-full source code) in wherever your system installs gems. 
-
-Sometimes, especially for development, it's useful to check out
-a complete copy of the blacklight source code, and link your app
-to that as a 'gem' instead. 
-
-Checkout the code:
-
-    $ git clone git@github.com:projectblacklight/blacklight.git  
-
-
-## Automatically generate a test application (and run the tests)
-
-To run the Blacklight test suite, Blacklight comes with a rake task that creates local dependencies like a Solr with indexed test data and a test Rails application, and then runs tests. 
-
-Requirements:
-
-  * Java (1.6 or above) (for Solr)
-  * phantomjs (used by integration tests, you may be able to install with your local package manager, for instance on OSX with `brew install phantomjs`)
-
-Then from the root directory of your blacklight git checkout:
-
-```
-rake ci  
-```
-This ensure a test Solr exists and is running, creates a test application, and loads the fixtures and then runs specs and cucumber tests.
-
-### Step by step, with more control
-
-`rake ci` will, every time you run it, re-index test data in solr, and re-build the test application. Re-building the test application in particular is kind of time-consuming. You may prefer to set up the environment and run tests as separate steps, to make development easier. 
-
-To create the dummy test app:
-
-    $ rake engine_cart:generate
-
-(If you have an existing dummy app that is outdated, `rake engine_cart:clean` first, then `rake engine_cart:generate). 
-
-Then start up the test jetty with:
-
-    $ rake jetty:start
-
-If you haven't yet indexed the test data in the test jetty. (??? Not sure how to do this. Run `rake ci` once to make sure test data has been indexed).  Run `rake jetty:stop` when you're done with it. 
-
-Then run all the specs with:
-
-    $ rake spec
-
-Or just run one spec
-
-    $ rake spec SPEC=just/one_spec.rb
-
-And stop your test solr when you're done with it:
-
-    $ rake jetty:stop

data/lib/blacklight/mash.rb

@@ -1,19 +0,0 @@
-# This class has dubious semantics and we only have it so that people can write
-# params[:key] instead of params['key'].
-class Mash < HashWithIndifferentAccess
-  def initialize *args, &block
-    ActiveSupport::Deprecation.warn("Mash is deprecated, and should be replaced with HashWithIndifferentAccess")
-
-    super
-  end
-end
-
-unless Hash.respond_to?(:to_mash)
-  class Hash
-    def to_mash
-      ActiveSupport::Deprecation.warn("Hash#to_mash is deprecated, and should be replaced with #with_indifferent_access")
-
-      HashWithIndifferentAccess.new(self)
-    end
-  end
-end

data/lib/blacklight/solr/document/marc.rb

@@ -1,71 +0,0 @@
-# -*- encoding : utf-8 -*-
-
-# This is a document extension meant to be mixed into a
-# Blacklight::Solr::Document class, such as SolrDocument. It provides support
-# for restoration of MARC data (xml or binary) from a Solr stored field, and
-# then provides various transformations/exports of that Marc via the included
-# Blacklight::Solr::Document::MarcExport module.
-#
-# This extension would normally be registered using 
-# Blacklight::Solr::Document#use_extension.  eg:
-#
-# SolrDocument.use_extension( Blacklight::Solr::Document::Marc ) { |document| my_logic_for_document_has_marc?( document ) }
-#
-# This extension also expects a :marc_source_field and :marc_format_type to
-# be registered with the hosting classes extension_parameters. In an initializer
-# or other startup code:
-# SolrDocument.extension_paramters[:marc_source_field] = "name_of_solr_stored_field"
-# SolrDocument.extension_parameters[:marc_format_type] = :marc21 # or :marcxml
-module Blacklight::Solr::Document::Marc
-  require 'marc'
-
-  include Blacklight::Solr::Document::MarcExport # All our export_as stuff based on to_marc. 
-  
-  class UnsupportedMarcFormatType < RuntimeError; end
-    
-  def self.extended(document)
-    # Register our exportable formats, we inherit these from MarcExport    
-    Blacklight::Solr::Document::MarcExport.register_export_formats( document )
-  end
-  
-  # ruby-marc object
-  def to_marc
-    @_ruby_marc_obj ||= load_marc
-  end
-
-
-  protected
-  def marc_source
-    @_marc_source ||= fetch(_marc_source_field)
-  end
-
-  def load_marc
-    case _marc_format_type.to_s
-    when 'marcxml'
-      records = MARC::XMLReader.new(StringIO.new( fetch(_marc_source_field) )).to_a
-      return records[0]
-    when 'marc21'
-      return MARC::Record.new_from_marc( fetch(_marc_source_field) )          
-    else
-
-      raise UnsupportedMarcFormatType.new("Only marcxml and marc21 are supported, this documents format is #{_marc_format_type} and the current extension parameters are #{self.class.extension_parameters.inspect}")
-    end      
-  end
-  
-  
-  
-  def _marc_helper
-    @_marc_helper ||= (
-      Blacklight::Marc::Document.new fetch(_marc_source_field), _marc_format_type )
-  end
-
-  def _marc_source_field    
-    self.class.extension_parameters[:marc_source_field]
-  end
-
-  def _marc_format_type
-        #TODO: Raise if not present
-    self.class.extension_parameters[:marc_format_type]    
-  end
-  
-end

data/lib/blacklight/solr/document/marc_export.rb

@@ -1,590 +0,0 @@
-# -*- encoding : utf-8 -*-
-# -*- coding: utf-8 -*-
-# Written for use with Blacklight::Solr::Document::Marc, but you can use
-# it for your own custom Blacklight document Marc extension too -- just
-# include this module in any document extension (or any other class)
-# that provides a #to_marc returning a ruby-marc object.  This module will add
-# in export_as translation methods for a variety of formats. 
-module Blacklight::Solr::Document::MarcExport
-  extend Deprecation
-  self.deprecation_horizon = 'Blacklight 5.x'
-
-  
-  def self.register_export_formats(document)
-    document.will_export_as(:xml)
-    document.will_export_as(:marc, "application/marc")
-    # marcxml content type: 
-    # http://tools.ietf.org/html/draft-denenberg-mods-etc-media-types-00
-    document.will_export_as(:marcxml, "application/marcxml+xml")
-    document.will_export_as(:openurl_ctx_kev, "application/x-openurl-ctx-kev")
-    document.will_export_as(:refworks_marc_txt, "text/plain")
-    document.will_export_as(:endnote, "application/x-endnote-refer")
-  end
-
-
-  def export_as_marc
-    to_marc.to_marc
-  end
-
-  def export_as_marcxml
-    to_marc.to_xml.to_s
-  end
-  alias_method :export_as_xml, :export_as_marcxml
-  
-  
-  # TODO This exporting as formatted citation thing should be re-thought
-  # redesigned at some point to be more general purpose, but this
-  # is in-line with what we had before, but at least now attached
-  # to the document extension where it belongs. 
-  def export_as_apa_citation_txt
-    apa_citation( to_marc )
-  end
-  
-  def export_as_mla_citation_txt
-    mla_citation( to_marc )
-  end
-  
-  def export_as_chicago_citation_txt
-    chicago_citation( to_marc )
-  end
-
-  # Exports as an OpenURL KEV (key-encoded value) query string.
-  # For use to create COinS, among other things. COinS are
-  # for Zotero, among other things. TODO: This is wierd and fragile
-  # code, it should use ruby OpenURL gem instead to work a lot
-  # more sensibly. The "format" argument was in the old marc.marc.to_zotero
-  # call, but didn't neccesarily do what it thought it did anyway. Left in
-  # for now for backwards compatibilty, but should be replaced by
-  # just ruby OpenURL. 
-  def export_as_openurl_ctx_kev(format = nil)  
-    title = to_marc.find{|field| field.tag == '245'}
-    author = to_marc.find{|field| field.tag == '100'}
-    corp_author = to_marc.find{|field| field.tag == '110'}
-    publisher_info = to_marc.find{|field| field.tag == '260'}
-    edition = to_marc.find{|field| field.tag == '250'}
-    isbn = to_marc.find{|field| field.tag == '020'}
-    issn = to_marc.find{|field| field.tag == '022'}
-    unless format.nil?
-      format.is_a?(Array) ? format = format[0].downcase.strip : format = format.downcase.strip
-    end
-      export_text = ""
-      if format == 'book'
-        export_text << "ctx_ver=Z39.88-2004&amp;rft_val_fmt=info%3Aofi%2Ffmt%3Akev%3Amtx%3Abook&amp;rfr_id=info%3Asid%2Fblacklight.rubyforge.org%3Agenerator&amp;rft.genre=book&amp;"
-        export_text << "rft.btitle=#{(title.nil? or title['a'].nil?) ? "" : CGI::escape(title['a'])}+#{(title.nil? or title['b'].nil?) ? "" : CGI::escape(title['b'])}&amp;"
-        export_text << "rft.title=#{(title.nil? or title['a'].nil?) ? "" : CGI::escape(title['a'])}+#{(title.nil? or title['b'].nil?) ? "" : CGI::escape(title['b'])}&amp;"
-        export_text << "rft.au=#{(author.nil? or author['a'].nil?) ? "" : CGI::escape(author['a'])}&amp;"
-        export_text << "rft.aucorp=#{CGI::escape(corp_author['a']) if corp_author['a']}+#{CGI::escape(corp_author['b']) if corp_author['b']}&amp;" unless corp_author.blank?
-        export_text << "rft.date=#{(publisher_info.nil? or publisher_info['c'].nil?) ? "" : CGI::escape(publisher_info['c'])}&amp;"
-        export_text << "rft.place=#{(publisher_info.nil? or publisher_info['a'].nil?) ? "" : CGI::escape(publisher_info['a'])}&amp;"
-        export_text << "rft.pub=#{(publisher_info.nil? or publisher_info['b'].nil?) ? "" : CGI::escape(publisher_info['b'])}&amp;"
-        export_text << "rft.edition=#{(edition.nil? or edition['a'].nil?) ? "" : CGI::escape(edition['a'])}&amp;"
-        export_text << "rft.isbn=#{(isbn.nil? or isbn['a'].nil?) ? "" : isbn['a']}"
-      elsif (format =~ /journal/i) # checking using include because institutions may use formats like Journal or Journal/Magazine
-        export_text << "ctx_ver=Z39.88-2004&amp;rft_val_fmt=info%3Aofi%2Ffmt%3Akev%3Amtx%3Ajournal&amp;rfr_id=info%3Asid%2Fblacklight.rubyforge.org%3Agenerator&amp;rft.genre=article&amp;"
-        export_text << "rft.title=#{(title.nil? or title['a'].nil?) ? "" : CGI::escape(title['a'])}+#{(title.nil? or title['b'].nil?) ? "" : CGI::escape(title['b'])}&amp;"
-        export_text << "rft.atitle=#{(title.nil? or title['a'].nil?) ? "" : CGI::escape(title['a'])}+#{(title.nil? or title['b'].nil?) ? "" : CGI::escape(title['b'])}&amp;"
-        export_text << "rft.aucorp=#{CGI::escape(corp_author['a']) if corp_author['a']}+#{CGI::escape(corp_author['b']) if corp_author['b']}&amp;" unless corp_author.blank?
-        export_text << "rft.date=#{(publisher_info.nil? or publisher_info['c'].nil?) ? "" : CGI::escape(publisher_info['c'])}&amp;"
-        export_text << "rft.issn=#{(issn.nil? or issn['a'].nil?) ? "" : issn['a']}"
-      else
-         export_text << "ctx_ver=Z39.88-2004&amp;rft_val_fmt=info%3Aofi%2Ffmt%3Akev%3Amtx%3Adc&amp;rfr_id=info%3Asid%2Fblacklight.rubyforge.org%3Agenerator&amp;"
-         export_text << "rft.title=" + ((title.nil? or title['a'].nil?) ? "" : CGI::escape(title['a']))
-         export_text <<  ((title.nil? or title['b'].nil?) ? "" : CGI.escape(" ") + CGI::escape(title['b']))
-         export_text << "&amp;rft.creator=" + ((author.nil? or author['a'].nil?) ? "" : CGI::escape(author['a']))
-         export_text << "&amp;rft.aucorp=#{CGI::escape(corp_author['a']) if corp_author['a']}+#{CGI::escape(corp_author['b']) if corp_author['b']}" unless corp_author.blank?
-         export_text << "&amp;rft.date=" + ((publisher_info.nil? or publisher_info['c'].nil?) ? "" : CGI::escape(publisher_info['c']))
-         export_text << "&amp;rft.place=" + ((publisher_info.nil? or publisher_info['a'].nil?) ? "" : CGI::escape(publisher_info['a']))
-         export_text << "&amp;rft.pub=" + ((publisher_info.nil? or publisher_info['b'].nil?) ? "" : CGI::escape(publisher_info['b']))
-         export_text << "&amp;rft.format=" + (format.nil? ? "" : CGI::escape(format))
-     end
-     export_text.html_safe unless export_text.blank?
-  end
-
-
-  # This format used to be called 'refworks', which wasn't really
-  # accurate, sounds more like 'refworks tagged format'. Which this
-  # is not, it's instead some weird under-documented Refworks 
-  # proprietary marc-ish in text/plain format. See
-  # http://robotlibrarian.billdueber.com/sending-marcish-data-to-refworks/
-  def export_as_refworks_marc_txt
-    fields = to_marc.find_all { |f| ('000'..'999') === f.tag }
-    text = "LEADER #{to_marc.leader}"
-    fields.each do |field|
-    unless ["940","999"].include?(field.tag)
-      if field.is_a?(MARC::ControlField)
-        text << "#{field.tag}    #{field.value}\n"
-      else
-        text << "#{field.tag} "
-        text << (field.indicator1 ? field.indicator1 : " ")
-        text << (field.indicator2 ? field.indicator2 : " ")
-        text << " "
-          field.each {|s| s.code == 'a' ? text << "#{s.value}" : text << " |#{s.code}#{s.value}"}
-        text << "\n"
-       end
-        end
-    end
-
-    # As of 11 May 2010, Refworks has a problem with UTF-8 if it's decomposed,
-    # it seems to want C form normalization, although RefWorks support
-    # couldn't tell me that. -jrochkind
-    text = ActiveSupport::Multibyte::Unicode.normalize(text, :c)
-    
-    return text
-  end 
-
-  # Endnote Import Format. See the EndNote User Guide at:
-  # http://www.endnote.com/support/enx3man-terms-win.asp
-  # Chapter 7: Importing Reference Data into EndNote / Creating a Tagged “EndNote Import” File
-  #
-  # Note: This code is copied from what used to be in the previous version
-  # in ApplicationHelper#render_to_endnote.  It does NOT produce very good
-  # endnote import format; the %0 is likely to be entirely illegal, the
-  # rest of the data is barely correct but messy. TODO, a new version of this,
-  # or better yet just an export_as_ris instead, which will be more general
-  # purpose. 
-  def export_as_endnote()
-    end_note_format = {
-      "%A" => "100.a",
-      "%C" => "260.a",
-      "%D" => "260.c",
-      "%E" => "700.a",
-      "%I" => "260.b",
-      "%J" => "440.a",
-      "%@" => "020.a",
-      "%_@" => "022.a",
-      "%T" => "245.a,245.b",
-      "%U" => "856.u",
-      "%7" => "250.a"
-    }
-    marc_obj = to_marc
-
-    # TODO. This should be rewritten to guess
-    # from actual Marc instead, probably.
-    format_str = 'Generic'
-    
-    text = ''
-    text << "%0 #{ format_str }\n"
-    # If there is some reliable way of getting the language of a record we can add it here
-    #text << "%G #{record['language'].first}\n"
-    end_note_format.each do |key,value|
-      values = value.split(",")
-      first_value = values[0].split('.')
-      if values.length > 1
-        second_value = values[1].split('.')
-      else
-        second_value = []
-      end
-      
-      if marc_obj[first_value[0].to_s]
-        marc_obj.find_all{|f| (first_value[0].to_s) === f.tag}.each do |field|
-          if field[first_value[1]].to_s or field[second_value[1]].to_s
-            text << "#{key.gsub('_','')}"
-            if field[first_value[1]].to_s
-              text << " #{field[first_value[1]].to_s}"
-            end
-            if field[second_value[1]].to_s
-              text << " #{field[second_value[1]].to_s}"
-            end
-            text << "\n"
-          end
-        end
-      end
-    end
-    text
-  end
-
-  ## DEPRECATED stuff left in for backwards compatibility, but should
-  # be gotten rid of eventually.
-
-  def to_zotero(format)
-    Deprecation.warn(self, "Simply call document.export_as_openurl_kev to get an openURL kev context object suitable for including in a COinS; then have view code make the span for the COinS. ")
-    "<span class=\"Z3988\" title=\"#{export_as_openurl_kev(format)}\"></span>"
-  end
-
-  def to_apa
-    Deprecation.warn(self, "Call document.export_as_apa_citation instead.")
-    export_as_apa_citation
-  end
-
-  def to_mla
-    Deprecation.warn(self, "Call document.export_as_mla_citation instead.")
-  end
-  
-  
-
-  protected
-  
-  # Main method for defining chicago style citation.  If we don't end up converting to using a citation formatting service
-  # we should make this receive a semantic document and not MARC so we can use this with other formats.
-  def chicago_citation(marc)
-    authors = get_all_authors(marc)    
-    author_text = ""
-    unless authors[:primary_authors].blank?
-      if authors[:primary_authors].length > 10
-        authors[:primary_authors].each_with_index do |author,index|
-          if index < 7
-            if index == 0
-              author_text << "#{author}"
-              if author.ends_with?(",")
-                author_text << " "
-              else
-                author_text << ", "
-              end
-            else
-              author_text << "#{name_reverse(author)}, "
-            end
-          end
-        end
-        author_text << " et al."
-      elsif authors[:primary_authors].length > 1
-        authors[:primary_authors].each_with_index do |author,index|
-          if index == 0
-            author_text << "#{author}"
-            if author.ends_with?(",")
-              author_text << " "
-            else
-              author_text << ", "
-            end
-          elsif index + 1 == authors[:primary_authors].length
-            author_text << "and #{name_reverse(author)}."
-          else
-            author_text << "#{name_reverse(author)}, "
-          end 
-        end
-      else
-        author_text << authors[:primary_authors].first
-      end
-    else
-      temp_authors = []
-      authors[:translators].each do |translator|
-        temp_authors << [translator, "trans."]
-      end
-      authors[:editors].each do |editor|
-        temp_authors << [editor, "ed."]
-      end
-      authors[:compilers].each do |compiler|
-        temp_authors << [compiler, "comp."]
-      end
-      
-      unless temp_authors.blank?
-        if temp_authors.length > 10
-          temp_authors.each_with_index do |author,index|
-            if index < 7
-              author_text << "#{author.first} #{author.last} "
-            end
-          end
-          author_text << " et al."
-        elsif temp_authors.length > 1
-          temp_authors.each_with_index do |author,index|
-            if index == 0
-              author_text << "#{author.first} #{author.last}, "
-            elsif index + 1 == temp_authors.length
-              author_text << "and #{name_reverse(author.first)} #{author.last}"
-            else
-              author_text << "#{name_reverse(author.first)} #{author.last}, "
-            end
-          end
-        else
-          author_text << "#{temp_authors.first.first} #{temp_authors.first.last}"
-        end
-      end
-    end
-    title = ""
-    additional_title = ""
-    section_title = ""
-    if marc["245"] and (marc["245"]["a"] or marc["245"]["b"])
-      title << citation_title(clean_end_punctuation(marc["245"]["a"]).strip) if marc["245"]["a"]
-      title << ": #{citation_title(clean_end_punctuation(marc["245"]["b"]).strip)}" if marc["245"]["b"]
-    end
-    if marc["245"] and (marc["245"]["n"] or marc["245"]["p"])
-      section_title << citation_title(clean_end_punctuation(marc["245"]["n"])) if marc["245"]["n"]
-      if marc["245"]["p"]
-        section_title << ", <i>#{citation_title(clean_end_punctuation(marc["245"]["p"]))}.</i>"
-      elsif marc["245"]["n"]
-        section_title << "."
-      end
-    end
-    
-    if !authors[:primary_authors].blank? and (!authors[:translators].blank? or !authors[:editors].blank? or !authors[:compilers].blank?)
-        additional_title << "Translated by #{authors[:translators].collect{|name| name_reverse(name)}.join(" and ")}. " unless authors[:translators].blank?
-        additional_title << "Edited by #{authors[:editors].collect{|name| name_reverse(name)}.join(" and ")}. " unless authors[:editors].blank?
-        additional_title << "Compiled by #{authors[:compilers].collect{|name| name_reverse(name)}.join(" and ")}. " unless authors[:compilers].blank?
-    end
-    
-    edition = ""
-    edition << setup_edition(marc) unless setup_edition(marc).nil?
-    
-    pub_info = ""
-    if marc["260"] and (marc["260"]["a"] or marc["260"]["b"]) 
-      pub_info << clean_end_punctuation(marc["260"]["a"]).strip if marc["260"]["a"]
-      pub_info << ": #{clean_end_punctuation(marc["260"]["b"]).strip}" if marc["260"]["b"]
-      pub_info << ", #{setup_pub_date(marc)}" if marc["260"]["c"]
-    elsif marc["502"] and marc["502"]["a"] # MARC 502 is the Dissertation Note.  This holds the correct pub info for these types of records.
-      pub_info << marc["502"]["a"]
-    elsif marc["502"] and (marc["502"]["b"] or marc["502"]["c"] or marc["502"]["d"]) #sometimes the dissertation note is encoded in pieces in the $b $c and $d sub fields instead of lumped into the $a
-      pub_info << "#{marc["502"]["b"]}, #{marc["502"]["c"]}, #{clean_end_punctuation(marc["502"]["d"])}"
-    end
-    
-    citation = ""
-    citation << "#{author_text} " unless author_text.blank?
-    citation << "<i>#{title}.</i> " unless title.blank?
-    citation << "#{section_title} " unless section_title.blank?
-    citation << "#{additional_title} " unless additional_title.blank?
-    citation << "#{edition} " unless edition.blank?
-    citation << "#{pub_info}." unless pub_info.blank?
-    citation
-  end
-  
-  
-  
-  def mla_citation(record)
-    text = ''
-    authors_final = []
-    
-    #setup formatted author list
-    authors = get_author_list(record)
-
-    if authors.length < 4
-      authors.each do |l|
-        if l == authors.first #first
-          authors_final.push(l)
-        elsif l == authors.last #last
-          authors_final.push(", and " + name_reverse(l) + ".")
-        else #all others
-          authors_final.push(", " + name_reverse(l))
-        end
-      end
-      text += authors_final.join
-      unless text.blank?
-        if text[-1,1] != "."
-          text += ". "
-        else
-          text += " "
-        end
-      end
-    else
-      text += authors.first + ", et al. "
-    end
-    # setup title
-    title = setup_title_info(record)
-    if !title.nil?
-      text += "<i>" + mla_citation_title(title) + "</i> "
-    end
-
-    # Edition
-    edition_data = setup_edition(record)
-    text += edition_data + " " unless edition_data.nil?
-    
-    # Publication
-    text += setup_pub_info(record) + ", " unless setup_pub_info(record).nil?
-    
-    # Get Pub Date
-    text += setup_pub_date(record) unless setup_pub_date(record).nil?
-    if text[-1,1] != "."
-      text += "." unless text.nil? or text.blank?
-    end
-    text
-  end
-
-  def apa_citation(record)
-    text = ''
-    authors_list = []
-    authors_list_final = []
-    
-    #setup formatted author list
-    authors = get_author_list(record)
-    authors.each do |l|
-      authors_list.push(abbreviate_name(l)) unless l.blank?
-    end
-    authors_list.each do |l|
-      if l == authors_list.first #first
-        authors_list_final.push(l.strip)
-      elsif l == authors_list.last #last
-        authors_list_final.push(", &amp; " + l.strip)
-      else #all others
-        authors_list_final.push(", " + l.strip)
-      end
-    end
-    text += authors_list_final.join
-    unless text.blank?
-      if text[-1,1] != "."
-        text += ". "
-      else
-        text += " "
-      end
-    end
-    # Get Pub Date
-    text += "(" + setup_pub_date(record) + "). " unless setup_pub_date(record).nil?
-    
-    # setup title info
-    title = setup_title_info(record)
-    text += "<i>" + title + "</i> " unless title.nil?
-    
-    # Edition
-    edition_data = setup_edition(record)
-    text += edition_data + " " unless edition_data.nil?
-    
-    # Publisher info
-    text += setup_pub_info(record) unless setup_pub_info(record).nil?
-    unless text.blank?
-      if text[-1,1] != "."
-        text += "."
-      end
-    end
-    text
-  end
-  def setup_pub_date(record)
-    if !record.find{|f| f.tag == '260'}.nil?
-      pub_date = record.find{|f| f.tag == '260'}
-      if pub_date.find{|s| s.code == 'c'}
-        date_value = pub_date.find{|s| s.code == 'c'}.value.gsub(/[^0-9|n\.d\.]/, "")[0,4] unless pub_date.find{|s| s.code == 'c'}.value.gsub(/[^0-9|n\.d\.]/, "")[0,4].blank?
-      end
-      return nil if date_value.nil?
-    end
-    clean_end_punctuation(date_value) if date_value
-  end
-  def setup_pub_info(record)
-    text = ''
-    pub_info_field = record.find{|f| f.tag == '260'}
-    if !pub_info_field.nil?
-      a_pub_info = pub_info_field.find{|s| s.code == 'a'}
-      b_pub_info = pub_info_field.find{|s| s.code == 'b'}
-      a_pub_info = clean_end_punctuation(a_pub_info.value.strip) unless a_pub_info.nil?
-      b_pub_info = b_pub_info.value.strip unless b_pub_info.nil?
-      text += a_pub_info.strip unless a_pub_info.nil?
-      if !a_pub_info.nil? and !b_pub_info.nil?
-        text += ": "
-      end
-      text += b_pub_info.strip unless b_pub_info.nil?
-    end
-    return nil if text.strip.blank?
-    clean_end_punctuation(text.strip)
-  end
-
-  def mla_citation_title(text)
-    no_upcase = ["a","an","and","but","by","for","it","of","the","to","with"]
-    new_text = []
-    word_parts = text.split(" ")
-    word_parts.each do |w|
-      if !no_upcase.include? w
-        new_text.push(w.capitalize)
-      else
-        new_text.push(w)
-      end
-    end
-    new_text.join(" ")
-  end
-  
-  # This will replace the mla_citation_title method with a better understanding of how MLA and Chicago citation titles are formatted.
-  # This method will take in a string and capitalize all of the non-prepositions.
-  def citation_title(title_text)
-    prepositions = ["a","about","across","an","and","before","but","by","for","it","of","the","to","with","without"]
-    new_text = []
-    title_text.split(" ").each_with_index do |word,index|
-      if (index == 0 and word != word.upcase) or (word.length > 1 and word != word.upcase and !prepositions.include?(word))
-        # the split("-") will handle the capitalization of hyphenated words
-        new_text << word.split("-").map!{|w| w.capitalize }.join("-")
-      else
-        new_text << word
-      end
-    end
-    new_text.join(" ")
-  end
-
-  def setup_title_info(record)
-    text = ''
-    title_info_field = record.find{|f| f.tag == '245'}
-    if !title_info_field.nil?
-      a_title_info = title_info_field.find{|s| s.code == 'a'}
-      b_title_info = title_info_field.find{|s| s.code == 'b'}
-      a_title_info = clean_end_punctuation(a_title_info.value.strip) unless a_title_info.nil?
-      b_title_info = clean_end_punctuation(b_title_info.value.strip) unless b_title_info.nil?
-      text += a_title_info unless a_title_info.nil?
-      if !a_title_info.nil? and !b_title_info.nil?
-        text += ": "
-      end
-      text += b_title_info unless b_title_info.nil?
-    end
-    
-    return nil if text.strip.blank?
-    clean_end_punctuation(text.strip) + "."
-    
-  end
-  
-  def clean_end_punctuation(text)
-    if [".",",",":",";","/"].include? text[-1,1]
-      return text[0,text.length-1]
-    end
-    text
-  end  
-
-  def setup_edition(record)
-    edition_field = record.find{|f| f.tag == '250'}
-    edition_code = edition_field.find{|s| s.code == 'a'} unless edition_field.nil?
-    edition_data = edition_code.value unless edition_code.nil?
-    if edition_data.nil? or edition_data == '1st ed.'
-      return nil
-    else
-      return edition_data
-    end    
-  end
-  
-  def get_author_list(record)
-    author_list = []
-    authors_primary = record.find{|f| f.tag == '100'}
-    author_primary = authors_primary.find{|s| s.code == 'a'}.value unless authors_primary.nil? rescue ''
-    author_list.push(clean_end_punctuation(author_primary)) unless author_primary.nil?
-    authors_secondary = record.find_all{|f| ('700') === f.tag}
-    if !authors_secondary.nil?
-      authors_secondary.each do |l|
-        author_list.push(clean_end_punctuation(l.find{|s| s.code == 'a'}.value)) unless l.find{|s| s.code == 'a'}.value.nil?
-      end
-    end
-    
-    author_list.uniq!
-    author_list
-  end
-  
-  # This is a replacement method for the get_author_list method.  This new method will break authors out into primary authors, translators, editors, and compilers
-  def get_all_authors(record)
-    translator_code = "trl"; editor_code = "edt"; compiler_code = "com"
-    primary_authors = []; translators = []; editors = []; compilers = []
-    record.find_all{|f| f.tag === "100" }.each do |field|
-      primary_authors << field["a"] if field["a"]
-    end
-    record.find_all{|f| f.tag === "700" }.each do |field|
-      if field["a"]
-        relators = []
-        relators << clean_end_punctuation(field["e"]) if field["e"]
-        relators << clean_end_punctuation(field["4"]) if field["4"]
-        if relators.include?(translator_code)
-          translators << field["a"]
-        elsif relators.include?(editor_code)
-          editors << field["a"]
-        elsif relators.include?(compiler_code)
-          compilers << field["a"]
-        else
-          primary_authors << field["a"]
-        end
-      end
-    end
-    {:primary_authors => primary_authors, :translators => translators, :editors => editors, :compilers => compilers}
-  end
-  
-  def abbreviate_name(name)
-    name_parts = name.split(", ")
-    first_name_parts = name_parts.last.split(" ")
-    temp_name = name_parts.first + ", " + first_name_parts.first[0,1] + "."
-    first_name_parts.shift
-    temp_name += " " + first_name_parts.join(" ") unless first_name_parts.empty?
-    temp_name
-  end
-
-  def name_reverse(name)
-    name = clean_end_punctuation(name)
-    return name unless name =~ /,/
-    temp_name = name.split(", ")
-    return temp_name.last + " " + temp_name.first
-  end 
-  
-end