enju_loc 0.2.0 → 0.3.0.beta.1

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA1:
-  metadata.gz: 02705ea8e6f5e989ef15b5af8e99a0f2cbde1a62
-  data.tar.gz: 9ea8deb70d906514194f05ebff38091f908a8e6b
+  metadata.gz: 5df92cc8c1fb95ba8861f40e551be3315289c095
+  data.tar.gz: 2fda9f1c77f120a3b95ef1e021384f3ca5b7cb5d
 SHA512:
-  metadata.gz: f8ca889b9f75cdce7e77431c3ec615743af92a94d16fc5f109b23cb7e6b089d233cfe21ad9d0262e831fddd994bc1800b2f9326be49e18ba834e82d12cebc17c
-  data.tar.gz: 1ebadcc88e584d09746ef24ded20c7cea7f43691542a65f933002c34d993a97bb455057fa04b9ae3fea1596514a3e21fbf963255b202ae8ba239cc13883a4c9e
+  metadata.gz: 1fd88540628fcd38c8a61c5c2a67da3e3e431aa5994f858fbb7bc050479a096a0e13ecfa5daea116860a1ede7e76276cf3b67f779d04a8f3cec50e452c7e6560
+  data.tar.gz: 613e137ead842eb8b90b28dcd955b32b13f1b9ed203fce870878c95d1452bfe06a1bd17fc6361c83d7b2e9b076ed33136c6d3b12c29268086a10a0aa8d5533c5

data/README.rdoc

@@ -1,11 +1,11 @@
 = EnjuLoc
