ddr-core 0.2.1

data/lib/ddr/auth/web_auth_context.rb

@@ -0,0 +1,29 @@
+module Ddr::Auth
+  class WebAuthContext < AuthContext
+
+    # @return [String] the IP address, or nil
+    # @see ActionDispatch::RemoteIp
+    def ip_address
+      if middleware = env["action_dispatch.remote_ip"]
+        middleware.calculate_ip
+      end
+    end
+
+    # @return [Array<String>]
+    def affiliation
+      split_env("affiliation").map { |a| a.sub(/@duke\.edu\z/, "") }
+    end
+
+    # @return [Array<String>]
+    def ismemberof
+      split_env("ismemberof")
+    end
+
+    private
+
+    def split_env(attr, delim = ";")
+      env.fetch(attr, "").split(delim)
+    end
+
+  end
+end

data/lib/ddr/core.rb

@@ -0,0 +1,110 @@
+require 'ddr/core/engine'
+require 'ddr/vocab'
+require 'ddr/auth'
+require 'ddr/error'
+
+module Ddr
+  extend ActiveSupport::Autoload
+
+  autoload :Files
+  autoload :NotFoundError, 'ddr/error'
+  autoload :Fits
+  autoload :Index
+  autoload :Managers
+  autoload :Utils
+  autoload :Workflow
+
+  autoload :Structure
+  module Structures
+    extend ActiveSupport::Autoload
+    autoload :Agent
+    autoload :Div
+    autoload :File
+    autoload :FileGrp
+    autoload :FileSec
+    autoload :FLocat
+    autoload :Fptr
+    autoload :MetsHdr
+    autoload :Mptr
+    autoload :StructMap
+    autoload :ComponentTypeTerm
+  end
+
+  SOLR_DOCUMENT_ID = "id"
+
+  # Default metadata adapter configured for Valkyrie
+  def self.metadata_adapter
+    @metadata_adapter ||= Valkyrie.config.metadata_adapter
+  end
+
+  # Persister for default metadata_adapter
+  def self.persister
+    @persister ||= metadata_adapter.persister
+  end
+
+  # Query Service for default metadata_adapter
+  def self.query_service
+    @query_service ||= metadata_adapter.query_service
+  end
+
+  # Default storage adapter
+  def self.storage_adapter
+    @storage_adapter ||= Valkyrie.config.storage_adapter
+  end
+
+  # Convenient to be able to set the default storage adapter in certain cases
+  def self.storage_adapter=(storage_adapter)
+    @storage_adapter = storage_adapter
+  end
+
+  mattr_accessor :default_mime_type do
+    "application/octet-stream"
+  end
+
+  # Maps media types to preferred file extensions
+  mattr_accessor :preferred_file_extensions do
+    {
+        'application/zip' => 'zip',
+        'audio/mp4'       => 'm4a',
+        'audio/mpeg'      => 'mp3',
+        'audio/ogg'       => 'ogg',
+        'audio/wav'       => 'wav',
+        'text/vtt'        => 'vtt',
+        'video/flv'       => 'flv',
+        'video/mp4'       => 'mp4',
+        'video/quicktime' => 'mov',
+        'video/webm'      => 'webm'
+    }
+  end
+
+  # Maps file extensions to preferred media types
+  mattr_accessor :preferred_media_types do
+    {
+        '.aac'  => 'audio/mp4',
+        '.f4a'  => 'audio/mp4',
+        '.flv'  => 'video/flv',
+        '.m4a'  => 'audio/mp4',
+        '.mov'  => 'video/quicktime',
+        '.mp3'  => 'audio/mpeg',
+        '.mp4'  => 'video/mp4',
+        '.oga'  => 'audio/ogg',
+        '.ogg'  => 'audio/ogg',
+        '.srt'  => 'text/plain',
+        '.vtt'  => 'text/vtt',
+        '.wav'  => 'audio/wav',
+        '.webm' => 'video/webm',
+        '.zip'  => 'application/zip'
+    }
+  end
+
+  # Is repository locked?  Default is false.
+  # A locked repository behaves as though each object in the repository is locked.
+  mattr_accessor :repository_locked do
+    false
+  end
+
+  module Core
+
+  end
+
+end

