fedora-migrate 0.3.0 → 0.4.0

data/lib/fedora_migrate/rights_metadata.rb

@@ -2,64 +2,64 @@ require 'active_support/core_ext/string'
 
 module FedoraMigrate
   # Implements Hydra RightsMetadata XML terminology for asserting access permissions
-  class RightsMetadata < ActiveFedora::OmDatastream       
+  class RightsMetadata < ActiveFedora::OmDatastream
     extend Deprecation
-    
+
     set_terminology do |t|
-      t.root(:path=>"rightsMetadata", :xmlns=>"http://hydra-collab.stanford.edu/schemas/rightsMetadata/v1", :schema=>"http://github.com/projecthydra/schemas/tree/v1/rightsMetadata.xsd") 
-      t.copyright {
+      t.root(path: "rightsMetadata", xmlns: "http://hydra-collab.stanford.edu/schemas/rightsMetadata/v1", schema: "http://github.com/projecthydra/schemas/tree/v1/rightsMetadata.xsd")
+      t.copyright do
         ## BEGIN possible delete, justin 2012-06-22
-        t.machine {
-          t.cclicense   
-          t.license     
-        }
-        t.human_readable(:path=>"human")
-        t.license(:proxy=>[:machine, :license ])            
-        t.cclicense(:proxy=>[:machine, :cclicense ])                  
+        t.machine do
+          t.cclicense
+          t.license
+        end
+        t.human_readable(path: "human")
+        t.license(proxy: [:machine, :license])
+        t.cclicense(proxy: [:machine, :cclicense])
         ## END possible delete
 
-        t.title(:path=>'human', :attributes=>{:type=>'title'})
-        t.description(:path=>'human', :attributes=>{:type=>'description'})
-        t.url(:path=>'machine', :attributes=>{:type=>'uri'})
-      }
+        t.title(path: 'human', attributes: { type: 'title' })
+        t.description(path: 'human', attributes: { type: 'description' })
+        t.url(path: 'machine', attributes: { type: 'uri' })
+      end
       t.access do
-        t.human_readable(:path=>"human")
-        t.machine {
+        t.human_readable(path: "human")
+        t.machine do
           t.group
           t.person
-        }
-        t.person(:proxy=>[:machine, :person])
-        t.group(:proxy=>[:machine, :group])
+        end
+        t.person(proxy: [:machine, :person])
+        t.group(proxy: [:machine, :group])
         # accessor :access_person, :term=>[:access, :machine, :person]
       end
-      t.discover_access(:ref=>[:access], :attributes=>{:type=>"discover"})
-      t.read_access(:ref=>[:access], :attributes=>{:type=>"read"})
-      t.edit_access(:ref=>[:access], :attributes=>{:type=>"edit"})
+      t.discover_access(ref: [:access], attributes: { type: "discover" })
+      t.read_access(ref: [:access], attributes: { type: "read" })
+      t.edit_access(ref: [:access], attributes: { type: "edit" })
       # A bug in OM prevnts us from declaring proxy terms at the root of a Terminology
       # t.access_person(:proxy=>[:access,:machine,:person])
       # t.access_group(:proxy=>[:access,:machine,:group])
-      
-      t.embargo {
+
+      t.embargo do
         t.human_readable(path: "human")
-        t.machine{
-          t.date(type: :time, attributes: {type: "release"})
+        t.machine do
+          t.date(type: :time, attributes: { type: "release" })
           t.date_deactivated(type: "deactivated")
-          t.visibility_during(path: "visibility", attributes: {scope: 'during'})
-          t.visibility_after(path: "visibility", attributes: {scope: 'after'})
-        }
-      }
+          t.visibility_during(path: "visibility", attributes: { scope: 'during' })
+          t.visibility_after(path: "visibility", attributes: { scope: 'after' })
+        end
+      end
 
