hydra-head 4.1.3 → 5.0.0.pre1

data/lib/hydra/global_configurable.rb

@@ -1,46 +0,0 @@
-module Hydra::GlobalConfigurable
-  
-  # The config environment name used by the #config method
-  #
-  # Example:
-  #   class MyThing
-  #     extend Hydra::GlobalConfigurable
-  #   end
-  # 
-  # Now MyThing.config will be the result of:
-  #   MyThing.configure(:production) {|config|}
-  #
-  # You set shared attributes by leaving the first argument blank or passing the :shared value:
-  #   MyThing.configure {|config|} 
-  # or
-  #   MyThing.configure(:shared) {|config|}
-  
-  # sets the @configs variable to a new Hash with empty Hash for :shared key and @config to nil
-  def reset_configs!
-    @config = nil
-    @configs = {:shared=>{}}
-  end
-  
-  # A hash of all environment configs
-  # The key is the environment name, the value a Hash
-  def configs
-    @configs ? @configs : (reset_configs! and @configs)
-  end
-  
-  # The main config accessor. It merges the current configs[::Rails.env] 
-  # with configs[:shared] and lazy-loads @config to the result.
-  def config
-    @config ||= configs[:shared].merge(configs[::Rails.env] ||= {})
-  end
-  alias_method :blacklight_config, :config
-  
-  # Accepts a value for the environment to configure and a block
-  # A hash is yielded to the block
-  # If the "env" != :shared,
-  # the hash is created by deep cloning the :shared environment config.
-  # This makes it possible to create defaults in the :shared config
-  def configure(env = :shared, &blk)
-    configs[env] = {}
-    yield configs[env]
-  end
-end

data/lib/hydra/model_methods.rb