-{<img src="https://travis-ci.org/next-l/enju_ndl.svg?branch=1.2" alt="Build Status" />}[https://travis-ci.org/next-l/enju_ndl]
-{<img src="https://coveralls.io/repos/next-l/enju_ndl/badge.svg?branch=1.2&service=github" alt="Coverage Status" />}[https://coveralls.io/github/next-l/enju_ndl?branch=1.2]
-{<img src="https://hakiri.io/github/next-l/enju_loc/1.2.svg" alt="security" />}[https://hakiri.io/github/next-l/enju_loc/1.2]
+{<img src="https://travis-ci.org/next-l/enju_ndl.svg?branch=1.3" alt="Build Status" />}[https://travis-ci.org/next-l/enju_ndl]
+{<img src="https://coveralls.io/repos/next-l/enju_ndl/badge.svg?branch=1.3&service=github" alt="Coverage Status" />}[https://coveralls.io/github/next-l/enju_ndl?branch=1.3]
+{<img src="https://hakiri.io/github/next-l/enju_loc/1.3.svg" alt="security" />}[https://hakiri.io/github/next-l/enju_loc/1.3]
 
 This project rocks and uses MIT-LICENSE.
 
 == 製作者・貢献者 (Authors and contributors)
 * {TAKAKU, Masao}[https://github.com/masao] ({@tmasao}[https://twitter.com/tmasao])
 * {TANABE, Kosuke}[https://github.com/nabeta] ({@nabeta}[https://twitter.com/nabeta])
-* {Project Next-L}[http://www.next-l.jp] ({@ProjectNextL}[https://twitter.com/ProjectNextL])
+* {Project Next-L}[https://www.next-l.jp] ({@ProjectNextL}[https://twitter.com/ProjectNextL])

data/app/controllers/loc_search_controller.rb

@@ -8,11 +8,10 @@ class LocSearchController < ApplicationController
       page = params[:page].to_i
     end
     @query = params[ :query ].to_s.strip
-    books = LocSearch.search( @query, { :page => page } )
+    books = LocSearch.search( @query, { page: page } )
     @books = Kaminari.paginate_array(
       books[:items],
-      :total_count => books[ :total_entries ],
-      :page => page
+      total_count: books[ :total_entries ]
     ).page( page ).per( 10 )
     respond_to do |format|
       format.html
@@ -21,19 +20,19 @@ class LocSearchController < ApplicationController
 
   def create
     begin
-      @manifestation = LocSearch.import_from_sru_response(params[:book][:lccn])
+      @manifestation = LocSearch.import_from_sru_response(params[:book].try(:[], 'lccn'))
     rescue EnjuLoc::RecordNotFound
     end
     respond_to do |format|
       if @manifestation.try(:save)
-        flash[:notice] = t('controller.successfully_created', :model => t('activerecord.models.manifestation'))
+        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
+        if @manifestation and not @manifestation.valid?
+          flash[:notice] = @manifestation.errors.messages
+        else
           flash[:notice] = t('enju_loc.record_not_found')
-	end
+        end
         format.html { redirect_to loc_search_index_url }
       end
     end

data/app/helpers/loc_search_helper.rb

@@ -3,9 +3,9 @@ module LocSearchHelper
     if lccn.blank?
       t('enju_loc.not_available')
     else
-      identifier_type = IdentifierType.where(:name => 'lccn').first
+      identifier_type = IdentifierType.where(name: 'lccn').first
       if identifier_type
-        manifestation = Identifier.where(:body => lccn, :identifier_type_id => identifier_type
+        manifestation = Identifier.where(body: lccn, identifier_type_id: identifier_type
 .id).first.try(:manifestation)
       end
       unless manifestation

data/app/models/loc_search.rb

@@ -1,56 +1,56 @@
 class LocSearch
-  def initialize( node )
+  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 = @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 )
+      @node.xpath('.//mods:mods/mods:identifier[@type="lccn"]', MODS_NS).first.try(:content)
     end
     def isbn
-      @node.xpath( './/mods:mods/mods:identifier[@type="isbn"]', MODS_NS ).first.try( :content )
+      @node.xpath('.//mods:mods/mods:identifier[@type="isbn"]', MODS_NS).first.try(:content)
     end
     def creator
-      statement_of_responsibility = @node.at('.//mods:note[@type="statement of responsibility"]',MODS_NS).try(:content)
+      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 )
+        names = @node.xpath('.//mods:name', MODS_NS)
         creator = names.map do |name|
-          name.xpath( './/mods:namePart', MODS_NS ).map do |part|
+          name.xpath('.//mods:namePart', MODS_NS).map do |part|
             if part.content
               part.content
             else
               nil
             end
-          end.compact.join( ", " )
-        end.join( " ; " )
+          end.compact.join(", ")
+        end.join(" ; ")
         creator
       end
     end
     def publisher
-      @node.xpath( './/mods:publisher', MODS_NS ).map do |e|
+      @node.xpath('.//mods:publisher', MODS_NS).map do |e|
         e.content
-      end.join( ", " )
+      end.join(", ")
     end
     def pubyear
-      @node.xpath( './/mods:dateIssued', MODS_NS ).first.try(:content)
+      @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
-      @node.xpath( './/dc:title', DC_NS ).first.content
+      @node.xpath('.//dc:title', DC_NS).first.content
     end
     def lccn
-      @node.xpath( './/dc:identifier[@type="lccn"]', DC_NS ).first.content
+      @node.xpath('.//dc:identifier[@type="lccn"]', DC_NS).first.content
     end
     def creator
     end
@@ -58,21 +58,21 @@ class LocSearch
 
   # http://www.loc.gov/z3950/lcserver.html
   LOC_SRU_BASEURL = "http://lx2.loc.gov:210/LCDB"
-  def self.make_sru_request_uri( query, options = {} )
+  def self.make_sru_request_uri(query, options = {})
     if options[ :page ]
       page = options[ :page ].to_i
-      options[ :startRecord ] = ( page - 1 ) * 10 + 1
+      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" } )
+    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.escape(k.to_s) }=#{ URI.escape(v.to_s) }"
+      end.join('&')
     uri = "#{ LOC_SRU_BASEURL }?#{ params }"
   end
 
-  def self.search( query, options = {} )
+  def self.search(query, options = {})
     if query and !query.empty?
       url = make_sru_request_uri(query, options)
       doc = Nokogiri::XML(Faraday.get(url).body)
@@ -91,10 +91,10 @@ class LocSearch
     return if identifier
     url = make_sru_request_uri("bath.lccn=\"^#{ lccn }\"")
     response = Nokogiri::XML(Faraday.get(url).body)
-    record = response.at( '//zs:recordData', {"zs" => "http://www.loc.gov/zing/srw/"} )
+    record = response.at('//zs:recordData', {"zs" => "http://www.loc.gov/zing/srw/"})
     return unless record.try(:content)
     doc = Nokogiri::XML::Document.new
-    doc << record.at( "//mods:mods", { "mods" => "http://www.loc.gov/mods/v3" } )
+    doc << record.at("//mods:mods", { "mods" => "http://www.loc.gov/mods/v3" })
     Manifestation.import_record_from_loc(doc)
   end
 end

data/lib/enju_loc/loc_search.rb

@@ -15,7 +15,7 @@ module EnjuLoc
         end
         url = LOC_SRU_BASEURL + "?operation=searchRetrieve&version=1.1&=query=#{ URI.escape(query) }"
         cont = Faraday.get(url).body
-        parser = LibXML::XML::Parser.string( cont )
+        parser = LibXML::XML::Parser.string(cont)
         doc = parser.parse
       end
 
@@ -34,17 +34,17 @@ module EnjuLoc
       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)
-        identifier_type = IdentifierType.where(name: 'loc_identifier').first
+      def import_record_from_loc(doc)
+        record_identifier = doc.at('//mods:recordInfo/mods:recordIdentifier', NS).try(:content)
+        identifier_type = IdentifierType.find_by(name: 'loc_identifier')
         identifier_type = IdentifierType.create!(name: 'loc_identifier') unless identifier_type
-        loc_identifier = Identifier.where(body: record_identifier, :identifier_type_id => identifier_type.id).first
+        loc_identifier = Identifier.find_by(body: record_identifier, identifier_type_id: identifier_type.id)
         return loc_identifier.manifestation if loc_identifier
 
         publishers = []
         doc.xpath('//mods:publisher', NS).each do |publisher|
           publishers << {
-            :full_name => publisher.content,
+            full_name: publisher.content,
             #:agent_identifier => publisher.attributes["about"].try(:content)
           }
         end
@@ -57,7 +57,7 @@ module EnjuLoc
         # date of publication
         date = get_mods_date_of_publication(doc)
 
-        language = Language.where(:iso_639_2 => get_mods_language(doc)).first
+        language = Language.find_by(iso_639_2: get_mods_language(doc))
         if language
           language_id = language.id
         else
@@ -69,7 +69,7 @@ module EnjuLoc
         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_mods_carrier_and_content_types( doc )
+        types = get_mods_carrier_and_content_types(doc)
         content_type = types[ :content_type ]
         carrier_type = types[ :carrier_type ]
 
@@ -91,62 +91,76 @@ module EnjuLoc
           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],
-            :extent => extent[:extent],
-            :height => extent[:height],
-            :dimensions => extent[:dimensions],
-            :access_address => access_address,
-            :note => note,
-            :publication_place => publication_place,
-            :serial => is_serial
+            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],
+            extent: extent[:extent],
+            height: extent[:height],
+            dimensions: extent[:dimensions],
+            access_address: access_address,
+            note: note,
+            publication_place: publication_place,
+            serial: is_serial
           )
           identifier = {}
           if isbn
-            identifier[:isbn] = Identifier.new(body: isbn)
-            identifier[:isbn].identifier_type = IdentifierType.where(name: 'isbn').first || IdnetifierType.create!(name: 'isbn')
+            identifier[:isbn] = Identifier.new(
+              manifestation: manifestation,
+              body: isbn,
+              identifier_type: IdentifierType.find_by(name: 'isbn') || IdnetifierType.create!(name: 'isbn')
+            )
           end
           if loc_identifier
-            identifier[:loc_identifier] = Identifier.new(body: loc_identifier)
-            identifier[:loc_identifier].identifier_type = IdentifierType.where(name: 'loc_identifier').first || IdnetifierType.create!(name: 'loc_identifier')
+            identifier[:loc_identifier] = Identifier.new(
+              manifestation: manifestation,
+              body: loc_identifier,
+              identifier_type: IdentifierType.find_by(name: 'loc_identifier') || IdnetifierType.create!(name: 'loc_identifier')
+            )
           end
           if lccn
-            identifier[:lccn] = Identifier.new(body: lccn)
-            identifier[:lccn].identifier_type = IdentifierType.where(name: 'lccn').first || IdentifierType.create!(name: 'lccn')
+            identifier[:lccn] = Identifier.new(
+              manifestation: manifestation,
+              body: lccn,
+              identifier_type: IdentifierType.find_by(name: 'lccn') || IdentifierType.create!(name: 'lccn')
+            )
           end
           if issn
-            identifier[:issn] = Identifier.new(body: issn)
-            identifier[:issn].identifier_type = IdentifierType.where(name: 'issn').first || IdentifierType.create!(name: 'issn')
+            identifier[:issn] = Identifier.new(
+              manifestation: manifestation,
+              body: issn,
+              identifier_type: IdentifierType.find_by(name: 'issn') || IdentifierType.create!(name: 'issn')
+            )
           end
           if issn_l
-            identifier[:issn_l] = Identifier.new(body: issn_l)
-            identifier[:issn_l].identifier_type = IdentifierType.where(name: 'issn_l').first || IdentifierType.create!(name: 'issn_l')
+            identifier[:issn_l] = Identifier.new(
+              manifestation: manifestation,
+              body: issn_l,
+              identifier_type: IdentifierType.find_by(name: 'issn_l') || IdentifierType.create!(name: 'issn_l')
+            )
           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_loc_subject_related_elements(doc, manifestation)
-            create_loc_series_statement(doc, manifestation)
-            if is_serial
-              create_loc_series_master(doc, manifestation)
-            end
+          manifestation.save!
+          identifier.each do |k, v|
+            manifestation.identifiers << v if v.valid?
+          end
+          manifestation.publishers << publisher_agents
+          manifestation.creators << creator_agents
+          create_loc_subject_related_elements(doc, manifestation)
+          create_loc_series_statement(doc, manifestation)
+          if is_serial
+            create_loc_series_master(doc, manifestation)
           end
         end
-        return manifestation
+        manifestation
       end
 
       private
@@ -155,25 +169,25 @@ module EnjuLoc
         subjects = get_mods_subjects(doc)
         classifications = get_mods_classifications(doc)
         if defined?(EnjuSubject)
-          subject_heading_type = SubjectHeadingType.where(name: 'lcsh').first || SubjectHeadingType.create!(name: 'lcsh')
+          subject_heading_type = SubjectHeadingType.find_by(name: 'lcsh') || SubjectHeadingType.create!(name: 'lcsh')
           subjects.each do |term|
-            subject = Subject.where(term: term[:term]).first
+            subject = Subject.find_by(term: term[:term])
             unless subject
               subject = Subject.new(term)
               subject.subject_heading_type = subject_heading_type
-              subject.subject_type = SubjectType.where(name: 'concept').first || SubjectType.create!(name: 'concept')
+              subject.subject_type = SubjectType.find_by(name: 'concept') || SubjectType.create!(name: 'concept')
             end
             manifestation.subjects << subject
           end
           if classifications
-            classification_type = ClassificationType.where(name: 'ddc').first || ClassificationType.create!(name: 'ddc')
+            classification_type = ClassificationType.find_by(name: 'ddc') || ClassificationType.create!(name: 'ddc')
             classifications.each do |ddc|
-              classification = Classification.where(:category => ddc).first
+              classification = Classification.find_by(category: ddc)
               unless classification
-                classification = Classification.new(:category => ddc)
+                classification = Classification.new(category: ddc)
                 classification.classification_type = classification_type
               end
-              manifestation.classifications << classification if classification.valid?
+              manifestation.classifications << classification
             end
           end
         end
@@ -186,7 +200,7 @@ module EnjuLoc
             series_title = title.split(';')[0].strip
           end
           if series_title
-            series_statement = SeriesStatement.where(:original_title => series_title).first || SeriesStatement.create!(original_title: series_title)
+            series_statement = SeriesStatement.find_by(original_title: series_title) || SeriesStatement.create!(original_title: series_title)
             if series_statement.try(:save)
               manifestation.series_statements << series_statement
             end
@@ -197,9 +211,9 @@ module EnjuLoc
       def create_loc_series_master(doc, manifestation)
         titles = get_mods_titles(doc)
         series_statement = SeriesStatement.new(
-          :original_title => titles[:original_title],
-          :title_alternative => titles[:title_alternative],
-          :series_master => true
+          original_title: titles[:original_title],
+          title_alternative: titles[:title_alternative],
+          series_master: true
         )
         if series_statement.try(:save)
           manifestation.series_statements << series_statement
@@ -222,315 +236,315 @@ module EnjuLoc
             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( ": " )
+            partname = [ partnumber, partname ].compact.join(": ")
             original_title << ". #{ partname }" unless partname.blank?
           end
         end
-        { :original_title => original_title, :title_alternative => title_alternatives.join( " ; " ) }
+        { original_title: original_title, title_alternative: title_alternatives.join(" ; ") }
       end
 
-    def get_mods_language(doc)
-      language = doc.at('//mods:language/mods:languageTerm[@authority="iso639-2b"]', NS).try(:content)
-    end
+      def get_mods_language(doc)
+        language = doc.at('//mods:language/mods:languageTerm[@authority="iso639-2b"]', NS).try(:content)
+      end
 
-    def get_mods_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)
+      def get_mods_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
-      access_address
-    end
 
-    def get_mods_publication_place(doc)
-      place = doc.at('//mods:originInfo/mods:place/mods:placeTerm[@type="text"]', NS).try(:content)
-    end
+      def get_mods_publication_place(doc)
+        place = doc.at('//mods:originInfo/mods:place/mods:placeTerm[@type="text"]', NS).try(:content)
+      end
 
-    def get_mods_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)
-        value[:extent] = page
-        if page =~ /(\d+)\s*(p|page)/
-          value[:start_page] = 1
-          value[:end_page] = $1.dup.to_i
-        end
-        height = extent[1].try(:strip)
-        value[:dimensions] = height
-        if height =~ /(\d+)\s*cm/
-          value[:height] = $1.dup.to_i
+      def get_mods_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)
+          value[:extent] = page
+          if page =~ /(\d+)\s*(p|page)/
+            value[:start_page] = 1
+            value[:end_page] = $1.dup.to_i
+          end
+          height = extent[1].try(:strip)
+          value[:dimensions] = height
+          if height =~ /(\d+)\s*cm/
+            value[:height] = $1.dup.to_i
+          end
         end
+        value
       end
-      value
-    end
 
-    def get_mods_statement_of_responsibility(doc)
-      note = doc.at('//mods:note[@type="statement of responsibility"]', NS).try(:content)
-      if note.blank?
-        note = get_mods_creators(doc).map{|e| e[:full_name] }.join( " ; " )
+      def get_mods_statement_of_responsibility(doc)
+        note = doc.at('//mods:note[@type="statement of responsibility"]', NS).try(:content)
+        if note.blank?
+          note = get_mods_creators(doc).map{|e| e[:full_name] }.join(" ; ")
+        end
+        note
       end
-      note
-    end
 
-    def get_mods_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" )
+      def get_mods_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
-    end
 
-    def get_mods_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
+      def get_mods_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
-      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_mods_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
+      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_mods_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.find_by(name: frequency_name)
+            end
+          end
         end
+        frequencies.compact.first
       end
-    end
-    frequencies.compact.first
-  end
 
-  def get_mods_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
+      def get_mods_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_mods_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 }
+      def get_mods_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
-      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_mods_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)
+      def get_mods_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
-    end
-    classifications.compact
-  end
 