-      t.lease {
+      t.lease do
         t.human_readable(path: "human")
-        t.machine{
-          t.date(type: :time, attributes: {type: "expire"})
-          t.date_deactivated(type: :time, attributes: {type: "deactivated"})
-          t.visibility_during(path: "visibility", attributes: {scope: 'during'})
-          t.visibility_after(path: "visibility", attributes: {scope: 'after'})
-        }
-      }
+        t.machine do
+          t.date(type: :time, attributes: { type: "expire" })
+          t.date_deactivated(type: :time, attributes: { type: "deactivated" })
+          t.visibility_during(path: "visibility", attributes: { scope: 'during' })
+          t.visibility_after(path: "visibility", attributes: { scope: 'after' })
+        end
+      end
 
-      t.license(:ref=>[:copyright])
+      t.license(ref: [:copyright])
 
       t.visibility_during_embargo proxy: [:embargo, :machine, :visibility_during]
       t.visibility_after_embargo proxy: [:embargo, :machine, :visibility_after]
@@ -71,62 +71,60 @@ module FedoraMigrate
       t.embargo_deactivation_date proxy: [:embargo, :machine, :date_deactivated]
       t.lease_expiration_date proxy: [:lease, :machine, :date], type: :time
       t.lease_deactivation_date proxy: [:lease, :machine, :date_deactivated]
-
     end
 
     # Generates an empty Mods Article (used when you call ModsArticle.new without passing in existing xml)
     def self.xml_template
       builder = Nokogiri::XML::Builder.new do |xml|
-        xml.rightsMetadata(:version=>"0.1", "xmlns"=>"http://hydra-collab.stanford.edu/schemas/rightsMetadata/v1") {
-          xml.copyright {
-            xml.human(:type=>'title')
-            xml.human(:type=>'description')
-            xml.machine(:type=>'uri')
-            
-          }
-          xml.access(:type=>"discover") {
+        xml.rightsMetadata(:version => "0.1", "xmlns" => "http://hydra-collab.stanford.edu/schemas/rightsMetadata/v1") do
+          xml.copyright do
+            xml.human(type: 'title')
+            xml.human(type: 'description')
+            xml.machine(type: 'uri')
+          end
+          xml.access(type: "discover") do
             xml.human
             xml.machine
-          }
-          xml.access(:type=>"read") {
-            xml.human 
+          end
+          xml.access(type: "read") do
+            xml.human
             xml.machine
-          }
-          xml.access(:type=>"edit") {
+          end
+          xml.access(type: "edit") do
             xml.human
             xml.machine
-          }
-          xml.embargo{
+          end
+          xml.embargo do
             xml.machine
-          }
-          xml.lease{
+          end
+          xml.lease do
             xml.machine
-          }
-        }
+          end
+        end
       end
-      return builder.doc
+      builder.doc
     end
-      
+
     # Returns the permissions for the selected person/group
-    # If new_access_level is provided, updates the selected person/group access_level to the one specified 
+    # If new_access_level is provided, updates the selected person/group access_level to the one specified
     # A new_access_level of "none" will remove all access_levels for the selected person/group
     # @param [Hash] selector hash in format {type => identifier}
     # @param new_access_level (default nil)
-    # @return Hash in format {type => access_level}.  
-    # 
-    # ie. 
+    # @return Hash in format {type => access_level}.
+    #
+    # ie.
     # permissions({:person=>"person123"})
     # => {"person123"=>"edit"}
     # permissions({:person=>"person123"}, "read")
     # => {"person123"=>"read"}
     # permissions({:person=>"person123"})
     # => {"person123"=>"read"}
-    def permissions(selector, new_access_level=nil)
+    def permissions(selector, new_access_level = nil)
       type = selector.keys.first.to_sym
       actor = selector.values.first
       if new_access_level.nil?
         xpath = xpath(type, actor)
-        nodeset = self.find_by_terms(xpath)
+        nodeset = find_by_terms(xpath)
         if nodeset.empty?
           return "none"
         else
@@ -134,24 +132,23 @@ module FedoraMigrate
         end
       else
         remove_all_permissions(selector)
