enju_loc 0.1.0.pre1

checksums.yaml

@@ -0,0 +1,7 @@
+---
+SHA1:
+  metadata.gz: 161a209a154952a583d5b7097b1d0095da0799dd
+  data.tar.gz: 28c269f6d80449a75cafc7222fc7e9d0dbab9d47
+SHA512:
+  metadata.gz: 5f0159d182e91d36adafde8eacd5cba7a9f3a030e16f786d1863372c4dc2c05fb613ecf7f87c11d77a74a898bd4fe5ff0d93c1ee5ea244f10c8ccc44b0f6fec8
+  data.tar.gz: 9f510d2b528a306917ccedd6d824bffa495b0c1529ac4a14e0a3b26a7fd813c66ee30532f59a04594404373e2ed6e8c0b9b50e3948fbf290c24acacee6cf792c

data/MIT-LICENSE

@@ -0,0 +1,20 @@
+Copyright 2013 YOURNAME
+
+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,3 @@
+= EnjuLoc
+
+This project rocks and uses MIT-LICENSE.

data/Rakefile

@@ -0,0 +1,38 @@
+#!/usr/bin/env rake
+begin
+  require 'bundler/setup'
+rescue LoadError
+  puts 'You must `gem install bundler` and `bundle install` to run rake tasks'
+end
+begin
+  require 'rdoc/task'
+rescue LoadError
+  require 'rdoc/rdoc'
+  require 'rake/rdoctask'
+  RDoc::Task = Rake::RDocTask
+end
+
+RDoc::Task.new(:rdoc) do |rdoc|
+  rdoc.rdoc_dir = 'rdoc'
+  rdoc.title    = 'EnjuLoc'
+  rdoc.options << '--line-numbers'
+  rdoc.rdoc_files.include('README.rdoc')
+  rdoc.rdoc_files.include('lib/**/*.rb')
+end
+
+APP_RAKEFILE = File.expand_path("../spec/dummy/Rakefile", __FILE__)
+load 'rails/tasks/engine.rake'
+
+
+
+Bundler::GemHelper.install_tasks
+
+require 'rspec/core'
+require 'rspec/core/rake_task'
+
+RSpec::Core::RakeTask.new(:spec) do |spec|
+  spec.pattern = FileList['spec/**/*_spec.rb']
+end
+
+
+task :default => :spec

data/app/assets/javascripts/loc_search.js

@@ -0,0 +1,2 @@
+// Place all the behaviors and hooks related to the matching controller here.
+// All this logic will automatically be available in application.js.

data/app/assets/stylesheets/loc_search.css

@@ -0,0 +1,4 @@
+/*
+  Place all the styles related to the matching controller here.
+  They will automatically be included in application.css.
+*/

data/app/controllers/loc_search_controller.rb

@@ -0,0 +1,49 @@
+class LocSearchController < ApplicationController
+  before_filter :authenticate_user!
+  before_filter :check_librarian
+  
+  def index
+    if params[:page].to_i <= 0
+      page = 1
+    else
+      page = params[:page].to_i
+    end
+    @query = params[ :query ].to_s.strip
+    books = LocSearch.search( @query, { :page => page } )
+    @books = Kaminari.paginate_array(
+      books[:items],
+      :total_count => books[ :total_entries ],
+      :page => page
+    ).page( page ).per( 10 )
+    respond_to do |format|
+      format.html
+    end
+  end
+
+  def create
+    begin
+      @manifestation = LocSearch.import_from_sru_response(params[:book][:lccn])
+    rescue EnjuLoc::RecordNotFound
+    end
+    respond_to do |format|
+      if @manifestation.try(:save)
+        flash[:notice] = t('controller.successfully_created', :model => t('activerecord.models.manifestation'))
+        format.html { redirect_to manifestation_url(@manifestation) }
+      else
+	if @manifestation and not @manifestation.valid? 
+	  flash[:notice] = @manifestation.errors.messages
+	else
+          flash[:notice] = t('enju_loc.record_not_found')
+	end
+        format.html { redirect_to loc_search_index_url }
+      end
+    end
+  end
+
+  private
+  def check_librarian
+    unless current_user.try(:has_role?, 'Librarian')
+      access_denied
+    end
+  end
+end

