valkyrie 0.0.0 → 0.1.0

data/db/seeds.rb

@@ -0,0 +1,8 @@
+# frozen_string_literal: true
+# This file should contain all the record creation needed to seed the database with its default values.
+# The data can then be loaded with the rails db:seed command (or created alongside the database with db:setup).
+#
+# Examples:
+#
+#   movies = Movie.create([{ name: 'Star Wars' }, { name: 'Lord of the Rings' }])
+#   Character.create(name: 'Luke', movie: movies.first)

data/lib/config/database_connection.rb

@@ -0,0 +1,15 @@
+# frozen_string_literal: true
+require 'active_record'
+require 'erb'
+
+module DatabaseConnection
+  def self.connect!(env)
+    # Ref https://github.com/puma/puma#clustered-mode
+    ActiveSupport.on_load(:active_record) do
+      ::ActiveRecord::Base.connection_pool.disconnect! if ::ActiveRecord::Base.connected?
+      ::ActiveRecord::Base.configurations = YAML.safe_load(ERB.new(File.read("db/config.yml")).result) || {}
+      config = ::ActiveRecord::Base.configurations[env.to_s]
+      ::ActiveRecord::Base.establish_connection(config)
+    end
+  end
+end

data/lib/generators/valkyrie/resource_generator.rb

@@ -0,0 +1,27 @@
+# frozen_string_literal: true
+require 'rails/generators'
+require 'rails/generators/model_helpers'
+
+class Valkyrie::ResourceGenerator < Rails::Generators::NamedBase
+  # Include ModelHelpers to warn about pluralization when generating new models or scaffolds
+  include Rails::Generators::ModelHelpers
+
+  source_root File.expand_path('../templates', __FILE__)
+
+  argument :attributes, type: :array, default: [], banner: 'field:type field:type'
+
+  def create_model
+    template('resource.rb.erb', File.join('app/models', class_path, "#{file_name}.rb"))
+  end
+
+  def create_model_spec
+    return unless rspec_installed?
+    template('resource_spec.rb.erb', File.join('spec/models', class_path, "#{file_name}_spec.rb"))
+  end
+
+  private
+
+    def rspec_installed?
+      defined?(RSpec) && defined?(RSpec::Rails)
+    end
+end

data/lib/generators/valkyrie/templates/resource.rb.erb

@@ -0,0 +1,9 @@
+# frozen_string_literal: true
+# Generated with `rails generate valkyrie:model <%= class_name %>`
+class <%= class_name %> < Valkyrie::Resource
+  include Valkyrie::Resource::AccessControls
+  attribute :id, Valkyrie::Types::ID.optional
+<%- attributes.each do |att| -%>
+  attribute :<%= att.name %>, Valkyrie::Types::<%= (att.type == :array) ? 'Array' : 'Set' %>
+<%- end -%>
+end

data/lib/generators/valkyrie/templates/resource_spec.rb.erb

@@ -0,0 +1,13 @@
+# frozen_string_literal: true
+# Generated with `rails generate valkyrie:model <%= class_name %>`
+require 'rails_helper'
+require 'valkyrie/specs/shared_specs'
+
+RSpec.describe <%= class_name %> do
+  let(:model_klass) { described_class }
+  it_behaves_like "a Valkyrie::Resource"
+
+  it "has tests" do
+    skip "Add your tests here"
+  end
+end

data/lib/valkyrie.rb

@@ -1,5 +1,80 @@
+# frozen_string_literal: true
 require "valkyrie/version"
+require "ostruct"
+require 'active_support'
+require 'active_support/core_ext'
+require 'dry-types'
+require 'dry-struct'
+require 'draper'
+require 'active_record'
+require 'reform'
+require 'reform/active_record'
+require 'rdf'
+require 'valkyrie/rdf_patches'
+require 'json/ld'
+require 'logger'
+require 'active_triples'
+require 'rdf/vocab'
+require 'active_fedora'
+require 'hydra-access-controls'
+require 'ruby_tika_app'
 
+# frozen_string_literal: true
 module Valkyrie