-  def get_mods_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: 'online_resource').first
-        when "videorecording", "motion picture", "game"
-          content_type = ContentType.where(name: 'two_dimensional_moving_image').first
-        when "sound recording"
-          content_type = ContentType.where(name: 'performed_music').first
-        when "graphic", "picture"
-          content_type = ContentType.where(name: 'still_image').first
-        #TODO: Enju needs more specific mappings...
-        when "art original",
-        "microscope slides",
-        "art reproduction",
-        "model",
-        "chart",
-        "diorama",
-        "realia",
-        "filmstrip",
-        "slide",
-        "flash card",
-        "technical drawing",
-        "toy",
-        "kit",
-        "transparency",
-        "microform"
-          content_type = ContentType.where(name: 'other').first
-        end
-        when "marcsmd" # cf.http://www.loc.gov/standards/valuelist/marcsmd.html
-          case e.content
-          when "text", "large print", "regular print", "text in looseleaf binder"
-            carrier_type = CarrierType.where(name: 'volume').first
-            content_type = ContentType.where(name: 'text').first
-          when "braille"
-            carrier_type = CarrierType.where(name: 'volume').first
-            content_type = ContentType.where(name: 'tactile_text').first
-          when "videodisc"
-            carrier_type = CarrierType.where(name: 'videodisc').first
-            content_type = ContentType.where(name: 'two_dimensional_moving_image').first
-          when "videorecording", "videocartridge", "videocassette", "videoreel"
-            carrier_type = CarrierType.where(name: 'other').first
-            content_type = ContentType.where(name: 'two_dimensional_moving_image').first
-          when "electronic resource"
-            carrier_type = CarrierType.where(name: 'online_resource').first
-          when "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: 'other').first
-          when "motion picture", "film cartridge", "film cassette", "film reel"
-            content_type = ContentType.where(name: 'two_dimensional_moving_image').first
-          when "sound recording", "cylinder", "roll", "sound cartridge", "sound cassette","sound-tape reel", "sound-track film", "wire recording"
-            content_type = ContentType.where(name: 'performed_music').first
-          when "sound disc"
-            content_type = ContentType.where(name: 'performed_music').first
-            carrier_type = CarrierType.where(name: 'audio_disc').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: 'still_image').first
-          when "tactile material", "braille", "tactile, with no writing system"
-            content_type = ContentType.where(name: 'tactile_text').first
-          #TODO: Enju needs more specific mappings...
-          when "globe",
-          "celestial globe",
-          "earth moon globe",
-          "planetary or lunar globe",
-          "terrestrial globe",
-          "map",
-          "atlas",
-          "diagram",
-          "map",
-          "model",
-          "profile",
-          "remote-sensing image",
-          "section",
-          "view",
-          "microform",
-          "aperture card",
-          "microfiche",
-          "microfiche cassette",
-          "microfilm cartridge",
-          "microfilm cassette",
-          "microfilm reel",
-          "microopaque",
-          "combination",
-          "moon"
-            content_type = ContentType.where(name: 'other').first
-          end
-          when "marcform" # cf. http://www.loc.gov/standards/valuelist/marcform.html
+      def get_mods_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 "print", "large print"
-              carrier_type = CarrierType.where(name: 'volume').first
-              content_type = ContentType.where(name: 'text').first
-            when "electronic"
-              carrier_type = CarrierType.where(name: 'online_resource').first
-            when "braille"
-              content_type = ContentType.where(name: 'tactile_text').first
+            when "electronic resource"
+              carrier_type = CarrierType.find_by(name: 'online_resource')
+            when "videorecording", "motion picture", "game"
+              content_type = ContentType.find_by(name: 'two_dimensional_moving_image')
+            when "sound recording"
+              content_type = ContentType.find_by(name: 'performed_music')
+            when "graphic", "picture"
+              content_type = ContentType.find_by(name: 'still_image')
             #TODO: Enju needs more specific mappings...
