valkyrie 2.1.0 → 3.0.0.pre.beta.1

data/Rakefile

@@ -6,7 +6,6 @@ require 'config/database_connection'
 require 'active_record'
 require 'rubocop/rake_task'
 load 'tasks/dev.rake'
-load 'tasks/docker.rake'
 
 RSpec::Core::RakeTask.new(:spec)
 
@@ -33,12 +32,21 @@ namespace :db do
   task configure_connection: :configuration do
     DatabaseConnection.connect!(DATABASE_ENV)
     ActiveRecord::Base.logger = Logger.new STDOUT if @config['logger']
+    @config = if ::ActiveRecord::Base.configurations.respond_to?(:configs_for)
+                ::ActiveRecord::Base.configurations.configs_for(env_name: DATABASE_ENV.to_s)[0]
+              else
+                ::ActiveRecord::Base.configurations[DATABASE_ENV.to_s]
+              end
   end
 
   desc 'Create the database from db/config.yml for the current DATABASE_ENV'
   task create: :configure_connection do
-    database = ActiveRecord::Tasks::PostgreSQLDatabaseTasks.new(@config)
-    database.create
+    begin
+      database = ActiveRecord::Tasks::PostgreSQLDatabaseTasks.new(@config)
+      database.create
+    rescue
+      puts "Database already exists."
+    end
     puts "Database created"
   end
 
@@ -51,25 +59,23 @@ namespace :db do
 
   desc 'Migrate the database (options: VERSION=x, VERBOSE=false).'
   task migrate: :configure_connection do
-    begin
-      verbose = ENV["VERBOSE"] ? ENV["VERBOSE"] == "true" : true
-      version = ENV["VERSION"] ? ENV["VERSION"].to_i : nil
-      scope   = ENV['SCOPE']
-      verbose_was = ActiveRecord::Migration.verbose
-      ActiveRecord::Migration.verbose = verbose
-      if ActiveRecord::Migrator.respond_to?(:migrate)
-        ActiveRecord::Migrator.migrate(MIGRATIONS_DIR, version) do |migration|
-          scope.blank? || scope == migration.scope
-        end
-      else
-        ActiveRecord::Base.connection.migration_context.migrate(version) do |migration|
-          scope.blank? || scope == migration.scope
-        end
+    verbose = ENV["VERBOSE"] ? ENV["VERBOSE"] == "true" : true
+    version = ENV["VERSION"] ? ENV["VERSION"].to_i : nil
+    scope   = ENV['SCOPE']
+    verbose_was = ActiveRecord::Migration.verbose
+    ActiveRecord::Migration.verbose = verbose
+    if ActiveRecord::Migrator.respond_to?(:migrate)
+      ActiveRecord::Migrator.migrate(MIGRATIONS_DIR, version) do |migration|
+        scope.blank? || scope == migration.scope
+      end
+    else
+      ActiveRecord::Base.connection.migration_context.migrate(version) do |migration|
+        scope.blank? || scope == migration.scope
       end
-      ActiveRecord::Base.clear_cache!
-    ensure
-      ActiveRecord::Migration.verbose = verbose_was
     end
+    ActiveRecord::Base.clear_cache!
+  ensure
+    ActiveRecord::Migration.verbose = verbose_was
   end
 
   namespace :schema do

data/db/config.yml

@@ -1,4 +1,3 @@
-<% local = File.exist?('/tmp/.s.PGSQL.5432') && File.stat('/tmp/.s.PGSQL.5432').socket? %>
 default: &default
   adapter: postgresql
   encoding: utf8
@@ -6,22 +5,16 @@ default: &default
   pool: <%= Integer(ENV.fetch("DB_POOL", 5)) %>
   reaping_frequency: <%= Integer(ENV.fetch("DB_REAPING_FREQUENCY", 10)) %>
   timeout: 5000
-  <% unless local %>
   host: localhost
-  username: docker
-  password: d0ck3r
-  <% end %>
+  username: postgres
+  password: 
 
 development:
   <<: *default
   database: Valkyrie_gem_development
-  <% unless local %>
   port: 5433
-  <% end %>
 
 test:
   <<: *default
   database: Valkyrie_gem_test
-  <% unless local %>
-  port: 5434
-  <% end %>
+  port: <%= ENV["POSTGRES_PORT"] || 5433 %>

data/lib/generators/valkyrie/resource_generator.rb

@@ -21,7 +21,7 @@ class Valkyrie::ResourceGenerator < Rails::Generators::NamedBase
 
   private
 