data/app/helpers/loc_search_helper.rb

@@ -0,0 +1,18 @@
+module LocSearchHelper
+  def link_to_import_from_loc(lccn)
+    if lccn.blank?
+      t('enju_loc.not_available')
+    else
+      identifier_type = IdentifierType.where(:name => 'lccn').first
+      if identifier_type
+        manifestation = Identifier.where(:body => lccn, :identifier_type_id => identifier_type
+.id).first.try(:manifestation)
+      end
+      unless manifestation
+        link_to t('enju_loc.add'), loc_search_index_path(:book => {:lccn => lccn}), :method => :post
+      else
+        link_to t('enju_loc.already_exists'), manifestation
+      end
+    end
+  end
+end

data/app/models/loc_search.rb

@@ -0,0 +1,97 @@
+class LocSearch
+  def initialize( node )
+    @node = node
+  end
+  class ModsRecord < LocSearch
+    MODS_NS = { "mods" => "http://www.loc.gov/mods/v3" }
+    def title
+      title = @node.xpath( './/mods:titleInfo/mods:title', MODS_NS ).first.content
+      subtitle = @node.xpath( './/mods:titleInfo/mods:subTitle', MODS_NS ).first
+      title += " : #{ subtitle.content }" if subtitle
+      title
+    end
+    def lccn
+      @node.xpath( './/mods:mods/mods:identifier[@type="lccn"]', MODS_NS ).first.try( :content )
+    end
+    def creator
+      statement_of_responsibility = @node.at('.//mods:note[@type="statement of responsibility"]',MODS_NS).try(:content)
+      if statement_of_responsibility
+        statement_of_responsibility
+      else
+        names = @node.xpath( './/mods:name', MODS_NS )
+        creator = names.map do |name|
+          name.xpath( './/mods:namePart', MODS_NS ).map do |part|
+            if part.content
+              part.content
+            else
+              nil
+            end
+          end.compact.join( ", " )
+        end.join( " ; " )
+        creator
+      end
+    end
+    def publisher
+      names = @node.xpath( './/mods:publisher', MODS_NS ).map do |e|
+        e.content
+      end.join( ", " )
+    end
+    def pubyear
+      @node.xpath( './/mods:dateIssued', MODS_NS ).first.try(:content)
+    end
+  end
+
+  class DCRecord < LocSearch
+    DC_NS = { "dc" => "http://purl.org/dc/elements/1.1/" }
+    def title
+      title = @node.xpath( './/dc:title', DC_NS ).first.content
+    end
+    def lccn	
+      @node.xpath( './/dc:identifier[@type="lccn"]', DC_NS ).first.content
+    end
+    def creator
+    end
+  end
+
+  # http://www.loc.gov/z3950/lcserver.html
+  LOC_SRU_BASEURL = "http://lx2.loc.gov:210/LCDB"
+  def self.make_sru_request_uri( query, options = {} )
+    if options[ :page ]
+      page = options[ :page ].to_i
+      options[ :startRecord ] = ( page - 1 ) * 10 + 1
+      options.delete :page
+    end
+    options = { :maximumRecords => 10, :recordSchema => :mods }.merge( options )
+    options = options.merge( { :query => query, :version => "1.1", :operation => "searchRetrieve" } )
+    params = options.map do |k, v|
+      "#{ URI.escape( k.to_s ) }=#{ URI.escape( v.to_s ) }"
+      end.join( '&' )
+    uri = "#{ LOC_SRU_BASEURL }?#{ params }"
+  end
+
+  def self.search( query, options = {} )
+    if query and not query.empty?
+      doc = nil
+      results = {}
+      url = make_sru_request_uri( query, options )
+      doc = Nokogiri::XML( open(url) )
+      items = doc.search( '//zs:record' ).map{|e| ModsRecord.new e }
+      @results = { :items => items,
+                   :total_entries => doc.xpath( '//zs:numberOfRecords' ).first.try(:content).to_i }
+    else
+      { :items => [], :total_entries => 0 }
+    end
+  end
+
+  def self.import_from_sru_response( lccn )
+    identifier = Identifier.where(:body => lccn, :identifier_type_id => IdentifierType.where(:name => 'lccn').first_or_create.id).first
+    return if identifier
+    url = make_sru_request_uri( "bath.lccn=#{ lccn }" )
+    response = Nokogiri::XML( open(url) ).at( '//zs:recordData', {"zs"=>"http://www.loc.gov/zing/srw/"} )
+    return unless response.try( :content )
+    doc = Nokogiri::XML::Document.new
+    doc << response.at( "//mods:mods", { "mods" => "http://www.loc.gov/mods/v3" } )
+    Manifestation.import_record_from_loc( doc )
+  end
+end
+