-            when "microfiche", "microfilm"
+            when "art original",
+            "microscope slides",
+            "art reproduction",
+            "model",
+            "chart",
+            "diorama",
+            "realia",
+            "filmstrip",
+            "slide",
+            "flash card",
+            "technical drawing",
+            "toy",
+            "kit",
+            "transparency",
+            "microform"
+              content_type = ContentType.find_by(name: 'other')
+            end
+            when "marcsmd" # cf.http://www.loc.gov/standards/valuelist/marcsmd.html
+              case e.content
+              when "text", "large print", "regular print", "text in looseleaf binder"
+                carrier_type = CarrierType.find_by(name: 'volume')
+                content_type = ContentType.find_by(name: 'text')
+              when "braille"
+                carrier_type = CarrierType.where(name: 'volume').first
+                content_type = ContentType.where(name: 'tactile_text').first
+              when "videodisc"
+                carrier_type = CarrierType.where(name: 'videodisc').first
+                content_type = ContentType.where(name: 'two_dimensional_moving_image').first
+              when "videorecording", "videocartridge", "videocassette", "videoreel"
+                carrier_type = CarrierType.where(name: 'other').first
+                content_type = ContentType.where(name: 'two_dimensional_moving_image').first
+              when "electronic resource"
+                carrier_type = CarrierType.where(name: 'online_resource').first
+              when "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: 'other').first
+              when "motion picture", "film cartridge", "film cassette", "film reel"
+                content_type = ContentType.where(name: 'two_dimensional_moving_image').first
+              when "sound recording", "cylinder", "roll", "sound cartridge", "sound cassette", "sound-tape reel", "sound-track film", "wire recording"
+                content_type = ContentType.where(name: 'performed_music').first
+              when "sound disc"
+                content_type = ContentType.where(name: 'performed_music').first
+                carrier_type = CarrierType.where(name: 'audio_disc').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: 'still_image').first
+              when "tactile material", "braille", "tactile, with no writing system"
+                content_type = ContentType.where(name: 'tactile_text').first
+              #TODO: Enju needs more specific mappings...
+              when "globe",
+              "celestial globe",
+              "earth moon globe",
+              "planetary or lunar globe",
+              "terrestrial globe",
+              "map",
+              "atlas",
+              "diagram",
+              "map",
+              "model",
+              "profile",
+              "remote-sensing image",
+              "section",
+              "view",
+              "microform",
+              "aperture card",
+              "microfiche",
+              "microfiche cassette",
+              "microfilm cartridge",
+              "microfilm cassette",
+              "microfilm reel",
+              "microopaque",
+              "combination",
+              "moon"
+                content_type = ContentType.where(name: 'other').first
+              end
+              when "marcform" # cf. http://www.loc.gov/standards/valuelist/marcform.html
+                case e.content
+                when "print", "large print"
+                  carrier_type = CarrierType.where(name: 'volume').first
+                  content_type = ContentType.where(name: 'text').first
+                when "electronic"
+                  carrier_type = CarrierType.where(name: 'online_resource').first
+                when "braille"
+                  content_type = ContentType.where(name: 'tactile_text').first
+                #TODO: Enju needs more specific mappings...
+                when "microfiche", "microfilm"
+                  content_type = ContentType.where(name: 'other').first
+                end
+              end
+            end
+            doc.xpath('//mods:genre', NS).each do |e|
+              authority = e.attributes['authority'].try(:content)
+              case authority
+              when "rdacontent"
+                content_type = ContentType.where(name: e.content.gsub(/\W+/, "_")).first
+                content_type = ContentType.where(name: 'other').first unless content_type
+              end
+            end
+            type = doc.at('//mods:typeOfResource', NS).try(:content)
+            case type
+            when "text"
+              content_type = ContentType.where(name: 'text').first
+            when "sound recording"
+              content_type = ContentType.where(name: 'sounds').first
+            when"sound recording-musical"
+              content_type = ContentType.where(name: 'performed_music').first
+            when"sound recording-nonmusical"
+              content_type = ContentType.where(name: 'spoken_word').first
+            when "moving image"
+              content_type = ContentType.where(name: 'two_dimensional_moving_image').first
+            when "software, multimedia"
+              content_type = ContentType.where(name: 'other').first
+            when "cartographic "
+              content_type = ContentType.where(name: 'cartographic_image').first
+            when "notated music"
+              content_type = ContentType.where(name: 'notated_music').first
+            when "still image"
+              content_type = ContentType.where(name: 'still_image').first
+            when "three dimensional object"
+              content_type = ContentType.where(name: 'other').first
+            when "mixed material"
               content_type = ContentType.where(name: 'other').first
             end