-    def rspec_installed?
-      defined?(RSpec) && defined?(RSpec::Rails)
-    end
+  def rspec_installed?
+    defined?(RSpec) && defined?(RSpec::Rails)
+  end
 end

data/lib/valkyrie/change_set.rb

@@ -104,8 +104,8 @@ module Valkyrie
 
     private
 
-      def field(field_name)
-        self.class.definitions.fetch(field_name.to_s)
-      end
+    def field(field_name)
+      self.class.definitions.fetch(field_name.to_s)
+    end
   end
 end

data/lib/valkyrie/id.rb

@@ -10,36 +10,29 @@ module Valkyrie
       @id = id.to_s
     end
 
+    ##
+    # @return [String]
     def to_s
+      to_str
+    end
+
+    ##
+    # @return [String]
+    def to_str
       id
     end
 
     delegate :hash, to: :state
 
     def eql?(other)
-      return (default_equality(other) || string_equality(other)) if Valkyrie.config.id_string_equality == true
-      default_equality(other)
+      other == to_str
     end
     alias == eql?
 
     protected
 
-      def default_equality(other)
-        output = (other.class == self.class && other.state == state)
-        return output if output == true
-        if output == false && string_equality(other) && Valkyrie.config.id_string_equality.nil?
-          warn "[DEPRECATION] Valkyrie::IDs will always be equal to their string counterparts in 3.0.0. " \
-            "To silence this message, please either compare IDs or set Valkyrie.config.id_string_equality = true."
-        end
-        false
-      end
-
-      def string_equality(other)
-        other.to_s == to_s
-      end
-
-      def state
-        [@id]
-      end
+    def state
+      [@id]
+    end
   end
 end

data/lib/valkyrie/indexers/access_controls_indexer.rb

@@ -40,24 +40,24 @@ module Valkyrie::Indexers
 
     private
 
-      # rubocop:disable Metrics/MethodLength
-      def default_config
-        if defined?(Hydra) && Hydra.respond_to?(:config)
-          {
-            read_groups: Hydra.config[:permissions][:read].group,
-            read_users: Hydra.config[:permissions][:read].individual,
-            edit_groups: Hydra.config[:permissions][:edit].group,
-            edit_users: Hydra.config[:permissions][:edit].individual
-          }
-        else
-          {
-            read_groups: 'read_access_group_ssim',
-            read_users: 'read_access_person_ssim',
-            edit_groups: 'edit_access_group_ssim',
-            edit_users: 'edit_access_person_ssim'
-          }
-        end
+    # rubocop:disable Metrics/MethodLength
+    def default_config
+      if defined?(Hydra) && Hydra.respond_to?(:config)
+        {
+          read_groups: Hydra.config[:permissions][:read].group,
+          read_users: Hydra.config[:permissions][:read].individual,
+          edit_groups: Hydra.config[:permissions][:edit].group,
+          edit_users: Hydra.config[:permissions][:edit].individual
+        }
+      else
+        {
+          read_groups: 'read_access_group_ssim',
+          read_users: 'read_access_person_ssim',
+          edit_groups: 'edit_access_group_ssim',
+          edit_users: 'edit_access_person_ssim'
+        }
       end
+    end
     # rubocop:enable Metrics/MethodLength
   end
 end

data/lib/valkyrie/persistence/buffered_persister.rb

@@ -24,8 +24,8 @@ module Valkyrie::Persistence
       @buffer_class = buffer_class
     end
 
-    def save(resource:)
-      persister.save(resource: resource)
+    def save(resource:, external_resource: false)
+      persister.save(resource: resource, external_resource: external_resource)
     end
 
     def save_all(resources:)

data/lib/valkyrie/persistence/composite_persister.rb

@@ -24,14 +24,14 @@ module Valkyrie::Persistence
     end
 
     # (see Valkyrie::Persistence::Memory::Persister#save)
-    def save(resource:)
+    def save(resource:, external_resource: false)
       # Assume the first persister is the canonical data store; that's the optlock we want
       first, *rest = *persisters
-      cached_resource = first.save(resource: resource)
+      cached_resource = first.save(resource: resource, external_resource: external_resource)
       # Don't pass opt lock tokens to other persisters
       internal_resource = cached_resource.dup
       internal_resource.clear_optimistic_lock_token!
-      rest.inject(internal_resource) { |m, persister| persister.save(resource: m) }
+      rest.inject(internal_resource) { |m, persister| persister.save(resource: m, external_resource: true) }
       # return the one with the desired opt lock token
       cached_resource
     end