data/lib/ddr/core/engine.rb

@@ -0,0 +1,8 @@
+require 'valkyrie'
+
+module Ddr
+  module Core
+    class Engine < ::Rails::Engine
+    end
+  end
+end

data/lib/ddr/core/version.rb

@@ -0,0 +1,5 @@
+module Ddr
+  module Core
+    VERSION = '0.2.1'
+  end
+end

data/lib/ddr/error.rb

@@ -0,0 +1,16 @@
+module Ddr
+  # Base class for custom exceptions
+  class Error < StandardError; end
+
+  # # Invalid checksum
+  # class ChecksumInvalid < Error; end
+  #
+  # # Derivative generation failure
+  # class DerivativeGenerationFailure < Error; end
+  #
+  # # Content model casting error
+  # class ContentModelError < Error; end
+
+  # A model instance was not found
+  class NotFoundError < Error; end
+end

data/lib/ddr/files.rb

@@ -0,0 +1,13 @@
+module Ddr
+  module Files
+
+    CHECKSUM_TYPE_MD5    = 'MD5'.freeze
+    CHECKSUM_TYPE_SHA1   = 'SHA1'.freeze
+    CHECKSUM_TYPE_SHA256 = 'SHA256'.freeze
+    CHECKSUM_TYPE_SHA384 = 'SHA384'.freeze
+    CHECKSUM_TYPE_SHA512 = 'SHA512'.freeze
+
+    CHECKSUM_TYPES = Valkyrie::Types::Strict::String.enum(CHECKSUM_TYPE_MD5, CHECKSUM_TYPE_SHA1, CHECKSUM_TYPE_SHA256,
+                                                          CHECKSUM_TYPE_SHA384, CHECKSUM_TYPE_SHA512)
+  end
+end

data/lib/ddr/fits.rb

