ddr-models 3.0.0.beta.3 → 3.0.0.beta.4

data/lib/ddr/index/query_clause.rb

@@ -1,51 +1,96 @@
+require "virtus"
+
 module Ddr::Index
   class QueryClause
+    include Virtus.value_object
+
+    ANY_FIELD = Field.new('*').freeze
+    ANY_VALUE = "[* TO *]"
+    QUOTE     = '"'
+
+    TERM_QUERY      = "{!term f=%{field}}%{value}"
+    STANDARD_QUERY  = "%{field}:%{value}"
+    NEGATIVE_QUERY  = "-%{field}:%{value}"
+    DISJUNCTION     = "{!lucene q.op=OR df=%{field}}%{value}"
+
+    values do
+      attribute :field,       FieldAttribute
+      attribute :value,       String
+      attribute :quote_value, Boolean, default: false
+      attribute :template,    String,  default: STANDARD_QUERY
+    end
+
+    def to_s
+      template % { field: field, value: quote_value ? quote(value) : value }
+    end
 
-    PRESENT = "[* TO *]"
-    TERM = "{!term f=%s}%s"
-    BEFORE_DAYS = "[* TO NOW-%sDAYS]"
+    def quote(value)
+      self.class.quote(value)
+    end
 
     class << self
-      # Standard Solr query, no escaping applied
-      def build(field, value)
-        [field, value].join(":")
+
+      def quote(value)
+        # Derived from Blacklight::Solr::SearchBuilderBehavior#solr_param_quote
+        unless value =~ /\A[a-zA-Z0-9$_\-\^]+\z/
+          QUOTE + value.gsub("'", "\\\\\'").gsub('"', "\\\\\"") + QUOTE
+        else
+          value
+        end
       end
 
+      # Builds a query clause to retrieve the index document by unique key.
       def unique_key(value)
         term(UniqueKeyField.instance, value)
       end
       alias_method :id, :unique_key
-      alias_method :pid, :unique_key
 
+      def where(field, value)
+         values = Array(value)
+        if values.size > 1
+          disjunction(field, values)
+        else
+          new(field: field, value: values.first, quote_value: true)
+        end
+      end
+
+      # Builds a query clause to filter where field does not have the given value.
       def negative(field, value)
-        build "-#{field}", value
+        new(field: field, value: value, template: NEGATIVE_QUERY, quote_value: true)
       end
 
+      # Builds a query clause to filter where field is present (i.e, has any value)
       def present(field)
-        build field, PRESENT
+        new(field: field, value: ANY_VALUE)
       end
 
+      # Builds a query clause to filter where field is NOT present (no values)
       def absent(field)
-        negative field, PRESENT
+        new(field: field, value: ANY_VALUE, template: NEGATIVE_QUERY)
       end
 
-      def or_values(field, *values)
-        build field, QueryValue.or_values(*values)
+      # Builds a query clause to filter where field contains at least one of a set of values.
+      def disjunction(field, values)
+        value = values.map { |v| quote(v) }.join(" ")
+        new(field: field, value: value, template: DISJUNCTION)
       end
 
-      def before(field, date_time)
-        value = "[* TO %s]" % Ddr::Utils.solr_date(date_time)
-        build field, value
+      # Builds a query clause to filter where date field value is earlier than a date/time value.
+      def before(field, value)
+        new(field: field, value: "[* TO %s]" % Ddr::Utils.solr_date(value))
       end
+      alias_method :before_date_time, :before
 
-      def before_days(field, days)
-        value = BEFORE_DAYS % days.to_i
-        build field, value
+      # Builds a query clause to filter where date field value is earlier than a number of days before now.
+      def before_days(field, value)
+        new(field: field, value: "[* TO NOW-%iDAYS]" % value)
       end
 
+      # Builds a "term query" clause to filter where field contains value.
       def term(field, value)