+            { carrier_type: carrier_type, content_type: content_type }
           end
-        end
-        doc.xpath('//mods:genre', NS).each do |e|
-          authority = e.attributes['authority'].try(:content)
-          case authority
-          when "rdacontent"
-            content_type = ContentType.where(name: e.content.gsub(/\W+/, "_")).first
-            content_type = ContentType.where(name: 'other').first unless content_type
-          end
-        end
-        type = doc.at('//mods:typeOfResource', NS).try(:content)
-        case type
-        when "text"
-          content_type = ContentType.where(name: 'text').first
-        when "sound recording"
-          content_type = ContentType.where(name: 'sounds').first
-        when"sound recording-musical"
-          content_type = ContentType.where(name: 'performed_music').first
-        when"sound recording-nonmusical"
-          content_type = ContentType.where(name: 'spoken_word').first
-        when "moving image"
-          content_type = ContentType.where(name: 'two_dimensional_moving_image').first
-        when "software, multimedia"
-          content_type = ContentType.where(name: 'other').first
-        when "cartographic "
-          content_type = ContentType.where(name: 'cartographic_image').first
-        when "notated music"
-          content_type = ContentType.where(name: 'notated_music').first
-        when "still image"
-          content_type = ContentType.where(name: 'still_image').first
-        when "three dimensional object"
-          content_type = ContentType.where(name: 'other').first
-        when "mixed material"
-          content_type = ContentType.where(name: 'other').first
-        end
-        { :carrier_type => carrier_type, :content_type => content_type }
-      end
     end
   end
 end