-        if new_access_level == "none" 
-          self.content = self.to_xml
+        if new_access_level == "none"
+          self.content = to_xml
         else
           access_type_symbol = "#{new_access_level}_access".to_sym
           current_values = term_values(access_type_symbol, type)
-          self.update_values([access_type_symbol, type] => current_values + [actor] )
+          update_values([access_type_symbol, type] => current_values + [actor])
         end
         return new_access_level
       end
-        
     end
-    
+
     # Reports on which groups have which permissions
     # @return Hash in format {group_name => group_permissions, group_name => group_permissions}
     def groups
-      return quick_search_by_type(:group)
+      quick_search_by_type(:group)
     end
-    
+
     def individuals
       Deprecation.warn(RightsMetadata, "The method `individuals' is deprecated and will be removed from Hydra::Datastream::RightsMetadata in hydra-head 8.0.  Use `users' instead.", caller)
       users
@@ -160,42 +157,42 @@ module FedoraMigrate
     # Reports on which users have which permissions
     # @return Hash in format {user_name => user_permissions, user_name => user_permissions}
     def users
-      return quick_search_by_type(:person)
+      quick_search_by_type(:person)
     end
-    
+
     # Updates permissions for all of the persons and groups in a hash
     # @param params ex. {"group"=>{"group1"=>"discover","group2"=>"edit"}, "person"=>{"person1"=>"read","person2"=>"discover"}}
     # Currently restricts actor type to group or person.  Any others will be ignored
     def update_permissions(params)
-      params.fetch("group", {}).each_pair {|group_id, access_level| self.permissions({"group"=>group_id}, access_level)}
-      params.fetch("person", {}).each_pair {|person_id, access_level| self.permissions({"person"=>person_id}, access_level)}
+      params.fetch("group", {}).each_pair { |group_id, access_level| permissions({ "group" => group_id }, access_level) }
+      params.fetch("person", {}).each_pair { |person_id, access_level| permissions({ "person" => person_id }, access_level) }
     end
 
     # Updates all permissions
     # @param params ex. {"group"=>{"group1"=>"discover","group2"=>"edit"}, "person"=>{"person1"=>"read","person2"=>"discover"}}
     # Restricts actor type to group or person.  Any others will be ignored
-    def permissions= (params)
+    def permissions=(params)
       groups_for_update = params['group'] ? params['group'].keys : []
       group_ids = groups.keys | groups_for_update
-      group_ids.each {|group_id| self.permissions({"group"=>group_id}, params['group'].fetch(group_id, 'none'))}
+      group_ids.each { |group_id| permissions({ "group" => group_id }, params['group'].fetch(group_id, 'none')) }
       users_for_update = params['person'] ? params['person'].keys : []
       user_ids = users.keys | users_for_update
-      user_ids.each {|person_id| self.permissions({"person"=>person_id}, params['person'].fetch(person_id, 'none'))}
+      user_ids.each { |person_id| permissions({ "person" => person_id }, params['person'].fetch(person_id, 'none')) }
     end
-    
+
     # @param [Symbol] type (either :group or :person)
-    # @return 
+    # @return
     # This method limits the response to known access levels.  Probably runs a bit faster than .permissions().
     def quick_search_by_type(type)
       result = {}
-      [{:discover_access=>"discover"},{:read_access=>"read"},{:edit_access=>"edit"}].each do |access_levels_hash|
+      [{ discover_access: "discover" }, { read_access: "read" }, { edit_access: "edit" }].each do |access_levels_hash|
         access_level = access_levels_hash.keys.first
         access_level_name = access_levels_hash.values.first
-        self.find_by_terms(*[access_level, type]).each do |entry|
+        find_by_terms(*[access_level, type]).each do |entry|
           result[entry.text] = access_level_name
         end
       end
-      return result
+      result
     end
 
     def under_embargo?
@@ -206,7 +203,7 @@ module FedoraMigrate
       lease_expiration_date.present? && Date.today < lease_expiration_date.first
     end
 