data/lib/valkyrie/persistence/custom_query_container.rb

@@ -39,25 +39,17 @@ module Valkyrie::Persistence
     attr_reader :query_service, :query_handlers
     def initialize(query_service:)
       @query_service = query_service
-      @query_handlers = []
+      @query_handlers = {}
     end
 
     def register_query_handler(query_handler)
-      @query_handlers << query_handler
-    end
-
-    def method_missing(meth_name, *args, &block)
-      query_handler = find_query_handler(meth_name).new(query_service: query_service)
-      return super unless query_handler
-      query_handler.__send__(meth_name, *args, &block)
-    end
-
-    def find_query_handler(method)
-      query_handlers.find { |x| x.queries.include?(method) }
-    end
-
-    def respond_to_missing?(meth_name, _args)
-      find_query_handler(meth_name).present?
+      query_handler.queries.each do |query|
+        handler = query_handler.new(query_service: query_service)
+        query_handlers[query.to_sym] = handler
+        define_singleton_method query do |*args, &block|
+          query_handlers[query.to_sym].__send__(query, *args, &block)
+        end
+      end
     end
   end
 end

data/lib/valkyrie/persistence/fedora/list_node.rb

@@ -85,60 +85,60 @@ module Valkyrie::Persistence::Fedora
 
     private
 
-      attr_reader :next_uri, :prev_uri, :node_cache
+    attr_reader :next_uri, :prev_uri, :node_cache
 
-      # Class used to populate the RDF graph structure for the linked lists
-      class Builder
-        attr_reader :uri, :graph
+    # Class used to populate the RDF graph structure for the linked lists
+    class Builder
+      attr_reader :uri, :graph
 
-        # @param uri [RDF::URI] the URI for the linked list in the graph store
-        # @param graph [RDF::Repository] the RDF graph to be populated
-        def initialize(uri, graph)
-          @uri = uri
-          @graph = graph
-        end
+      # @param uri [RDF::URI] the URI for the linked list in the graph store
+      # @param graph [RDF::Repository] the RDF graph to be populated
+      def initialize(uri, graph)
+        @uri = uri
+        @graph = graph
+      end
 
-        # Populates attributes for the LinkedNode
-        # @param instance [ListNode]
-        def populate(instance)
-          instance.proxy_for = resource.proxy_for
-          instance.proxy_in = resource.proxy_in
-          instance.next_uri = resource.next
-          instance.prev_uri = resource.prev
-        end
+      # Populates attributes for the LinkedNode
+      # @param instance [ListNode]
+      def populate(instance)
+        instance.proxy_for = resource.proxy_for
+        instance.proxy_in = resource.proxy_in
+        instance.next_uri = resource.next
+        instance.prev_uri = resource.prev
+      end
 
-        private
+      private
 
-          # Constructs a set of triples using ActiveTriples as objects
-          # @return [Valkyrie::Persistence::Fedora::ListNode::Resource]
-          def resource
-            @resource ||= Resource.new(uri, graph: graph)
-          end
+      # Constructs a set of triples using ActiveTriples as objects
+      # @return [Valkyrie::Persistence::Fedora::ListNode::Resource]
+      def resource
+        @resource ||= Resource.new(uri, graph: graph)
       end
+    end
 
-      # Class for providing a set of triples modeling linked list nodes
-      class Resource
-        def self.property(property, predicate:)
-          define_method property do
-            graph.query([uri, predicate, nil]).objects.first
-          end
+    # Class for providing a set of triples modeling linked list nodes
+    class Resource
+      def self.property(property, predicate:)
+        define_method property do
+          graph.query([uri, predicate, nil]).objects.first
+        end
 
-          define_method "#{property}=" do |val|
-            return if val.nil?
-            graph << [uri, predicate, val]
-          end
+        define_method "#{property}=" do |val|
+          return if val.nil?
+          graph << [uri, predicate, val]
         end
+      end
 
-        property :proxy_for, predicate: ::RDF::Vocab::ORE.proxyFor
-        property :proxy_in, predicate: ::RDF::Vocab::ORE.proxyIn
-        property :next, predicate: ::RDF::Vocab::IANA.next
-        property :prev, predicate: ::RDF::Vocab::IANA.prev
+      property :proxy_for, predicate: ::RDF::Vocab::ORE.proxyFor
+      property :proxy_in, predicate: ::RDF::Vocab::ORE.proxyIn
+      property :next, predicate: ::RDF::Vocab::IANA.next
+      property :prev, predicate: ::RDF::Vocab::IANA.prev
 
