valkyrie 0.0.0 → 0.1.0

data/lib/valkyrie/storage/fedora.rb

@@ -0,0 +1,71 @@
+# frozen_string_literal: true
+module Valkyrie::Storage
+  class Fedora
+    attr_reader :connection
+    PROTOCOL = 'fedora://'
+    def initialize(connection:)
+      @connection = connection
+    end
+
+    # @param id [Valkyrie::ID]
+    # @return [Boolean] true if this adapter can handle this type of identifer
+    def handles?(id:)
+      id.to_s.start_with?(PROTOCOL)
+    end
+
+    # Return the file associated with the given identifier
+    # @param id [Valkyrie::ID]
+    # @return [Valkyrie::StorageAdapter::StreamFile]
+    def find_by(id:)
+      Valkyrie::StorageAdapter::StreamFile.new(id: id, io: response(id: id))
+    end
+
+    # @param file [IO]
+    # @param resource [Valkyrie::Resource]
+    # @return [Valkyrie::StorageAdapter::StreamFile]
+    def upload(file:, resource:)
+      # TODO: this is a very naive aproach. Change to PCDM
+      identifier = resource.id.to_uri + '/original'
+      ActiveFedora::File.new(identifier) do |af|
+        af.content = file
+        af.save!
+        af.metadata.set_value(:type, af.metadata.type + [::RDF::URI('http://pcdm.org/use#OriginalFile')])
+        af.metadata.save
+      end
+      find_by(id: Valkyrie::ID.new(identifier.to_s.sub(/^.+\/\//, PROTOCOL)))
+    end
+
+    class IOProxy
+      # @param response [Ldp::Resource::BinarySource]
+      attr_reader :size
+      def initialize(source, size)
+        @source = source
+        @size = size
+      end
+      delegate :each, :read, :rewind, to: :io
+
+      # There is no streaming support in faraday (https://github.com/lostisland/faraday/pull/604)
+      # @return [StringIO]
+      def io
+        @io ||= StringIO.new(@source.get.response.body)
+      end
+    end
+    private_constant :IOProxy
+
+    private
+
+      # @return [IOProxy]
+      def response(id:)
+        af_file = ActiveFedora::File.new(active_fedora_identifier(id: id))
+        IOProxy.new(af_file.ldp_source, af_file.size)
+      end
+
+      # Translate the Valkrie ID into a URL for the fedora file
+      # @return [RDF::URI]
+      def active_fedora_identifier(id:)
+        scheme = URI(ActiveFedora.config.credentials[:url]).scheme
+        identifier = id.to_s.sub(PROTOCOL, "#{scheme}://")
+        RDF::URI(identifier)
+      end
+  end
+end

data/lib/valkyrie/storage/memory.rb

@@ -0,0 +1,31 @@
+# frozen_string_literal: true
+module Valkyrie::Storage
+  class Memory
+    attr_reader :cache
+    def initialize
+      @cache = {}
+    end
+
+    # @param file [IO]
+    # @param resource [Valkyrie::Resource]
+    # @return [Valkyrie::StorageAdapter::StreamFile]
+    def upload(file:, resource: nil)
+      identifier = Valkyrie::ID.new("memory://#{resource.id}")
+      cache[identifier] = Valkyrie::StorageAdapter::StreamFile.new(id: identifier, io: file)
+    end
+
+    # Return the file associated with the given identifier
+    # @param id [Valkyrie::ID]
+    # @return [Valkyrie::StorageAdapter::StreamFile]
+    def find_by(id:)
+      return unless handles?(id: id) && cache[id]
+      cache[id]
+    end
+
+    # @param id [Valkyrie::ID]
+    # @return [Boolean] true if this adapter can handle this type of identifer
+    def handles?(id:)
+      id.to_s.start_with?("memory://")
+    end
+  end
+end

data/lib/valkyrie/storage_adapter.rb

@@ -0,0 +1,100 @@
+# frozen_string_literal: true
+module Valkyrie
+  class StorageAdapter
+    class_attribute :storage_adapters
+    self.storage_adapters = {}
+    class << self
+      # Add a storage adapter to the registry under the provided short name
+      # @param storage_adapter [Valkyrie::StorageAdapter]
+      # @param short_name [Symbol]
+      # @return [void]
+      def register(storage_adapter, short_name)
+        storage_adapters[short_name] = storage_adapter
+      end
+
+      # @param short_name [Symbol]
+      # @return [void]
+      def unregister(short_name)
+        storage_adapters.delete(short_name)
+      end
+
+      # Find the adapter associated with the provided short name
+      # @param short_name [Symbol]
+      # @return [Valkyrie::StorageAdapter]
+      def find(short_name)
+        storage_adapters[short_name]
+      end
+
+      # Search through all registered storage adapters until it finds one that
+      # can handle the passed in identifier.  The call find_by on that adapter
+      # with the given identifier.
+      # @param id [Valkyrie::ID]
+      # @return [Valkyrie::StorageAdapter::File]
+      def find_by(id:)
+        storage_adapters.values.find do |storage_adapter|
+          storage_adapter.handles?(id: id)
+        end.find_by(id: id)
+      end
+    end
+
+    class File < Dry::Struct
+      attribute :id, Valkyrie::Types::Any
+      attribute :io, Valkyrie::Types::Any
+      delegate :size, :read, :rewind, to: :io
+      def stream
+        io
+      end
+
+      def disk_path
+        Pathname.new(io.path)
+      end
+
+      # @param id [Valkyre::ID]
+      # @param digests [Array<Digest>]
+      # @return [Array<Digest>]
+      def checksum(digests:)
+        io.rewind
+        while (chunk = io.read(4096))
+          digests.each { |digest| digest.update(chunk) }
+        end
+
+        digests.map(&:to_s)
+      end
+
+      # @param id [Valkyre::ID]
+      # @param size [Integer]
+      # @param digests [Array<Digest>]
+      # @return [Boolean]
+      def valid?(size: nil, digests:)
+        return false if size && io.size.to_i != size.to_i
+        calc_digests = checksum(digests: digests.keys.map { |alg| Digest(alg.upcase).new })
+        return false unless digests.values == calc_digests
+
+        true
+      end
+    end
+
+    class StreamFile < File
+      def disk_path
+        Pathname.new(tmp_file.path)
+      end
+
+      private
+
+        def tmp_file_name
+          id.to_s.tr(':/', '__')
+        end
+
+        def tmp_file_path
+          ::File.join(Dir.tmpdir, tmp_file_name)
+        end
+
+        def tmp_file
+          @tmp_file ||= ::File.open(tmp_file_path, 'w+b') do |f|
+            IO.copy_stream(io, f)
+            f
+          end
+        end
+    end
+  end
+end

data/lib/valkyrie/types.rb

@@ -0,0 +1,34 @@
+# frozen_string_literal: true
+module Valkyrie
+  ##
+  # Namespace for Dry::Types types.
+  module Types
+    include Dry::Types.module
+    # Valkyrie::ID
+    ID = Dry::Types::Definition
+         .new(Valkyrie::ID)
+         .constructor do |input|
+           Valkyrie::ID.new(input)
+         end
+    # Used for casting {Valkyrie::Resources} if possible.
+    Anything = Valkyrie::Types::Any.constructor do |value|
+      if value.respond_to?(:fetch) && value.fetch(:internal_resource, nil)
+        value.fetch(:internal_resource).constantize.new(value)
+      else
+        value
+      end
+    end
+    # Represents an array of unique values.
+    Set = Valkyrie::Types::Coercible::Array.constructor do |value|
+      value.select(&:present?).uniq.map do |val|
+        Anything[val]
+      end
+    end.default([])
+    Array = Dry::Types['coercible.array'].default([])
+    # Used for when an input may be an array, but the output needs to be a
+    # single string.
+    SingleValuedString = Valkyrie::Types::String.constructor do |value|
+      ::Array.wrap(value).first.to_s
+    end
+  end
+end

data/lib/valkyrie/value_mapper.rb

@@ -0,0 +1,67 @@
+# frozen_string_literal: true
+module Valkyrie
+  ##
+  # ValueMapper is a way to handle coordinating extendable casting of values
+  # depending on what the value is. It's used in many of the adapters in
+  # Valkyrie.
+  #
+  # Typically a root node is defined as a sub-class ValueMapper to separate
+  # value mappers for a distinct purpose, but it's not a requirement.
+  #
+  # @example Defining a ValueMapper which converts symbols to strings.
+  #   class ParentMapper < ValueMapper
+  #   end
+  #   class Stringify < ValueMapper
+  #     ParentMapper.register(self)
+  #     def self.handles?(value)
+  #       value.kind_of?(Symbol)
+  #     end
+  #     def result
+  #       value.to_s
+  #     end
+  #   end
+  # @example Use a ValueMapper
+  #   ParentMapper.for(:symbol).result # => "symbol"
+  class ValueMapper
+    # Register a value caster.
+    # @param value_caster [Valkyrie::ValueMapper]
+    def self.register(value_caster)
+      self.value_casters += [value_caster]
+    end
+
+    # @return [Array<Valkyrie::ValueMapper>] Registered value casters.
+    def self.value_casters
+      @value_casters ||= []
+    end
+
+    class << self
+      attr_writer :value_casters
+    end
+
+    # Find the value caster for a given value.
+    # @param value [Anything] The value to find a caster for.
+    def self.for(value)
+      (value_casters + [self]).find do |value_caster|
+        value_caster.handles?(value)
+      end.new(value, self)
+    end
+
+    # Test whether this caster handles a given value.
+    # @param value [Anything]
+    # @return [Boolean]
+    def self.handles?(_value)
+      true
+    end
+
+    attr_reader :value, :calling_mapper
+    def initialize(value, calling_mapper)
+      @value = value
+      @calling_mapper = calling_mapper
+    end
+
+    # @return Casted value.
+    def result
+      value
+    end
+  end
+end

data/lib/valkyrie/version.rb

@@ -1,3 +1,4 @@
+# frozen_string_literal: true
 module Valkyrie
-  VERSION = "0.0.0"
+  VERSION = "0.1.0"
 end

data/lib/valkyrie/vocab/pcdm_use.rb

@@ -0,0 +1,73 @@
+# -*- encoding: utf-8 -*-
+# frozen_string_literal: true
+# This file generated automatically using rdf vocabulary format from http://pcdm.org/use#
+require 'rdf'
+module Valkyrie::Vocab
+  # @!parse
+  #   # Vocabulary for <http://pcdm.org/use#>
+  #   class PCDMUse < RDF::Vocabulary
+  #   end
+  class PCDMUse < RDF::Vocabulary("http://pcdm.org/use#")
+    # Ontology definition
+    ontology :"http://pcdm.org/use#",
+             comment: %(Ontology for a PCDM extension to add subclasses of PCDM File for the
+               different roles files have in relation to the Object they are attached to.),
+             "dc:modified": %(2015-05-12),
+             "dc:publisher": %(http://www.duraspace.org/),
+             "dc:title": %(Portland Common Data Model: Use Extension),
+             "owl:versionInfo": %(2015/05/12),
+             "rdfs:seeAlso": [%(https://github.com/duraspace/pcdm/wiki), %(https://wiki.duraspace.org/display/hydra/File+Use+Vocabulary)]
+
+    # Class definitions
+    term :ExtractedText,
+         comment: %(A textual representation of the Object appropriate for fulltext indexing,
+           such as a plaintext version of a document, or OCR text.),
+         label: "extracted text",
+         "rdf:subClassOf": %(http://pcdm.org/resources#File),
+         "rdfs:isDefinedBy": %(pcdmuse:),
+         type: "rdfs:Class"
+    term :IntermediateFile,
+         comment: %(High quality representation of the Object, appropriate for generating
+           derivatives or other additional processing.),
+         label: "intermediate file",
+         "rdf:subClassOf": %(http://pcdm.org/resources#File),
+         "rdfs:isDefinedBy": %(pcdmuse:),
+         type: "rdfs:Class"
+    term :OriginalFile,
+         comment: %(The original creation format of a file.),
+         label: "original file",
+         "rdf:subClassOf": %(http://pcdm.org/resources#File),
+         "rdfs:isDefinedBy": %(pcdmuse:),
+         type: "rdfs:Class"
+    term :PreservationMasterFile,
+         comment: %(Best quality representation of the Object appropriate for long-term
+           preservation.),
+         label: "preservation master file",
+         "rdf:subClassOf": %(http://pcdm.org/resources#File),
+         "rdfs:isDefinedBy": %(pcdmuse:),
+         type: "rdfs:Class"
+    term :ServiceFile,
+         comment: %(A medium quality representation of the Object appropriate for serving to
+           users.  Similar to a FADGI "derivative file" but can also be used for born-digital content,
+           and is not necessarily derived from another file.),
+         label: "service file",
+         "rdf:subClassOf": %(http://pcdm.org/resources#File),
+         "rdfs:isDefinedBy": %(pcdmuse:),
+         type: "rdfs:Class"
+    term :ThumbnailImage,
+         comment: %(A low resolution image representation of the Object appropriate for using
+           as an icon.),
+         label: "thumbnail image",
+         "rdf:subClassOf": %(http://pcdm.org/resources#File),
+         "rdfs:isDefinedBy": %(pcdmuse:),
+         type: "rdfs:Class"
+    term :Transcript,
+         comment: %(A textual representation of the Object appropriate for presenting to users,
+           such as subtitles or transcript of a video.  Can be used as a substitute or complement to other
+           files for accessibility purposes.),
+         label: "transcript",
+         "rdf:subClassOf": %(http://pcdm.org/resources#ExtractedText),
+         "rdfs:isDefinedBy": %(pcdmuse:),
+         type: "rdfs:Class"
+  end
+end

data/valkyrie.gemspec

@@ -1,7 +1,8 @@
 # coding: utf-8
-lib = File.expand_path("../lib", __FILE__)
+# frozen_string_literal: true
+lib = File.expand_path('../lib', __FILE__)
 $LOAD_PATH.unshift(lib) unless $LOAD_PATH.include?(lib)
-require "valkyrie/version"
+require 'valkyrie/version'
 
 Gem::Specification.new do |spec|
   spec.name          = "valkyrie"
@@ -9,18 +10,43 @@ Gem::Specification.new do |spec|
   spec.authors       = ["Trey Pendragon"]
   spec.email         = ["tpendragon@princeton.edu"]
 
-  spec.summary       = %q{An ORM using the Data Mapper pattern, specifically built to solve Digital Repository use cases.}
+  spec.summary       = 'An ORM using the Data Mapper pattern, specifically built to solve Digital Repository use cases.'
 
-  spec.homepage      = "https://github.com/samvera-labs/valkyrie"
-
-  spec.files         = `git ls-files -z`.split("\x0").reject do |f|
+  spec.files = `git ls-files -z`.split("\x0").reject do |f|
     f.match(%r{^(test|spec|features)/})
   end
   spec.bindir        = "exe"
   spec.executables   = spec.files.grep(%r{^exe/}) { |f| File.basename(f) }
   spec.require_paths = ["lib"]
 
-  spec.add_development_dependency "bundler", "~> 1.15"
+  spec.add_dependency 'dry-struct'
+  spec.add_dependency 'draper'
+  spec.add_dependency 'activemodel'
+  spec.add_dependency 'dry-types'
+  spec.add_dependency 'rdf'
+  spec.add_dependency 'active-fedora'
+  spec.add_dependency 'activesupport'
+  spec.add_dependency 'activerecord'
+  spec.add_dependency 'reform'
+  spec.add_dependency 'reform-rails'
+  spec.add_dependency 'pg'
+  spec.add_dependency 'json-ld'
+  spec.add_dependency 'json'
+  spec.add_dependency 'active-triples'
+  spec.add_dependency 'hydra-access-controls'
+  spec.add_dependency 'hydra-derivatives'
+  spec.add_dependency 'ruby_tika_app'
+
+  spec.add_development_dependency "bundler", "~> 1.13"
   spec.add_development_dependency "rake", "~> 10.0"
   spec.add_development_dependency "rspec", "~> 3.0"
+  spec.add_development_dependency "pry"
+  spec.add_development_dependency "pry-byebug"
+  spec.add_development_dependency "database_cleaner"
+  spec.add_development_dependency "simplecov"
+  spec.add_development_dependency "coveralls"
+  spec.add_development_dependency "bixby"
+  spec.add_development_dependency 'rubocop', '~> 0.48.0'
+  spec.add_development_dependency 'rubocop-rails'
+  spec.add_development_dependency 'yard'
 end