-    def to_solr(solr_doc=Hash.new)
+    def to_solr(solr_doc = {})
       [:discover, :read, :edit].each do |access|
         vals = send("#{access}_access").machine.group
         solr_doc[Hydra.config.permissions[access].group] = vals unless vals.empty?
@@ -214,11 +211,11 @@ module FedoraMigrate
         solr_doc[Hydra.config.permissions[access].individual] = vals unless vals.empty?
       end
       if embargo_release_date.present?
-        key = Hydra.config.permissions.embargo.release_date.sub(/_[^_]+$/, '') #Strip off the suffix
+        key = Hydra.config.permissions.embargo.release_date.sub(/_[^_]+$/, '') # Strip off the suffix
         ::Solrizer.insert_field(solr_doc, key, embargo_release_date, :stored_sortable)
       end
       if lease_expiration_date.present?
-        key = Hydra.config.permissions.lease.expiration_date.sub(/_[^_]+$/, '') #Strip off the suffix
+        key = Hydra.config.permissions.lease.expiration_date.sub(/_[^_]+$/, '') # Strip off the suffix
         ::Solrizer.insert_field(solr_doc, key, lease_expiration_date, :stored_sortable)
       end
       solr_doc[::Solrizer.solr_name("visibility_during_embargo", :symbol)] = visibility_during_embargo unless visibility_during_embargo.nil?
@@ -248,34 +245,32 @@ module FedoraMigrate
 
     # Completely clear the permissions
     def clear_permissions!
-      remove_all_permissions({:person=>true})
-      remove_all_permissions({:group=>true})
+      remove_all_permissions(person: true)
+      remove_all_permissions(group: true)
     end
 
-
-    
     private
-    # Purge all access given group/person 
-    def remove_all_permissions(selector)
-      return unless ng_xml
-      type = selector.keys.first.to_sym
-      actor = selector.values.first
-      xpath = xpath(type, actor)
-      nodes_to_purge = self.find_by_terms(xpath)
-      nodes_to_purge.each {|node| node.remove}
-    end
 
-    # @param [Symbol] type (:group, :person)
-    # @param [String,TrueClass] actor the user we want to find. If actor is true, then don't query.
-    def xpath(type, actor)
-      raise ArgumentError, "Type must either be ':group' or ':person'. You provided: '#{type.inspect}'" unless [:group, :person].include?(type)
-      path = "//oxns:access/oxns:machine/oxns:#{type}"
-      if actor.is_a? String
-        clean_actor = actor.gsub("'", '')
-        path += "[text() = '#{clean_actor}']" 
+      # Purge all access given group/person
+      def remove_all_permissions(selector)
+        return unless ng_xml
+        type = selector.keys.first.to_sym
+        actor = selector.values.first
+        xpath = xpath(type, actor)
+        nodes_to_purge = find_by_terms(xpath)
+        nodes_to_purge.each(&:remove)
+      end
+
+      # @param [Symbol] type (:group, :person)
+      # @param [String,TrueClass] actor the user we want to find. If actor is true, then don't query.
+      def xpath(type, actor)
+        raise ArgumentError, "Type must either be ':group' or ':person'. You provided: '#{type.inspect}'" unless [:group, :person].include?(type)
+        path = "//oxns:access/oxns:machine/oxns:#{type}"
+        if actor.is_a? String
+          clean_actor = actor.delete("'")
+          path += "[text() = '#{clean_actor}']"
+        end
+        path
       end
-      path
-    end
-    
   end
 end

data/lib/fedora_migrate/rubydora_connection.rb

@@ -1,18 +1,17 @@
 module FedoraMigrate
   class RubydoraConnection
-    
     attr_accessor :options, :connection
 
-    def initialize(params={})
+    def initialize(params = {})
       params = params.dup
       self.options = params
       connect
     end
 
-    def connect(force=false)
-      return unless @connection.nil? or force
+    def connect(force = false)
+      return unless @connection.nil? || force
       allowable_options = [:url, :user, :password, :timeout, :open_timeout, :ssl_client_cert, :ssl_client_key, :validateChecksum]