data/app/views/loc_search/index.html.erb

@@ -0,0 +1,49 @@
+<div id="content_detail" class="ui-corner-all ui-widget-content">
+<h1 class="title"><%= t('enju_loc.import_from_loc_search') %></h1>
+<div id="content_list">
+<p id="notice"><%= notice %></p>
+<%= form_for :loc_search, :url => loc_search_index_path, :html => {:method => 'get'} do -%>
+  <p>
+    <%= label_tag :search_form_top, t('page.search_term') -%>:
+    <%= search_field_tag 'query', h(@query), {:id => 'search_form_top', :class => 'search_form'} -%>
+    <%= submit_tag t('page.search') -%>
+  </p>
+<%- end -%>
+<% if @query.present? %>
+<p><%= t('enju_loc.number_of_search_results', :count => @books.total_count) %></p>
+<table class="table table-striped index">
+  <tr>
+    <th></th>
+    <th><%= t('activerecord.attributes.manifestation.original_title') %></th>
+  </tr>
+<% @books.each do |book| -%>
+  <tr class="line<%= cycle("0", "1") -%>">
+    <td>
+      <%= link_to_import_from_loc(book.lccn) %>
+    </td>
+    <td>
+      <strong><%= link_to_unless( book.lccn.blank?, book.title, "http://lccn.loc.gov/#{ book.lccn }" ) do book.title end %></strong><br />
+      <%=h book.creator -%><br />
+      <%=h book.publisher -%>,
+      <%=h book.pubyear -%>
+    </td>
+  </tr>
+<% end -%>
+</table>
+<br />
+<%= paginate(@books) %>
+
+<% else %>
+  <%= javascript_tag("$('#search_form_top').focus()") -%>
+<% end %>
+
+</div>
+</div>
+
+<div id="submenu" class="ui-corner-all ui-widget-content">
+<% if defined?(EnjuNdl) %>
+  <ul>
+    <li><%= link_to t('enju_ndl.import_from_ndl_search'), ndl_books_path( :query => @query ) %></li>
+  </ul>
+<% end %>
+</div>

data/config/locales/en.yml

@@ -0,0 +1,13 @@
+en:
+  enju_loc:
+    import_from_loc_search: Import from LoC Search
+    record_not_found: Record not found.
+    not_available: Not available
+    add: Add
+    already_exists: Already exists
+    number_of_search_results:
+      one: "1 record found."
+      other: "%{count} records found."
+  activerecord:
+    models:
+      loc_search: LoC Catalog Search

data/config/locales/ja.yml

@@ -0,0 +1,11 @@
+ja:
+  enju_loc:
+    import_from_loc_search: 米国議会図書館検索によるインポート
+    record_not_found: 資料が見つかりません。
+    not_available: 利用不可
+    add: 追加
+    already_exists: 登録済み
+    number_of_search_results: "%{count} 件の資料が見つかりました。"
+  activerecord:
+    models:
+      loc_search: 米国議会図書館(LoC)蔵書検索

data/config/routes.rb

@@ -0,0 +1,3 @@
+Rails.application.routes.draw do
+  resources :loc_search, :only => [:index, :create]
+end

data/lib/enju_loc.rb

@@ -0,0 +1,21 @@
+require "enju_loc/engine"
+require "enju_loc/loc_search"
+
+module EnjuLoc
+  module ActsAsMethods
+    def self.included(base)
+      base.extend ClassMethods
+    end
+
+    module ClassMethods
+      def enju_loc_search
+        include EnjuLoc::LocSearch
+      end
+    end
+  end
+
+  class RecordNotFound < StandardError; end
+  class InvalidIsbn < StandardError; end
+end
+
+ActiveRecord::Base.send :include, EnjuLoc::ActsAsMethods