@@ -1,104 +0,0 @@
-# will move to lib/hydra/model/model_behavior.rb  (with appropriate namespace changes) in release 5.x
-module Hydra::ModelMethods
-  extend ActiveSupport::Concern
-
-  included do
-    unless self.class ==  Module
-      self.has_many :parts, :class_name=>'ActiveFedora::Base', :property=>:is_part_of
-    end
-  end
-  
-  #
-  # Adds metadata about the depositor to the asset
-  # Most important behavior: if the asset has a rightsMetadata datastream, this method will add +depositor_id+ to its individual edit permissions.
-  #
-  def apply_depositor_metadata(depositor_id)
-    prop_ds = self.datastreams["properties"]
-    rights_ds = self.datastreams["rightsMetadata"]
-  
-    if prop_ds 
-      prop_ds.depositor = depositor_id unless prop_ds.nil?
-    end
-    rights_ds.permissions({:person=>depositor_id}, 'edit') unless rights_ds.nil?
-    return true
-  end
-
-  #
-  # Set the collection type (e.g. hydrangea_article) for the asset
-  #
-  def set_collection_type(collection)
-    prop_ds = self.datastreams["properties"]
-    if !prop_ds.nil? && prop_ds.respond_to?(:collection_values)
-      prop_ds.collection_values = collection
-    end
-  end
-  
-  # Set the title and label on the current object
-  #
-  # @param [String] new_title
-  # @param [Hash] opts (optional) hash of configuration options
-  #
-  # @example Use :only_if_blank option to only update the values when the label is empty
-  #   obj.set_title_and_label("My Title", :only_if_blank=> true)
-  def set_title_and_label(new_title, opts={})
-    if opts[:only_if_blank]
-      if self.label.nil? || self.label.empty?
-        self.label = new_title
-        self.set_title( new_title )
-      end
-    else
-      self.label = new_title
-      set_title( new_title )
-    end
-  end
-  
-  # Set the title and label on the current object
-  #
-  # @param [String] new_title
-  # @param [Hash] opts (optional) hash of configuration options
-  def set_title(new_title, opts={})
-    if self.datastreams.has_key?("descMetadata")
-      desc_metadata_ds = self.datastreams["descMetadata"]
-      if desc_metadata_ds.respond_to?(:title_values)
-        desc_metadata_ds.title_values = new_title
-      else
-        desc_metadata_ds.title = new_title
-      end
-    end
-  end
-
-  # Call insert_contributor on the descMetadata datastream
-  def insert_contributor(type, opts={})
-    ds = self.datastreams["descMetadata"]
-    node, index = ds.insert_contributor(type,opts)
-    return node, index
-  end
-  
-  # Call remove_contributor on the descMetadata datastream
-  def remove_contributor(type, index)
-    ds = self.datastreams["descMetadata"]
-    result = ds.remove_contributor(type,index)
-    return result
-  end
-  
-  # Call to remove file objects
-  def destroy_child_assets
-    destroyable_child_assets.each.inject([]) do |destroyed,fo|
-        destroyed << fo.pid
-        fo.delete
-        destroyed
-    end
-
-  end
-
-  def destroyable_child_assets
-    return [] unless self.parts
-    self.parts.each.inject([]) do |file_assets, fo|
-      parents = fo.ids_for_outbound(:is_part_of)
-      if parents.length == 1 && parents.first.match(/#{self.pid}$/)
-        file_assets << fo
-      end
-      file_assets
-    end
-  end
-end

data/lib/hydra/model_mixins.rb

@@ -1,8 +0,0 @@
-module Hydra::ModelMixins
-  extend ActiveSupport::Autoload
-  eager_autoload do
-    autoload :CommonMetadata
-    autoload :RightsMetadata
-    autoload :SolrDocumentExtension
-  end
-end

data/lib/hydra/model_mixins/common_metadata.rb

@@ -1,25 +0,0 @@
-# Include this into models that you want to conform to the Hydra commonMetadata cModel
-# See https://wiki.duraspace.org/display/hydra/Hydra+objects%2C+content+models+%28cModels%29+and+disseminators#Hydraobjects%2Ccontentmodels%28cModels%29anddisseminators-models
-#
-# Explicitly declares:
-#   rightsMetadata datastream using Hydra::RightsMetadata Terminology
-#
-# Does not explicitly declare:
-#   descMetadata datastream -- should be declared by a more specific mixin like Hydra::ModelMixins::ModsObject
-#   DC datastream -- Handled by ActiveFedora::Base
-#   RELS-EXT datastream -- Handled by ActiveFedora::Base & ActiveFedora::RelsExtDatastream
-#   optional datastreams (contentMetadata, technicalMetadata, provenanceMetadata, sourceMetadata)
-#
-# will move to lib/hydra/model/common_metadata_behavior in release 5.x
-module Hydra::ModelMixins
-  module CommonMetadata
-  
-    def self.included(klazz)
-      # Uses the Hydra Rights Metadata Schema for tracking access permissions & copyright
-      klazz.has_metadata :name => "rightsMetadata", :type => Hydra::Datastream::RightsMetadata
-    
-      # Ensure that objects assert the commonMetadata cModel
-      # klazz.relationships << :has_model => "info:fedora/hydra-cModel:commonMetadata"
-    end
-  end
-end

data/lib/hydra/model_mixins/solr_document_extension.rb

@@ -1,24 +0,0 @@
-module Hydra::ModelMixins
-  module SolrDocumentExtension
-    def document_type display_type = CatalogController.blacklight_config.show.display_type
-      type = self.fetch(:medium_t, nil)
-
-      type ||= self.fetch(display_type, nil) if display_type
-
-      type.first.to_s.gsub("info:fedora/afmodel:","").gsub("Hydrangea","").gsub(/^Generic/,"")
-    end
-
-    def get_person_from_role(role, opts={})
-      i = 0
-      while i < 10
-        persons_roles = self["person_#{i}_role_t"].map{|w|w.strip.downcase} unless self["person_#{i}_role_t"].nil?
-        if persons_roles and persons_roles.include?(role.downcase)
-          return {:first=>self["person_#{i}_first_name_t"], :last=>self["person_#{i}_last_name_t"]}
-        end
-        i += 1
-      end
-    end
-  end
-end
-
-SolrDocument.use_extension Hydra::ModelMixins::SolrDocumentExtension

data/lib/hydra/models/file_asset.rb

@@ -1,78 +0,0 @@
-# will move to lib/hydra/model/file_asset_behavior in release 5.x
-module Hydra
-  module Models
-    # Defines Behaviors for a FileAsset Model
-    # Conforms to the Hydra genericContent cModel -- the "content" is in a datastream called content
-    # TODO:   Could we just move this behavior into app/models/file_asset.rb? 
-    module FileAsset
-      extend ActiveSupport::Concern
-      included do
-        include Hydra::ModelMethods
-        
-        #has_relationship "is_member_of_collection", :has_collection_member, :inbound => true
-        #has_bidirectional_relationship "part_of", :is_part_of, :has_part
-        belongs_to :container, :class_name=>'ActiveFedora::Base', :property=>:is_part_of
-        has_metadata :name => "descMetadata", :type => ActiveFedora::QualifiedDublinCoreDatastream do |m|
-        end
-      end
-
-
-      # Returns a human readable filesize appropriate for the given number of bytes (ie. automatically chooses 'bytes','KB','MB','GB','TB')
-      # Based on a bit of python code posted here: http://blogmag.net/blog/read/38/Print_human_readable_file_size
-      # @param [Numeric] num file size in bits
-      def bits_to_human_readable(num)
-          ['bytes','KB','MB','GB','TB'].each do |x|
-            if num < 1024.0
-              return "#{num.to_i} #{x}"
-            else
-              num = num/1024.0
-            end
-          end
-      end
-      
-
-      def label
-        descMetadata.title.first
-      end
-          
-      def label=(label)
-        super
-        descMetadata.title = label
-      end    
-      
-      # augments add_file_datastream to also put file size (in bytes/KB/MB/GB/TB) in dc:extent 
-      def add_file_datastream(file, opts={})
-        super
-        if file.respond_to?(:size)
-          size = bits_to_human_readable(file.size)
-        elsif file.kind_of?(File)
-          size = bits_to_human_readable(File.size(file))
-        else
-          size = ""
-        end
-        datastreams["descMetadata"].extent = size
-      end
-
-      # Override ActiveFedora::Base.to_solr to...
-      # Check if we are dealing with a child of FileAsset and if so when calling to_solr from Solrizer indexer we want to skip loading parent metadata again 
-      #
-      # if known models greater than one (without ActiveFedora::Base) and
-      #   known models contains a child of FileAsset and
-      #   opts[:model_only] == true and
-      #   current object class is FileAsset
-      # that means that the child already has had to_solr called which included metadata from FileAsset
-      # if any of the above is false then call to_solr as normal
-      def to_solr(solr_doc=Hash.new, opts={})
-
-        active_fedora_model_s = solr_doc["active_fedora_model_s"] if solr_doc["active_fedora_model_s"]
-        actual_class = active_fedora_model_s.constantize if active_fedora_model_s
-        if actual_class && actual_class != self.class && actual_class.superclass == ::FileAsset
-          solr_doc
-        else
-          super(solr_doc,opts)
-        end
-      end
-
-    end
-  end
-end

data/lib/hydra/repository_controller.rb

@@ -1,28 +0,0 @@
-# Hydra-repository Contoller is a controller layer mixin. It is in the controller scope: request params, session etc.
-# 
-# will move to lib/hydra/controller/repository_controller_behavior in release 5.x
-# 
-# NOTE: Be careful when creating variables here as they may be overriding something that already exists.
-# The ActionController docs: http://api.rubyonrails.org/classes/ActionController/Base.html
-#
-# Override these methods in your own controller for customizations:
-# 
-# class HomeController < ActionController::Base
-#   
-#   include Stanford::SolrHelper
-#   
-#   def solr_search_params
-#     super.merge :per_page=>10
-#   end
-#   
-# end
-#
-module Hydra::RepositoryController
-  extend ActiveSupport::Concern
-
-  included do
-    ActiveSupport::Deprecation.warn "Hydra::RepositoryController has moved to Hydra::Controller::RepositoryControllerBehavior"
-    include Hydra::Controller::RepositoryControllerBehavior
-  end
-  
-end

data/lib/hydra/rights_metadata.rb

@@ -1,194 +0,0 @@
-module Hydra
-# @deprecated -- this will be removed in 5.x release
-class RightsMetadata < ActiveFedora::NokogiriDatastream       
-  
-  def initialize(digital_object, dsid, options={})
-    ActiveSupport::Deprecation.warn("Hydra::RightsMetadata has been deprecated. Use Hydra::Datastream::RightsMetadata instead")
-    super
-  end
-
-  set_terminology do |t|
-    t.root(:path=>"rightsMetadata", :xmlns=>"http://hydra-collab.stanford.edu/schemas/rightsMetadata/v1", :schema=>"http://github.com/projecthydra/schemas/tree/v1/rightsMetadata.xsd") 
-    t.copyright {
-      t.machine {
-        t.uvalicense
-        t.cclicense   
-        t.license     
-      }
-      t.human_readable(:path=>"human")
-      t.license(:proxy=>[:machine, :license ])            
-      t.cclicense(:proxy=>[:machine, :cclicense ])                  
-    }
-    t.access {
-      t.human_readable(:path=>"human")
-      t.machine {
-        t.group
-        t.person
-      }
-      t.person(:proxy=>[:machine, :person])
-      t.group(:proxy=>[:machine, :group])
-      # accessor :access_person, :term=>[:access, :machine, :person]
-    }
-    t.discover_access(:ref=>[:access], :attributes=>{:type=>"discover"})
-    t.read_access(:ref=>[:access], :attributes=>{:type=>"read"})
-    t.edit_access(:ref=>[:access], :attributes=>{:type=>"edit"})
-    # A bug in OM prevnts us from declaring proxy terms at the root of a Terminology
-    # t.access_person(:proxy=>[:access,:machine,:person])
-    # t.access_group(:proxy=>[:access,:machine,:group])
-    
-    t.embargo {
-      t.human_readable(:path=>"human")
-      t.machine{
-        t.date(:type =>"release")
-      }
-      t.embargo_release_date(:proxy => [:machine, :date])
-    }    
-  end
-
-  # Generates an empty Mods Article (used when you call ModsArticle.new without passing in existing xml)
-  def self.xml_template
-    builder = Nokogiri::XML::Builder.new do |xml|
-      xml.rightsMetadata(:version=>"0.1", "xmlns"=>"http://hydra-collab.stanford.edu/schemas/rightsMetadata/v1") {
-        xml.copyright {
-          xml.human
-          xml.machine {
-            xml.uvalicense "no"
-          }
-        }
-        xml.access(:type=>"discover") {
-          xml.human
-          xml.machine
-        }
-        xml.access(:type=>"read") {
-          xml.human 
-          xml.machine
-        }
-        xml.access(:type=>"edit") {
-          xml.human
-          xml.machine
-        }
-        xml.embargo{
-          xml.human
-          xml.machine
-        }        
-      }
-    end
-    return builder.doc
-  end
-    
-  # Returns the permissions for the selected person/group
-  # If new_access_level is provided, updates the selected person/group access_level to the one specified 
-  # A new_access_level of "none" will remove all access_levels for the selected person/group
-  # @param [Hash] selector hash in format {type => identifier}
-  # @param new_access_level (default nil)
-  # @return Hash in format {type => access_level}.  
-  # 
-  # ie. 
-  # permissions({:person=>"person123"})
-  # => {"person123"=>"edit"}
-  # permissions({:person=>"person123"}, "read")
-  # => {"person123"=>"read"}
-  # permissions({:person=>"person123"})
-  # => {"person123"=>"read"}
-  def permissions(selector, new_access_level=nil)
-    type = selector.keys.first.to_sym
-    actor = selector.values.first
-    if new_access_level.nil?
-      xpath = self.class.terminology.xpath_for(:access, type, actor)
-      nodeset = self.find_by_terms(xpath)
-      if nodeset.empty?
-        return "none"
-      else
-        return nodeset.first.ancestors("access").first.attributes["type"].text
-      end
-    else
-      remove_all_permissions(selector)
-      unless new_access_level == "none" 
-        access_type_symbol = "#{new_access_level}_access".to_sym
-        result = self.update_values([access_type_symbol, type] => {"-1"=>actor})
-      end
-      self.dirty = true
-      return new_access_level
-    end
-      
-  end
-  
-  # Reports on which groups have which permissions
-  # @return Hash in format {group_name => group_permissions, group_name => group_permissions}
-  def groups
-    return quick_search_by_type(:group)
-  end
-  
-  # Reports on which groups have which permissions
-  # @return Hash in format {person_name => person_permissions, person_name => person_permissions}
-  def individuals
-    return quick_search_by_type(:person)
-  end
-  
-  # Updates permissions for all of the persons and groups in a hash
-  # @param params  ex. {"group"=>{"group1"=>"discover","group2"=>"edit"}, "person"=>{"person1"=>"read","person2"=>"discover"}}
-  # Currently restricts actor type to group or person.  Any others will be ignored
-  def update_permissions(params)
-    params.fetch("group", {}).each_pair {|group_id, access_level| self.permissions({"group"=>group_id}, access_level)}
-    params.fetch("person", {}).each_pair {|group_id, access_level| self.permissions({"person"=>group_id}, access_level)}
-  end
-  
-  # @param [Symbol] type (either :group or :person)
-  # @return 
-  # This method limits the response to known access levels.  Probably runs a bit faster than .permissions().
-  def quick_search_by_type(type)
-    result = {}
-    [{:discover_access=>"discover"},{:read_access=>"read"},{:edit_access=>"edit"}].each do |access_levels_hash|
-      access_level = access_levels_hash.keys.first
-      access_level_name = access_levels_hash.values.first
-      self.find_by_terms(*[access_level, type]).each do |entry|
-        result[entry.text] = access_level_name
-      end
-    end
-    return result
-  end
-
-  attr_reader :embargo_release_date
-  def embargo_release_date=(release_date)
-    release_date = release_date.to_s if release_date.is_a? Date
-    begin
-      Date.parse(release_date)
-    rescue 
-      return "INVALID DATE"
-    end
-    self.update_values({[:embargo,:machine,:date]=>release_date})
-  end
-  def embargo_release_date(opts={})
-    embargo_release_date = self.find_by_terms(*[:embargo,:machine,:date]).first ? self.find_by_terms(*[:embargo,:machine,:date]).first.text : nil
-    if embargo_release_date.present? && opts[:format] && opts[:format] == :solr_date
-      embargo_release_date << "T23:59:59Z"
-    end
-    embargo_release_date
-  end
-  def under_embargo?
-    (embargo_release_date && Date.today < embargo_release_date.to_date) ? true : false
-  end
-
-  def to_solr(solr_doc=Hash.new)
-    super(solr_doc)
-    ::Solrizer::Extractor.insert_solr_field_value(solr_doc, "embargo_release_date_dt", embargo_release_date(:format=>:solr_date)) if embargo_release_date
-    solr_doc
-  end
-
-
-
-
-  
-  private
-  # Purge all access given group/person 
-  def remove_all_permissions(selector)
-    return unless ng_xml
-    type = selector.keys.first.to_sym
-    actor = selector.values.first
-    xpath = self.class.terminology.xpath_for(:access, type, actor)
-    nodes_to_purge = self.find_by_terms(xpath)
-    nodes_to_purge.each {|node| node.remove}
-  end
-  
-end
-end