-  # Your code goes here...
+  require 'valkyrie/id'
+  require 'valkyrie/change_set'
+  require 'valkyrie/value_mapper'
+  require 'valkyrie/persistence'
+  require 'valkyrie/types'
+  require 'valkyrie/resource'
+  require 'valkyrie/derivative_service'
+  require 'valkyrie/storage_adapter'
+  require 'valkyrie/metadata_adapter'
+  require 'valkyrie/adapter_container'
+  require 'valkyrie/file_characterization_service'
+  require 'valkyrie/decorators/decorator_list'
+  require 'valkyrie/decorators/decorator_with_arguments'
+  require 'valkyrie/resource/access_controls'
+  require 'valkyrie/indexers/access_controls_indexer'
+  require 'valkyrie/storage'
+  require 'valkyrie/vocab/pcdm_use'
+  require 'generators/valkyrie/resource_generator'
+  require 'valkyrie/engine' if defined?(Rails)
+  def config
+    @config ||= Config.new(
+      YAML.safe_load(ERB.new(File.read(config_root_path.join("config", "valkyrie.yml"))).result)[environment]
+    )
+  end
+
+  def environment
+    Rails.env
+  end
+
+  def config_root_path
+    if const_defined?(:Rails) && Rails.root
+      Rails.root
+    else
+      Pathname.new(Dir.pwd)
+    end
+  end
+
+  def logger
+    @logger ||= Logger.new(STDOUT)
+  end
+
+  def logger=(logger)
+    @logger = logger
+  end
+
+  class Config < OpenStruct
+    def metadata_adapter
+      Valkyrie::MetadataAdapter.find(super.to_sym)
+    end
+
+    def storage_adapter
+      Valkyrie::StorageAdapter.find(super.to_sym)
+    end
+  end
+
+  module_function :config, :logger, :logger=, :config_root_path, :environment
 end

data/lib/valkyrie/adapter_container.rb

@@ -0,0 +1,12 @@
+# frozen_string_literal: true
+module Valkyrie
+  class AdapterContainer
+    # Wraps up an individual persister and query service to conform to the
+    # adapter interface. Useful for decorated persisters.
+    attr_reader :persister, :query_service
+    def initialize(persister:, query_service:)
+      @persister = persister
+      @query_service = query_service
+    end
+  end
+end

data/lib/valkyrie/change_set.rb

@@ -0,0 +1,84 @@
+# frozen_string_literal: true
+require 'reform/form/coercion'
+require 'reform/form/active_model/validations'
+module Valkyrie
+  ##
+  # Standard change set object for Valkyrie.
+  # ChangeSets are a way to group together properties that should be applied to
+  # an underlying resource. They are often used for powering HTML Forms or
+  # storing virtual attributes for special synchronization with a resource.
+  # @example Define a change set
+  #   class BookChangeSet < Valkyrie::ChangeSet
+  #     self.fields = [:title, :author]
+  #     validates :title, presence: true
+  #     property :title, multiple: false, required: true
+  #   end
+  class ChangeSet < Reform::Form
+    include Reform::Form::ActiveModel::Validations
+    feature Coercion
+    class_attribute :fields
+    self.fields = []
+
+    property :append_id, virtual: true
+
+    # Set ID of record this one should be appended to.
+    # @param append_id [Valkyrie::ID]
+    def append_id=(append_id)
+      super(Valkyrie::ID.new(append_id))
+    end
+
+    # Returns whether or not a given field has multiple values.
+    # @param field [Symbol]
+    # @return [Boolean]
+    def multiple?(field)
+      self.class.definitions[field.to_s][:multiple] != false
+    end
+
+    # Returns whether or not a given field is required.
+    # @param field [Symbol]
+    # @return [Boolean]
+    def required?(field)
+      self.class.definitions[field.to_s][:required]
+    end
+
+    # Quick setter for fields that should be in a changeset. Defaults to multiple,
+    # not required, with an empty array default.
+    # @param fields [Array<Symbol>]
+    def self.fields=(fields)
+      singleton_class.class_eval do
+        remove_possible_method(:fields)
+        define_method(:fields) { fields }
+      end
+
+      fields.each do |field|
+        property field, default: []
+      end
+      fields
+    end
+
+    # Returns value for a given property.
+    # @param key [Symbol]
+    def [](key)
+      send(key) if respond_to?(key)
+    end
+
+    delegate :attributes, to: :resource
+
+    delegate :internal_resource, :created_at, :updated_at, :model_name, to: :resource
+
+    # Prepopulates all fields with defaults defined in the changeset. This is an
+    # override of Reform::Form's method to allow for single-valued fields to
+    # prepopulate appropriately.
+    def prepopulate!(_options = {})
+      self.class.definitions.select { |_field, definition| definition[:multiple] == false }.each do |field, _definition|
+        value = Array.wrap(send(field.to_s)).first
+        send("#{field}=", value)
+      end
+      self
+    end
+
+    def resource
+      model
+    end
+  end
+end

data/lib/valkyrie/decorators/decorator_list.rb

@@ -0,0 +1,15 @@
+# frozen_string_literal: true
+module Valkyrie::Decorators
+  class DecoratorList
+    attr_reader :decorators
+    def initialize(*decorators)
+      @decorators = decorators
+    end
+
+    def new(undecorated_object)
+      decorators.inject(undecorated_object) do |obj, decorator|
+        decorator.new(obj)
+      end
+    end
+  end
+end

data/lib/valkyrie/decorators/decorator_with_arguments.rb

@@ -0,0 +1,14 @@
+# frozen_string_literal: true
+module Valkyrie::Decorators
+  class DecoratorWithArguments
+    attr_reader :decorator, :args
+    def initialize(decorator, *args)
+      @decorator = decorator
+      @args = args
+    end
+
+    def new(item)
+      decorator.new(item, *args)
+    end
+  end
+end