data/lib/enju_loc/engine.rb

@@ -0,0 +1,7 @@
+require 'enju_seed'
+require 'nokogiri'
+
+module EnjuLoc
+  class Engine < ::Rails::Engine
+  end
+end

data/lib/enju_loc/loc_search.rb

@@ -0,0 +1,537 @@
+module EnjuLoc
+  module LocSearch
+    def self.included(base)
+      base.extend ClassMethods
+    end
+
+    module ClassMethods
+      def loc_search(query, options = {})
+        options = {}.merge(options)
+        doc = nil
+        results = {}
+        startrecord = options[:idx].to_i
+        if startrecord == 0
+          startrecord = 1
+        end
+        url = LOC_SRU_BASEURL + "?operation=searchRetrieve&version=1.1&=query=#{ URI.escape(query) }"
+        cont = open( url ){|io| io.read }
+        parser = LibXML::XML::Parser.string( cont )
+        doc = parser.parse
+      end
+
+      def import_record_from_loc_isbn(options)
+        #if options[:isbn]
+          lisbn = Lisbn.new(options[:isbn])
+          raise EnjuLoc::InvalidIsbn unless lisbn.valid?
+        #end
+
+        manifestation = Manifestation.find_by_isbn(lisbn.isbn)
+        return manifestation.first if manifestation.present?
+
+        doc = return_xml(lisbn.isbn)
+        raise EnjuLoc::RecordNotFound unless doc
+        import_record_from_loc(doc)
+      end
+
+      NS = {"mods"=>"http://www.loc.gov/mods/v3"}
+      def import_record_from_loc( doc )
+        record_identifier = doc.at( '//mods:recordInfo/mods:recordIdentifier', NS ).try(:content)
+        loc_identifier = Identifier.where(:body => record_identifier, :identifier_type_id => IdentifierType.where(:name => 'loc_identifier').first_or_create.id).first
+        return loc_identifier.manifestation if loc_identifier
+
+        publishers = []
+        doc.xpath('//mods:publisher',NS).each do |publisher|
+          publishers << {
+            :full_name => publisher.content,
+            #:agent_identifier => publisher.attributes["about"].try(:content)
+          }
+        end
+
+        creators = get_creators(doc)
+
+        # title
+        titles = get_titles(doc)
+
+        # date of publication
+        date = get_date_of_publication(doc)
+
+        language = Language.where(:iso_639_2 => get_language(doc)).first
+        if language
+          language_id = language.id
+        else
+          language_id = 1
+        end
+
+        isbn = Lisbn.new(doc.at('/mods:mods/mods:identifier[@type="isbn"]',NS).try(:content).to_s).try(:isbn)
+        lccn = StdNum::LCCN.normalize(doc.at('/mods:mods/mods:identifier[@type="lccn"]',NS).try(:content).to_s)
+        issn = StdNum::ISSN.normalize(doc.at('/mods:mods/mods:identifier[@type="issn"]',NS).try(:content).to_s)
+        issn_l = StdNum::ISSN.normalize(doc.at('/mods:mods/mods:identifier[@type="issn-l"]',NS).try(:content).to_s)
+
+	types = get_carrier_and_content_types( doc )
+	content_type = types[ :content_type ]
+	carrier_type = types[ :carrier_type ]
+
+	record_identifier = doc.at('//mods:recordInfo/mods:recordIdentifier',NS).try(:content)
+        description = doc.xpath('//mods:abstract',NS).collect(&:content).join("\n")
+        edition_string = doc.at('//mods:edition',NS).try(:content)
+        extent = get_extent(doc)
+	note = get_note(doc)
+        frequency = get_frequency(doc)
+	issuance = doc.at('//mods:issuance',NS).try(:content)
+	is_serial = true if issuance == "serial"
+        statement_of_responsibility = get_statement_of_responsibility(doc)
+	access_address = get_access_address(doc)
+	publication_place = get_publication_place(doc)
+
+        manifestation = nil
+        Agent.transaction do
+	  creator_agents = Agent.import_agents(creators)
+          publisher_agents = Agent.import_agents(publishers)
+
+          manifestation = Manifestation.new(
+            :manifestation_identifier => record_identifier,
+            :original_title => titles[:original_title],
+            :title_alternative => titles[:title_alternative],
+            :language_id => language_id,
+            :pub_date => date,
+            :description => description,
+	    :edition_string => edition_string,
+            :statement_of_responsibility => statement_of_responsibility,
+            :start_page => extent[:start_page],
+            :end_page => extent[:end_page],
+            :height => extent[:height],
+	    :access_address => access_address,
+	    :note => note,
+	    :publication_place => publication_place,
+	    :periodical => is_serial,
+          )
+          identifier = {}
+          if isbn
+            identifier[:isbn] = Identifier.new(:body => isbn)
+            identifier[:isbn].identifier_type = IdentifierType.where(:name => 'isbn').first_or_create
+          end
+          if loc_identifier
+            identifier[:loc_identifier] = Identifier.new(:body => loc_identifier)
+            identifier[:loc_identifier].identifier_type = IdentifierType.where(:name => 'loc_identifier').first_or_create
+          end
+          if lccn
+            identifier[:lccn] = Identifier.new(:body => lccn)
+            identifier[:lccn].identifier_type = IdentifierType.where(:name => 'lccn').first_or_create
+          end
+          if issn
+            identifier[:issn] = Identifier.new(:body => issn)
+            identifier[:issn].identifier_type = IdentifierType.where(:name => 'issn').first_or_create
+          end
+          if issn_l
+            identifier[:issn_l] = Identifier.new(:body => issn_l)
+            identifier[:issn_l].identifier_type = IdentifierType.where(:name => 'issn_l').first_or_create
+          end
+          manifestation.carrier_type = carrier_type if carrier_type
+          manifestation.manifestation_content_type = content_type if content_type
+	  manifestation.frequency = frequency if frequency
+          if manifestation.save
+            identifier.each do |k, v|
+              manifestation.identifiers << v if v.valid?
+            end
+            manifestation.publishers << publisher_agents
+	    manifestation.creators << creator_agents
+	    create_subject_related_elements(doc, manifestation)
+            create_series_statement(doc, manifestation)
+	    if is_serial
+              create_series_master(doc, manifestation)
+	    end
+          end
+        end
+        return manifestation
+      end
+
+      private
+      def create_subject_related_elements(doc, manifestation)
+	subjects = get_subjects(doc)
+	classifications = get_classifications(doc)
+	if defined?(EnjuSubject)
+          subject_heading_type = SubjectHeadingType.where(:name => 'lcsh').first_or_create
+          subjects.each do |term|
+            subject = Subject.where(:term => term[:term]).first
+            unless subject
+              subject = Subject.new(term)
+              subject.subject_heading_type = subject_heading_type
+              subject.subject_type = SubjectType.where(:name => 'concept').first_or_create
+            end
+            manifestation.subjects << subject
+          end
+          if classifications
+            classification_type = ClassificationType.where(:name => 'ddc').first_or_create
+	    classifications.each do |ddc|
+              classification = Classification.where(:category => ddc).first
+	      unless classification
+                classification = Classification.new(:category => ddc)
+                classification.classification_type = classification_type
+	      end
+              manifestation.classifications << classification if classification.valid?
+            end
+          end
+	end
+      end
+
+      def create_series_statement(doc, manifestation)
+        doc.xpath('//mods:relatedItem[@type="series"]/mods:titleInfo/mods:title',NS).each do |series|
+          series_title = title = series.try(:content)
+          if title
+            series_title = title.split(';')[0].strip
+          end
+          if series_title
+            series_statement = SeriesStatement.where(:original_title => series_title).first_or_create
+            if series_statement.try(:save)
+              manifestation.series_statements << series_statement
+            end
+          end
+        end
+      end
+      
+      def create_series_master(doc, manifestation)
+        titles = get_titles(doc)
+	series_statement = SeriesStatement.new(
+	  :original_title => titles[:original_title],
+	  :title_alternative => titles[:title_alternative],
+	  :series_master => true,
+	)
+	if series_statement.try(:save)
+	  manifestation.series_statements << series_statement
+	end
+      end
+
+      def get_titles(doc)
+	original_title = ""
+	title_alternatives = []
+	doc.xpath('//mods:mods/mods:titleInfo',NS).each do |e|
+	  type = e.attributes["type"].try(:content)
+	  case type
+	  when "alternative", "translated", "abbreviated", "uniform"
+	    title_alternatives << e.at('./mods:title',NS).content
+	  else
+	    nonsort = e.at('./mods:nonSort',NS).try(:content)
+	    original_title << nonsort if nonsort
+	    original_title << e.at('./mods:title',NS).try(:content)
+	    subtitle = e.at('./mods:subTitle',NS).try(:content)
+	    original_title << " : #{ subtitle }" if subtitle
+	    partnumber = e.at('./mods:partNumber',NS).try(:content)
+	    partname = e.at('./mods:partName',NS).try(:content)
+	    partname = [ partnumber, partname ].compact.join( ": " )
+	    original_title << ". #{ partname }" unless partname.blank?
+	  end
+	end
+	{ :original_title => original_title, :title_alternative => title_alternatives.join( " ; " ) }
+      end
+
+      def get_language(doc)
+	language = doc.at('//mods:language/mods:languageTerm[@authority="iso639-2b"]',NS).try(:content)
+      end
+
+      def get_access_address(doc)
+	access_address = nil
+	url = doc.at('//mods:location/mods:url',NS)
+	if url
+	  usage = url.attributes["usage"].try(:content)
+	  case usage
+	  when "primary display", "primary"
+	    access_address = url.try(:content)
+	  end
+	end
+	access_address
+      end
+
+      def get_publication_place(doc)
+	place = doc.at('//mods:originInfo/mods:place/mods:placeTerm[@type="text"]',NS).try(:content)
+      end
+
+      def get_extent(doc)
+        extent = doc.at('//mods:extent',NS).try(:content)
+        value = {:start_page => nil, :end_page => nil, :height => nil}
+        if extent
+          extent = extent.split(';')
+          page = extent[0].try(:strip)
+          if page =~ /(\d+)\s*(p|page)/
+            value[:start_page] = 1
+            value[:end_page] = $1.dup.to_i
+          end
+          height = extent[1].try(:strip)
+          if height =~ /(\d+)\s*cm/
+            value[:height] = $1.dup.to_i
+          end
+        end
+        value
+      end
+
+      def get_statement_of_responsibility(doc)
+	note = doc.at('//mods:note[@type="statement of responsibility"]',NS).try(:content)
+	if note
+	  note
+	else
+	  doc.xpath('/mods:mods/mods:name',NS).map do |n|
+	    n.at('./mods:namePart',NS).try(:content)
+	  end.join( "; " )
+	end
+      end
+      def get_note(doc)
+        notes = []
+	doc.xpath('//mods:note',NS).each do |note|
+	  type = note.attributes['type'].try(:content)
+	  next if type == "statement of responsibility"
+	  note_s = note.try( :content )
+	  notes << note_s unless note_s.blank?
+	end
+	if notes.empty?
+	  nil
+	else
+	  notes.join( ";\n" )
+	end
+      end
+      def get_date_of_publication(doc)
+        dates = []
+	doc.xpath('//mods:dateIssued',NS).each do |pub_date|
+	  pub_date = pub_date.content.sub( /\A[cp]/, '' )
+          next unless pub_date =~ /^\d+(-\d\d?){0,2}$/
+          date = pub_date.split('-')
+          if date[0] and date[1]
+            dates << sprintf("%04d-%02d", date[0], date[1])
+          else
+            dates << pub_date
+	  end
+        end
+	dates.compact.first
+      end
+
+      # derived from marcfrequency: http://www.loc.gov/standards/valuelist/marcfrequency.html
+      MARCFREQUENCY = [
+        "Continuously updated",
+        "Daily",
+        "Semiweekly",
+        "Three times a week",
+        "Weekly",
+        "Biweekly",
+        "Three times a month",
+        "Semimonthly",
+        "Monthly",
+        "Bimonthly",
+        "Quarterly",
+        "Three times a year",
+        "Semiannual",
+        "Annual",
+        "Biennial",
+        "Triennial",
+        "Completely irregular",
+      ]
+      def get_frequency(doc)
+        frequencies = []
+	doc.xpath('//mods:frequency',NS).each do |freq|
+	  frequency = freq.try(:content)
+	  MARCFREQUENCY.each do |freq_regex|
+	    if /\A(#{freq_regex})/ =~ frequency
+	      frequency_name = freq_regex.downcase.gsub( /\s+/, "_" )
+	      frequencies << Frequency.where( :name => frequency_name ).first
+	    end
+	  end
+	end
+	frequencies.compact.first
+      end
+
+      def get_creators(doc)
+	creators = []
+        doc.xpath('/mods:mods/mods:name',NS).each do |creator|
+	  creators << {
+	    :full_name => creator.xpath('./mods:namePart',NS).collect(&:content).join( ", " ),
+	  }
+        end
+	creators.uniq
+      end
+
+      # TODO:only LCSH-based parsing...
+      def get_subjects(doc)
+	subjects = []
+	doc.xpath('//mods:subject[@authority="lcsh"]',NS).each do |s|
+	  subject = []
+	  s.xpath('./*',NS).each do |subelement|
+	    type = subelement.name
+	    case subelement.name
+	    when "topic", "geographic", "genre", "temporal"
+	      subject << { :type => type , :term => subelement.try(:content) }
+	    when "titleInfo"
+	      subject << { :type => type, :term => subelement.at('./mods:title',NS).try(:content) }
+	    when "name"
+	      name = subelement.xpath('./mods:namePart',NS).map{|e| e.try(:content) }.join( ", " )
+	      subject << { :type => type, :term => name }
+	    end
+	  end
+	  next if subject.compact.empty?
+	  if subject.size > 1 and subject[0][:type] == "name" and subject[1][:type] == "titleInfo"
+	    subject[0..1] = { :term => subject[0..1].map{|e|e[:term]}.join( ". " ) }
+	  end
+	  subjects << {
+	    :term => subject.map{|e|e[:term]}.compact.join( "--" )
+	  }
+	end
+	subjects
+      end
+
+      # TODO:support only DDC.
+      def get_classifications(doc)
+	classifications = []
+	doc.xpath('//mods:classification[@authority="ddc"]',NS).each do|c|
+	  ddc = c.content
+	  if ddc
+	    classifications << ddc.split(/[^\d\.]/).first.try(:strip)
+	  end
+	end
+	classifications.compact
+      end
+
+      def get_carrier_and_content_types(doc)
+        carrier_type = content_type = nil
+        doc.xpath('//mods:form',NS).each do |e|
+          authority = e.attributes['authority'].try(:content)
+	  case authority
+	  when "gmd"
+	    case e.content
+	    when "electronic resource"
+	      carrier_type = CarrierType.where(:name => 'file').first
+	    when "videorecording"
+              content_type = ContentType.where(:name => 'video').first
+	    #TODO: Enju needs more specific mappings...
+	    when "art original"
+	    when "microscope slides"
+	    when "art reproduction"
+	    when "model"
+	    when "chart"
+	    when "motion picture"
+	    when "diorama"
+	    when "picture"
+	    when "realia"
+	    when "filmstrip"
+	    when "slide"
+	    when "flash card"
+	    when "sound recording"
+	    when "game"
+	    when "technical drawing"
+	    when "graphic"
+	    when "toy"
+	    when "kit"
+	    when "transparency"
+	    when "microform"
+	    end
+	  when "marcsmd" # cf.http://www.loc.gov/standards/valuelist/marcsmd.html
+	    case e.content
+            when "text", "braille", "large print", "regular print", "text in looseleaf binder"
+              carrier_type = CarrierType.where(:name => 'print').first
+              content_type = ContentType.where(:name => 'text').first
+	    when "videorecording", "videocartridge", "videocassette", "videodisc", "videoreel"
+              content_type = ContentType.where(:name => 'video').first
+	    when "electronic resource", "chip cartridge", "computer optical disc cartridge", "magnetic disk", "magneto-optical disc", "optical disc", "remote", "tape cartridge", "tape cassette", "tape reel"
+	      carrier_type = CarrierType.where(:name => 'file').first
+	    when "motion picture", "film cartridge", "film cassette", "film reel"
+              content_type = ContentType.where(:name => 'video').first
+	    when "sound recording", "cylinder", "roll ", "sound cartridge", "sound cassette ", "sound disc ", "sound-tape reel", "sound-track film ", "wire recording" 
+	      conrent_type = ContentType.where(:name => 'audio').first
+	    #when "nonprojected graphic", "chart", "collage", "drawing", "flash card", "painting", "photomechanical print", "photonegative", "photoprint", "picture", "print", "technical drawing", "projected graphic", "filmslip", "filmstrip cartridge", "filmstrip roll", "other filmstrip type ", "slide", "transparency"
+            #  content_type = ContentType.where(:name => 'image').first
+	    #TODO: Enju needs more specific mappings...
+	    when "globe"
+	    when "celestial globe"
+	    when "earth moon globe"
+	    when "planetary or lunar globe"
+	    when "terrestrial globe"
+	    when "map"
+	    when "atlas"
+	    when "diagram"
+	    when "map"
+	    when "model"
+	    when "profile "
+	    when "remote-sensing image"
+	    when "section"
+	    when "view"
+	    when "microform"
+	    when "aperture card"
+	    when "microfiche"
+	    when "microfiche cassette"
+	    when "microfilm cartridge"
+	    when "microfilm cassette"
+	    when "microfilm reel"
+	    when "microopaque"
+	    when "tactile material"
+            when "braille"
+            when "combination"
+            when "moon"
+            when "tactile, with no writing system"
+	    end
+	  when "marcform" # cf. http://www.loc.gov/standards/valuelist/marcform.html
+	    case e.content
+	    when "print", "large print"
+              carrier_type = CarrierType.where(:name => 'print').first
+              content_type = ContentType.where(:name => 'text').first
+	    when "electronic"
+              carrier_type = CarrierType.where(:name => 'file').first
+	    #TODO: Enju needs more specific mappings...
+	    when "microfiche"
+	    when "braille"
+	    when "microfilm"
+	    end
+	  end
+	end
+        doc.xpath('//mods:genre',NS).each do |e|
+          authority = e.attributes['authority'].try(:content)
+	  case authority
+	  when "rdacontent"
+	    case e.content
+	    when "computer dataset", "computer program"
+              content_type = ContentType.where(:name => 'file').first
+	    when "sounds", "spoken word"
+              content_type = ContentType.where(:name => 'audio').first
+	    when "text"
+              content_type = ContentType.where(:name => 'text').first
+	    when "two-dimensional moving image"
+              content_type = ContentType.where(:name => 'video').first
+	    #TODO: Enju needs more specific mappings...
+	    when "cartographic dataset"
+	    when "cartographic image"
+	    when "cartographic moving image"
+	    when "cartographic tactile image"
+	    when "cartographic tactile three-dimensional form"
+	    when "cartographic three-dimensional form"
+	    when "notated movement"
+	    when "notated music"
+	    when "performed music"
+	    when "still image"
+	    when "tactile image"
+	    when "tactile notated music"
+	    when "tactile notated movement"
+	    when "tactile text"
+	    when "tactile three-dimensional form"
+	    when "three-dimensional form"
+	    when "three-dimensional moving image"
+	    when "other"
+	    when "unspecified"
+            end
+          end
+        end
+	type = doc.at('//mods:typeOfResource',NS).try(:content)
+	case type
+	when "text"
+	  content_type = ContentType.where(:name => 'text').first
+	when "sound recording", "sound recording-musical", "sound recording-nonmusical"
+	  content_type = ContentType.where(:name => 'audio').first
+	when "moving image"
+	  content_type = ContentType.where(:name => 'video').first
+	when "software, multimedia"
+	  carrier_type = ContentType.where(:name => 'file').first
+	#TODO: Enju needs more specific mappings...
+	when "cartographic "
+	when "notated music"
+	when "still image"
+	when "three dimensional object"
+	when "mixed material"
+	end
+        { :carrier_type => carrier_type, :content_type => content_type }
+      end
+    end
+  end
+end