@@ -0,0 +1,189 @@
+module Ddr
+  class Fits < SimpleDelegator
+
+    FITS_XMLNS = "http://hul.harvard.edu/ois/xml/ns/fits/fits_output".freeze
+    FITS_SCHEMA = "http://hul.harvard.edu/ois/xml/xsd/fits/fits_output.xsd".freeze
+
+    EXIFTOOL = "Exiftool"
+
+    def version
+      root.xpath('@version').map(&:value)
+    end
+
+    def timestamp
+      root.xpath('@timestamp').map(&:value)
+    end
+
+    def format_label
+      root.xpath('fits:identification/fits:identity/@format', fits: FITS_XMLNS).map(&:value)
+    end
+
+    def format_version
+      root.xpath('fits:identification/fits:identity/fits:version', fits: FITS_XMLNS).map(&:text)
+    end
+
+    def media_type
+      root.xpath('fits:identification/fits:identity/@mimetype', fits: FITS_XMLNS).map(&:value)
+    end
+
+    def pronom_identifier
+      root.xpath('fits:identification/fits:identity/fits:externalIdentifier[@type = "puid"]', fits: FITS_XMLNS)
+          .map(&:text)
+    end
+
+    def valid
+      root.xpath('fits:filestatus/fits:valid', fits: FITS_XMLNS).map(&:text)
+    end
+
+    def well_formed
+      root.xpath('fits:filestatus/fits:well-formed', fits: FITS_XMLNS).map(&:text)
+    end
+
+    def created
+      root.xpath('fits:fileinfo/fits:created', fits: FITS_XMLNS).map(&:text)
+    end
+
+    def creating_application
+      root.xpath('fits:fileinfo/fits:creatingApplicationName', fits: FITS_XMLNS).map(&:text)
+    end
+
+    def extent
+      root.xpath('fits:fileinfo/fits:size', fits: FITS_XMLNS).map(&:text)
+    end
+
+    def md5
+      root.xpath('fits:fileinfo/fits:md5checksum', fits: FITS_XMLNS).map(&:text)
+    end
+
+    def color_space
+      root.xpath('fits:metadata/fits:image/fits:colorSpace', fits: FITS_XMLNS).map(&:text)
+    end
+
+    def icc_profile_name
+      root.xpath('fits:metadata/fits:image/fits:iccProfileName', fits: FITS_XMLNS).map(&:text)
+    end
+
+    def icc_profile_version
+      root.xpath('fits:metadata/fits:image/fits:iccProfileVersion', fits: FITS_XMLNS).map(&:text)
+    end
+
+    def image_height
+      root.xpath('fits:metadata/fits:image/fits:imageHeight', fits: FITS_XMLNS).map(&:text)
+    end
+
+    def image_width
+      root.xpath('fits:metadata/fits:image/fits:imageWidth', fits: FITS_XMLNS).map(&:text)
+    end
+
+    def modified
+      root.xpath("fits:fileinfo/fits:lastmodified[@toolname != '#{EXIFTOOL}']", fits: FITS_XMLNS).map(&:text)
+    end
+
+    def self.xml_template
+      builder = Nokogiri::XML::Builder.new do |xml|
+        xml.fits("xmlns"=>FITS_XMLNS,
+                 "xmlns:xsi"=>"http://www.w3.org/2001/XMLSchema-instance",
+                 "xsi:schemaLocation"=>"http://hul.harvard.edu/ois/xml/ns/fits/fits_output #{FITS_SCHEMA}")
+      end
+      builder.doc
+    end
+
+    private
+
+    def root
+      xpath('//fits:fits', fits: FITS_XMLNS).first
+    end
+
+    ### DDRevo ##########################################
+    # From Ddr::Datastreams::FitsDatastream.  Code above accounts for proxy terms from below and has a private 'root'
+    # method but does not (yet) provide methods for all the terms in the terminology.  Thought it was better to wait
+    # and see which ones are actually needed.
+    ### DDRevo ##########################################
+    # set_terminology do |t|
+    #   t.root(path: "fits",
+    #          xmlns: FITS_XMLNS,
+    #          schema: FITS_SCHEMA)
+    #   t.version(path: {attribute: "version"})
+    #   t.timestamp(path: {attribute: "timestamp"})
+    #   t.identification {
+    #     t.identity {
+    #       t.mimetype(path: {attribute: "mimetype"})
+    #       t.format_label(path: {attribute: "format"})
+    #       t.version
+    #       t.externalIdentifier
+    #       t.pronom_identifier(path: "externalIdentifier", attributes: {type: "puid"})
+    #     }
+    #   }
+    #   t.fileinfo {
+    #     t.created
+    #     t.creatingApplicationName
+    #     t.creatingos
+    #     t.filename
+    #     t.filepath
+    #     t.fslastmodified
+    #     t.lastmodified
+    #     t.md5checksum
+    #     t.size
+    #   }
+    #   t.filestatus {
+    #     t.valid
+    #     t.well_formed(path: "well-formed")
+    #   }
+    #   t.metadata {
+    #     t.image {
+    #       t.imageWidth
+    #       t.imageHeight
+    #       t.colorSpace
+    #       t.iccProfileName
+    #       t.iccProfileVersion
+    #     }
+    #     t.document {
+    #       # TODO - configure to get from Tika?
+    #       # t.encoding
+    #     }
+    #     t.text
+    #     t.audio
+    #     t.video
+    #   }
+    #
+    #   ## proxy terms
+    #
+    #   # identification / identity
+    #   t.format_label         proxy: [:identification, :identity, :format_label]
+    #   t.format_version       proxy: [:identification, :identity, :version]
+    #   t.media_type           proxy: [:identification, :identity, :mimetype]
+    #   t.pronom_identifier    proxy: [:identification, :identity, :pronom_identifier]
+    #
+    #   # filestatus
+    #   t.valid                proxy: [:filestatus, :valid]
+    #   t.well_formed          proxy: [:filestatus, :well_formed]
+    #
+    #   # fileinfo
+    #   t.created              proxy: [:fileinfo, :created]
+    #   t.creating_application proxy: [:fileinfo, :creatingApplicationName]
+    #   t.extent               proxy: [:fileinfo, :size]
+    #   t.md5                  proxy: [:fileinfo, :md5checksum]
+    #
+    #   # image metadata
+    #   t.color_space          proxy: [:metadata, :image, :colorSpace]
+    #   t.icc_profile_name     proxy: [:metadata, :image, :iccProfileName]
+    #   t.icc_profile_version  proxy: [:metadata, :image, :iccProfileVersion]
+    #   t.image_height         proxy: [:metadata, :image, :imageHeight]
+    #   t.image_width          proxy: [:metadata, :image, :imageWidth]
+    # end
+    #
+    # def self.xml_template
+    #   builder = Nokogiri::XML::Builder.new do |xml|
+    #     xml.fits("xmlns"=>FITS_XMLNS,
+    #              "xmlns:xsi"=>"http://www.w3.org/2001/XMLSchema-instance",
+    #              "xsi:schemaLocation"=>"http://hul.harvard.edu/ois/xml/ns/fits/fits_output http://hul.harvard.edu/ois/xml/xsd/fits/fits_output.xsd")
+    #   end
+    #   builder.doc
+    # end
+    #
+    # def prefix
+    #   "fits__"
+    # end
+
+  end
+end