-        TERM % [field, value.gsub(/"/, '\"')]
+        new(field: field, value: value, template: TERM_QUERY)
       end
+
     end
 
   end

data/lib/ddr/index/query_params.rb

@@ -0,0 +1,40 @@
+module Ddr::Index
+  class QueryParams
+
+    attr_reader :query
+
+    def initialize(query)
+      @query = query
+    end
+
+    def params
+      { q:    q_param,
+        fq:   filter_queries,
+        fl:   fields,
+        sort: sort,
+        rows: rows,
+      }.select { |k, v| v.present? }
+    end
+
+    def q_param
+      query.q.to_s
+    end
+
+    def filter_queries
+      query.filter_clauses.map(&:to_s)
+    end
+
+    def fields
+      query.fields.join(",")
+    end
+
+    def sort
+      query.sort.join(",")
+    end
+
+    def rows
+      query.rows
+    end
+
+  end
+end

data/lib/ddr/index/solr_csv_options.rb

@@ -0,0 +1,18 @@
+require "hashie"
+
+module Ddr::Index
+  class SolrCSVOptions < Hashie::Trash
+
+    property "csv.header",       from: :header,     default: false
+    property "csv.separator",    from: :col_sep,    default: ","
+    property "csv.encapsulator", from: :quote_char, default: '"'
+    property "csv.mv.separator", from: :mv_sep,     default: ","
+    property :wt,                default: "csv"
+    property :rows
+
+    def params
+      to_h.reject { |k, v| v.nil? }
+    end
+
+  end
+end

data/lib/ddr/index/sort_order.rb

@@ -0,0 +1,28 @@
+require "virtus"
+
+module Ddr::Index
+  class SortOrder
+    include Virtus.value_object
+
+    ASC = "asc"
+    DESC = "desc"
+
+    values do
+      attribute :field, FieldAttribute
+      attribute :order, String
+    end
+
+    def to_s
+      [ field, order ].join(" ")
+    end
+
+    def self.asc(field)
+      new(field: field, order: ASC)
+    end
+
+    def self.desc(field)
+      new(field: field, order: DESC)
+    end
+
+  end
+end

data/lib/ddr/jobs.rb

@@ -2,8 +2,12 @@ module Ddr
   module Jobs
     extend ActiveSupport::Autoload
 
-    autoload :PermanentId
     autoload :FitsFileCharacterization
+    autoload :FixityCheck
+    autoload :Job
+    autoload :PermanentId
+    autoload :Queue
+    autoload :UpdateIndex
 
     autoload_at 'ddr/jobs/permanent_id' do
       autoload :MakeUnavailable

data/lib/ddr/jobs/fits_file_characterization.rb

@@ -1,51 +1,13 @@
-require 'open3'
-
 module Ddr::Jobs
   class FitsFileCharacterization
+    extend Job
 
     @queue = :file_characterization
 
-    EVENT_SUMMARY = 'FITS characterization of content file'.freeze
-
     def self.perform(pid)
       obj = ActiveFedora::Base.find(pid)
-      tmp_filename = Ddr::Utils::sanitize_filename(obj.original_filename) || obj.content.default_file_name
-      Dir.mktmpdir do |dir|
-        infile = create_temp_infile(dir, tmp_filename, obj.content.content)
-        fits_output, err, status = Open3.capture3(fits_command, '-i', infile)
-        if status.success? && fits_output.present?
-          obj.reload
-          obj.fits.content = fits_output
-          obj.save!
-        end
-        notify_event(pid, err, status)
-      end
-    end
-
-    def self.fits_command
-      File.join(Ddr::Models.fits_home, 'fits.sh')
-    end
-
-    def self.fits_version
-      `#{fits_command} -v`.strip
-    end
-
-    private
-
-    def self.create_temp_infile(dir, tmp_filename, content)
-      temp_infile = File.join(dir, tmp_filename)
-      File.open(temp_infile, 'wb') do |f|
-        f.write content
-      end
-      temp_infile
-    end
-
-    def self.notify_event(pid, err, status)
-      details = status.success? ? nil : err
-      event_args = { pid: pid, summary: EVENT_SUMMARY, software:  "fits #{fits_version}", detail: details }
-      event_args[:outcome] = status.success? ? Ddr::Events::Event::SUCCESS : Ddr::Events::Event::FAILURE
-      Ddr::Notifications.notify_event(:update, event_args)
+      Ddr::Models::FileCharacterization.call(obj)
     end
 
   end
-end
+end

data/lib/ddr/jobs/fixity_check.rb

@@ -0,0 +1,13 @@
+module Ddr::Jobs
+  class FixityCheck
+    extend Job
+
+    @queue = :fixity
+
+    def self.perform(id)
+      obj = ActiveFedora::Base.find(id)
+      obj.fixity_check
+    end
+
+  end
+end

data/lib/ddr/jobs/job.rb

@@ -0,0 +1,36 @@
+require "resque"
+
+module Ddr::Jobs
+  module Job
+
+    def self.extended(base)
+      base.extend ClassMethods
+    end
+
+    module ClassMethods
+      # @return [Array<String>] list of object ids queued for this job type.
+      # @note Assumes that the object_id is the first argument of the .perform method.
+      def queued_object_ids(**args)
+        args[:type] = self
+        __queue__.jobs(**args).map { |job| job["args"].first }
+      end
+
+      protected
+
+      def method_missing(name, *args, &block)
+        # If .queue method not defined, do the right thing
+        if name == :queue
+          return Resque.queue_from_class(self)
+        end
+        super
+      end
+
+      private
+
+      def __queue__
+        Queue.new(queue)
+      end
+    end
+
+  end
+end

data/lib/ddr/jobs/queue.rb

@@ -0,0 +1,27 @@
+require "resque"
+
+module Ddr::Jobs
+  class Queue
+
+    attr_reader :name
+
+    def initialize(name)
+      @name = name
+    end
+
+    def size
+      Resque.size(name)
+    end
+
+    # @return [Array<Hash>] jobs in the queue, optionally filtered by type,
+    #   start position, and count.
+    def jobs(type: nil, start: 0, count: nil)
+      jobs = Resque.peek(name, start, count || size)
+      if type
+        jobs.select! { |job| job["class"] == type.to_s }
+      end
+      jobs
+    end
+
+  end
+end

data/lib/ddr/jobs/update_index.rb

@@ -0,0 +1,13 @@
+module Ddr::Jobs
+  class UpdateIndex
+    extend Job
+
+    @queue = :index
+
+    def self.perform(id)
+      obj = ActiveFedora::Base.find(id)
+      obj.update_index
+    end
+
+  end
+end

data/lib/ddr/models.rb

@@ -7,15 +7,14 @@ require 'hydra/validations'
 
 module Ddr
   extend ActiveSupport::Autoload
+  extend Deprecation
 
   autoload :Actions
   autoload :Auth
-  autoload :Contacts
   autoload :Datastreams
   autoload :Derivatives
   autoload :Events
   autoload :Index
-  autoload :IndexFields
   autoload :Jobs
   autoload :Managers
   autoload :Metadata
@@ -23,19 +22,30 @@ module Ddr
   autoload :Utils
   autoload :Vocab
 
+  def self.const_missing(name)
+    if name == :IndexFields
+      Deprecation.warn(Ddr::Models, "`Ddr::IndexFields` is deprecated and will be removed in ddr-models 3.0." \
+                                    " Use `Ddr::Index::Fields` instead.")
+      Index::Fields
+    else
+      super
+    end
+  end
+
   module Models
     extend ActiveSupport::Autoload
 
-    autoload :AccessControllable
     autoload :AdminSet
     autoload :AttachedFileProfile
     autoload :AttachedFilesProfile
     autoload :Base
     autoload :ChecksumInvalid, 'ddr/models/error'
+    autoload :Contact
     autoload :ContentModelError, 'ddr/models/error'
     autoload :DerivativeGenerationFailure, 'ddr/models/error'
     autoload :Error
     autoload :EventLoggable
+    autoload :FileCharacterization
     autoload :FileManagement
     autoload :FindingAid
     autoload :FixityCheckable
@@ -48,6 +58,7 @@ module Ddr
     autoload :HasStructMetadata
     autoload :HasThumbnail
     autoload :Indexing
+    autoload :NotFoundError, 'ddr/models/error'
     autoload :ObjectApi
     autoload :SolrDocument
     autoload :StructDiv
@@ -55,6 +66,7 @@ module Ddr
     autoload :UrlSafeId
     autoload :Validatable
     autoload :Validator
+    autoload :WithContentFile
     autoload :YearFacet
 
     autoload_under "licenses" do
@@ -113,6 +125,11 @@ module Ddr
       "http://library.duke.edu/rubenstein/findingaids/"
     end
 
+    # Application temp dir - defaults to system temp dir
+    mattr_accessor :tempdir do
+      Dir.tmpdir
+    end
+
     # Yields an object with module configuration accessors
     def self.configure
       yield self