-        attr_reader :graph, :uri
-        def initialize(uri, graph: RDF::Graph.new)
-          @uri = uri
-          @graph = graph
-        end
+      attr_reader :graph, :uri
+      def initialize(uri, graph: RDF::Graph.new)
+        @uri = uri
+        @graph = graph
       end
+    end
   end
 end

data/lib/valkyrie/persistence/fedora/metadata_adapter.rb

@@ -58,7 +58,7 @@ module Valkyrie::Persistence::Fedora
     # @param [RDF::URI] id the Valkyrie ID
     # @return [RDF::URI]
     def id_to_uri(id)
-      prefix = fedora_version == 5 ? "" : "#{pair_path(id)}/"
+      prefix = [5, 6].include?(fedora_version) ? "" : "#{pair_path(id)}/"
       RDF::URI("#{connection_prefix}/#{prefix}#{CGI.escape(id.to_s)}")
     end
 
@@ -71,6 +71,10 @@ module Valkyrie::Persistence::Fedora
       id.to_s.split(/[-\/]/).first.split("").each_slice(2).map(&:join).join("/")
     end
 
+    def url_prefix
+      connection.http.url_prefix
+    end
+
     # Generate the prefix used in HTTP requests to the Fedora RESTful endpoint
     # @return [String]
     def connection_prefix

data/lib/valkyrie/persistence/fedora/ordered_list.rb

@@ -67,111 +67,111 @@ module Valkyrie::Persistence::Fedora
 
     private
 
-      attr_reader :node_cache
-
-      # Append a node to a linked list
-      # @param source [ListNode] the node being appended
-      # @param append_node [ListNode] the node already in the existing list
-      def append_to(source, append_node)
-        source.prev = append_node
-        append_node.next.prev = source
-        source.next = append_node.next
-        append_node.next = source
-        @changed = true
-      end
+    attr_reader :node_cache
+
+    # Append a node to a linked list
+    # @param source [ListNode] the node being appended
+    # @param append_node [ListNode] the node already in the existing list
+    def append_to(source, append_node)
+      source.prev = append_node
+      append_node.next.prev = source
+      source.next = append_node.next
+      append_node.next = source
+      @changed = true
+    end
 
-      # Constructs a new OrderedReader for this OrderedList
-      # @return [OrderedReader]
-      def ordered_reader
-        OrderedReader.new(self)
-      end
+    # Constructs a new OrderedReader for this OrderedList
+    # @return [OrderedReader]
+    def ordered_reader
+      OrderedReader.new(self)
+    end
 
-      # Populates the list with constructed ListNode Objects
-      # @param subject [RDF::URI]
-      def build_node(subject = nil)
-        return nil unless subject
-        node_cache.fetch(subject) do
-          ListNode.new(node_cache, subject, adapter, graph)
-        end
+    # Populates the list with constructed ListNode Objects
+    # @param subject [RDF::URI]
+    def build_node(subject = nil)
+      return nil unless subject
+      node_cache.fetch(subject) do
+        ListNode.new(node_cache, subject, adapter, graph)
       end
+    end
 
-      # Generates hash URIs for the subject of the LinkedList
-      # Should one of these URIs already be in use, a new URI will be generated
-      # @return [RDF::URI]
-      def new_node_subject
-        node = ::RDF::URI("##{::RDF::Node.new.id}")
-        node = ::RDF::URI("##{::RDF::Node.new.id}") while node_cache.key?(node)
-        node
-      end
+    # Generates hash URIs for the subject of the LinkedList
+    # Should one of these URIs already be in use, a new URI will be generated
+    # @return [RDF::URI]
+    def new_node_subject
+      node = ::RDF::URI("##{::RDF::Node.new.id}")
+      node = ::RDF::URI("##{::RDF::Node.new.id}") while node_cache.key?(node)
+      node
+    end
 
-      # Class used for caching LinkedNode objects mapped to URIs
-      class NodeCache
-        def initialize
-          @cache ||= {}
-        end
+    # Class used for caching LinkedNode objects mapped to URIs
+    class NodeCache
+      def initialize
+        @cache ||= {}
+      end
 
-        # Retrieve the ListNode for a given URI
-        # If a block is passed, set its output to the cache
-        # @param uri [RDF::URI]
-        # @return [ListNode]
-        def fetch(uri)
-          @cache[uri] ||= yield if block_given?
-        end
+      # Retrieve the ListNode for a given URI
+      # If a block is passed, set its output to the cache
+      # @param uri [RDF::URI]
+      # @return [ListNode]
+      def fetch(uri)
+        @cache[uri] ||= yield if block_given?
+      end
 