data/lib/ddr/index.rb

@@ -0,0 +1,29 @@
+module Ddr
+  module Index
+    extend ActiveSupport::Autoload
+
+    autoload :AbstractQueryResult
+    autoload :Connection
+    autoload :CSVQueryResult
+    autoload :DocumentBuilder
+    autoload :Field
+    autoload :FieldAttribute
+    autoload :Fields
+    autoload :Filter
+    autoload :Query
+    autoload :QueryBuilder
+    autoload :QueryClause
+    autoload :QueryParams
+    autoload :QueryResult
+    autoload :Response
+    autoload :SortOrder
+    autoload :UniqueKeyField
+
+    def self.pids
+      builder = QueryBuilder.new { field UniqueKeyField.instance }
+      query = builder.query
+      query.pids
+    end
+
+  end
+end

data/lib/ddr/index/abstract_query_result.rb

@@ -0,0 +1,22 @@
+module Ddr::Index
+  class AbstractQueryResult
+    include Enumerable
+
+    attr_reader :query
+    delegate :params, to: :query
+
+    def initialize(query)
+      @query = query.dup.freeze
+    end
+
+    def count
+      response = Connection.select(params, rows: 0)
+      response.num_found
+    end
+
+    def each
+      raise NotImplementedError, "Subclasses must implement `#each`."
+    end
+
+  end
+end

data/lib/ddr/index/connection.rb

@@ -0,0 +1,38 @@
+require "rsolr"
+require "forwardable"
+
+module Ddr::Index
+  #
+  # Wraps an RSolr connection
+  #
+  class Connection
+
+    module Methods
+      extend Forwardable
+
+      delegate [:get, :post, :paginate] => :solr
+
+      def solr
+        # Changed for Valkyrie
+        # RSolr.connect(ActiveFedora.solr_config)
+        Blacklight.default_index.connection
+      end
+
+      def select(params, extra={})
+        Response.new post("select", params: params.merge(extra))
+      end
+
+      def page(*args)
+        Response.new paginate(*args)
+      end
+
+      def count(params)
+        select(params, rows: 0).num_found
+      end
+    end
+
+    extend Methods
+    include Methods
+
+  end
+end