-      client_options = options.reject { |k,v| not allowable_options.include?(k) }
+      client_options = options.reject { |k, _v| !allowable_options.include?(k) }
       @connection = Rubydora.connect client_options
     end
   end

data/lib/fedora_migrate/target_constructor.rb

@@ -1,38 +1,35 @@
 module FedoraMigrate
   class TargetConstructor
+    attr_accessor :source, :candidates, :target
 
-    attr_accessor :candidates, :target
-
-    def initialize candidates
-      @candidates = candidates
+    def initialize(source)
+      @source = source
     end
 
     def build
-      determine_target
-      return self
+      raise FedoraMigrate::Errors::MigrationError, "No qualified targets found in #{source.pid}" if target.nil?
+      target.new(id: FedoraMigrate::Mover.id_component(source))
+    end
+
+    def target
+      @target ||= determine_target
     end
 
     private
 
-    def determine_target
-      case
-        when @candidates.kind_of?(Array) then vote
-        when @candidates.kind_of?(String) then vet(@candidates)
+      def determine_target
+        Array(candidates).map { |model| vet(model) }.compact.first
       end
-    end
 
-    def vote
-      candidates.each do |model|
-        vet(model)
-        return unless @target.nil?
+      def vet(model)
+        FedoraMigrate::Mover.id_component(model).constantize
+      rescue NameError
+        Logger.debug "rejecting #{model} for target"
+        nil
       end
-    end
-
-    def vet model
-      @target = FedoraMigrate::Mover.id_component(model).constantize
-    rescue NameError
-      Logger.debug "rejecting #{model} for target"
-    end
 
+      def candidates
+        @candidates ||= source.models
+      end
   end
 end

data/lib/fedora_migrate/version.rb

@@ -1,3 +1,3 @@
 module FedoraMigrate
-  VERSION = "0.3.0"
+  VERSION = "0.4.0".freeze
 end

data/spec/integration/content_versions_spec.rb

@@ -1,19 +1,18 @@
 require 'spec_helper'
 
-describe "Versioned content" do
-
+describe FedoraMigrate::DatastreamMover do
   let(:mover) do
-    FedoraMigrate::DatastreamMover.new(
-      FedoraMigrate.source.connection.find("sufia:rb68xc089").datastreams["content"], 
+    described_class.new(
+      FedoraMigrate.source.connection.find("sufia:rb68xc089").datastreams["content"],
       ExampleModel::VersionedContent.create.attached_files["content"]
     )
   end
 
   let(:application_mover) do
-    FedoraMigrate::DatastreamMover.new(
-      FedoraMigrate.source.connection.find("sufia:rb68xc089").datastreams["content"], 
+    described_class.new(
+      FedoraMigrate.source.connection.find("sufia:rb68xc089").datastreams["content"],
       ExampleModel::VersionedContent.create.attached_files["content"],
-      { application_creates_versions: true }
+      application_creates_versions: true
     )
   end
 
@@ -28,10 +27,10 @@ describe "Versioned content" do
       mover.migrate
       mover.target
     end
-    it "should migrate all versions" do
+    it "migrates all versions" do
       expect(subject.versions.all.count).to eql 3
     end
-    it "should preserve metadata" do
+    it "preserves metadata" do
       expect(subject.mime_type).to eql "image/png"
       expect(subject.original_name).to eql "world.png"
     end
@@ -44,7 +43,7 @@ describe "Versioned content" do
         expect(subject.versions.count).to eql 0
       end
     end
-  end 
+  end
 
   context "without migrating versions" do
     subject do
@@ -52,14 +51,13 @@ describe "Versioned content" do
       mover.migrate
       mover.target
     end
-    it "should migrate only the most recent version" do
+    it "migrates only the most recent version" do
       expect(subject.versions.count).to eql 0
-      expect(subject.content).to_not be_nil
+      expect(subject.content).not_to be_nil
     end
-    it "should preserve metadata" do
+    it "preserves metadata" do
       expect(subject.mime_type).to eql "image/png"
       expect(subject.original_name).to eql "world.png"
     end
   end
-
 end