-        # Determines whether or not the cache contains a key
-        # @param key [Object]
-        # @return [Boolean]
-        def key?(key)
-          @cache.key?(key)
-        end
+      # Determines whether or not the cache contains a key
+      # @param key [Object]
+      # @return [Boolean]
+      def key?(key)
+        @cache.key?(key)
       end
+    end
 
-      # Class modeling sentinels within the linked list
-      # @see https://en.wikipedia.org/wiki/Sentinel_value
-      class Sentinel
-        attr_reader :parent, :next, :prev
-        attr_writer :next, :prev
-
-        # @param parent [Valkyrie::Persistence::Fedora::OrderedList]
-        # @param next_node [ListNode]
-        # @param prev_node [ListNode]
-        def initialize(parent, next_node: nil, prev_node: nil)
-          @parent = parent
-          @next = next_node
-          @prev = prev_node
-        end
+    # Class modeling sentinels within the linked list
+    # @see https://en.wikipedia.org/wiki/Sentinel_value
+    class Sentinel
+      attr_reader :parent, :next, :prev
+      attr_writer :next, :prev
+
+      # @param parent [Valkyrie::Persistence::Fedora::OrderedList]
+      # @param next_node [ListNode]
+      # @param prev_node [ListNode]
+      def initialize(parent, next_node: nil, prev_node: nil)
+        @parent = parent
+        @next = next_node
+        @prev = prev_node
+      end
 
-        # Ensure that this always behaves like a NilClass
-        # @return [TrueClass]
-        def nil?
-          true
-        end
+      # Ensure that this always behaves like a NilClass
+      # @return [TrueClass]
+      def nil?
+        true
+      end
 
-        # Ensure that this does not have a URI
-        # @return [NilClass]
-        def rdf_subject
-          nil
-        end
+      # Ensure that this does not have a URI
+      # @return [NilClass]
+      def rdf_subject
+        nil
       end
+    end
 
-      class HeadSentinel < Sentinel
-        # @param parent [Valkyrie::Persistence::Fedora::OrderedList]
-        # @param next_node [ListNode]
-        # @param prev_node [ListNode]
-        def initialize(*args)
-          super
-          @next ||= TailSentinel.new(parent, prev_node: self)
-        end
+    class HeadSentinel < Sentinel
+      # @param parent [Valkyrie::Persistence::Fedora::OrderedList]
+      # @param next_node [ListNode]
+      # @param prev_node [ListNode]
+      def initialize(*args)
+        super
+        @next ||= TailSentinel.new(parent, prev_node: self)
       end
+    end
 
-      class TailSentinel < Sentinel
-        # @param parent [Valkyrie::Persistence::Fedora::OrderedList]
-        # @param next_node [ListNode]
-        # @param prev_node [ListNode]
-        def initialize(*args)
-          super
-          prev.next = self if prev&.next != self
-        end
+    class TailSentinel < Sentinel
+      # @param parent [Valkyrie::Persistence::Fedora::OrderedList]
+      # @param next_node [ListNode]
+      # @param prev_node [ListNode]
+      def initialize(*args)
+        super
+        prev.next = self if prev&.next != self
       end
+    end
   end
 end

data/lib/valkyrie/persistence/fedora/ordered_reader.rb

@@ -26,10 +26,10 @@ module Valkyrie::Persistence::Fedora
 
     private
 
-      # Access the "first" (head) node for the linked list
-      # @return [Valkyrie::Persistence::Fedora::OrderedList::HeadSentinel]
-      def first_head
-        root.head
-      end
+    # Access the "first" (head) node for the linked list
+    # @return [Valkyrie::Persistence::Fedora::OrderedList::HeadSentinel]
+    def first_head
+      root.head
+    end
   end
 end

data/lib/valkyrie/persistence/fedora/permissive_schema.rb

@@ -92,7 +92,7 @@ module Valkyrie::Persistence::Fedora
       existing_predicates = schema.find { |_k, v| v == RDF::URI(predicate.to_s) }
       predicate_name = predicate.to_s.gsub(URI_PREFIX, '')
 
-      return predicate_name if existing_predicates.nil? || existing_predicates.empty?
+      return predicate_name if existing_predicates.blank?
       existing_predicates.first
     end
   end