data/lib/valkyrie/derivative_service.rb

@@ -0,0 +1,42 @@
+# frozen_string_literal: true
+require 'hydra/derivatives'
+module Valkyrie
+  ##
+  # Container for registering DerivativeServices.
+  #
+  # To add a new service:
+  #   DerivativeService.services << MyDerivativeService
+  class DerivativeService
+    require 'valkyrie/local_file_service'
+    require 'valkyrie/persist_derivatives'
+    Hydra::Derivatives.source_file_service = Valkyrie::LocalFileService
+    Hydra::Derivatives.output_file_service = Valkyrie::PersistDerivatives
+    class_attribute :services
+    self.services = []
+    # Returns a derivative service for a change_set.
+    # @param resource [Valkyrie::ChangeSet]
+    # @return [Valkyrie::DerivativeService]
+    def self.for(change_set)
+      services.map { |service| service.new(change_set) }.find(&:valid?) ||
+        new(change_set)
+    end
+    attr_reader :change_set
+    delegate :mime_type, :uri, to: :change_set
+    # @param resource [Valkyrie::Resource]
+    def initialize(change_set)
+      @change_set = change_set
+    end
+
+    # Deletes any derivatives generated.
+    def cleanup_derivatives; end
+
+    # Creates derivatives.
+    def create_derivatives; end
+
+    # Returns true if the given resource is valid for this derivative service.
+    # @return [Boolean]
+    def valid?
+      true
+    end
+  end
+end

data/lib/valkyrie/engine.rb

@@ -0,0 +1,10 @@
+# frozen_string_literal: true
+##
+# This engine exists for the sole purpose of enabling the
+#   `valkyrie_engine:install:migrations` rake task from an including Rails
+#   application. It technically enables a whole host of other functionality -
+#   don't use it, please.
+module Valkyrie
+  class Engine < Rails::Engine
+  end
+end

data/lib/valkyrie/file_characterization_service.rb

@@ -0,0 +1,42 @@
+# frozen_string_literal: true
+require 'ruby_tika_app'
+
+module Valkyrie
+  # Abstract base class for file characterization
+  # registers file characterization service a ValkyrieFileCharacterization service
+  # initializes the interface for file characterization
+  # @since 0.1.0
+  class FileCharacterizationService
+    class_attribute :services
+    self.services = []
+    # initializes the file characterization service
+    # @param file_node [FileNode] the FileNode to be characterized
+    # @param persister [AppendingPersister] the Persister used to save the FileNode
+    # @return [TikaFileCharacterizationService] the file characterization service, currently only TikaFileCharacterizationService is implemented
+    def self.for(file_node:, persister:)
+      services.map { |service| service.new(file_node: file_node, persister: persister) }.find(&:valid?) ||
+        new(file_node: file_node, persister: persister)
+    end
+    attr_reader :file_node, :persister
+    delegate :mime_type, :height, :width, :checksum, to: :file_node
+    def initialize(file_node:, persister:)
+      @file_node = file_node
+      @persister = persister
+    end
+
+    # characterizes the file_node passed into this service
+    # Default options are:
+    #   save: true
+    # @param save [Boolean] should the persister save the file_node after Characterization
+    # @return [FileNode]
+    def characterize(save: true)
+      persister.save(resource: @file_node) if save
+      @file_node
+    end
+
+    # Stub function that sets this service as valid for all FileNode types
+    def valid?
+      true
+    end
+  end
+end

data/lib/valkyrie/id.rb

@@ -0,0 +1,32 @@
+# frozen_string_literal: true
+module Valkyrie
+  class ID
+    attr_reader :id
+    delegate :empty?, to: :id
+    def initialize(id)
+      @id = id.to_s
+    end
+
+    def to_s
+      id
+    end
+
+    delegate :hash, to: :state
+
+    def eql?(other)
+      other.class == self.class && other.state == state
+    end
+    alias == eql?
+
+    def to_uri
+      return RDF::Literal.new(id.to_s, datatype: RDF::URI("http://example.com/valkyrie_id")) if id.to_s.include?("://")
+      ::RDF::URI(ActiveFedora::Base.id_to_uri(id))
+    end
+
+    protected
+
+      def state
+        [@id]
+      end
+  end
+end

data/lib/valkyrie/indexers/access_controls_indexer.rb

@@ -0,0 +1,19 @@
+# frozen_string_literal: true
+module Valkyrie::Indexers
+  class AccessControlsIndexer
+    attr_reader :resource
+    def initialize(resource:)
+      @resource = resource
+    end
+
+    def to_solr
+      return {} unless resource.respond_to?(:read_users)
+      {
+        Hydra.config[:permissions][:read].group => resource.read_groups,
+        Hydra.config[:permissions][:read].individual => resource.read_users,
+        Hydra.config[:permissions][:edit].individual => resource.edit_users,
+        Hydra.config[:permissions][:edit].group => resource.edit_groups
+      }
+    end
+  end
+end