hydra-core 5.0.0.pre1

data/lib/hydra/global_configurable.rb

@@ -0,0 +1,46 @@
+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

@@ -0,0 +1,109 @@
+# 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
+
+  def file_asset_count
+    ### TODO switch to AF::Base.count
+    parts.length
+  end
+end

data/lib/hydra/model_mixins/common_metadata.rb

@@ -0,0 +1,25 @@
+# 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

@@ -0,0 +1,24 @@
+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

@@ -0,0 +1,76 @@
+# 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
+        
+        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

@@ -0,0 +1,28 @@
+# 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/solr.rb

@@ -0,0 +1,9 @@
+module Hydra
+  module Solr
+    module Document
+      def to_model
+        ActiveFedora::Base.load_instance_from_solr(id, self)
+      end
+    end
+  end
+end

data/lib/railties/active-fedora.rake

@@ -0,0 +1 @@
+require "active-fedora"  # This causes active-fedora's rake tasks to be loaded

data/lib/railties/hydra-fixtures.rake

@@ -0,0 +1,50 @@
+namespace :hydra do
+  
+  desc "Init Hydra configuration" 
+  task :init => [:environment] do
+    # We need to just start rails so that all the models are loaded
+  end
+
+  desc "Load hydra-head models"
+  task :load_models do
+    require "hydra"
+    Dir.glob(File.join(File.expand_path(File.dirname(__FILE__)), "..",'app','models', '*.rb')).each do |model|
+      load model
+    end
+  end
+
+  namespace :fixtures do
+    task :load do
+      ENV["dir"] ||= File.join("spec", "fixtures")
+      loader = ActiveFedora::FixtureLoader.new(ENV['dir'])
+      Dir.glob("#{ENV['dir']}/*.foxml.xml").each do |fixture_path|
+        pid = File.basename(fixture_path, ".foxml.xml").sub("_",":")
+        begin
+          foo = loader.reload(pid)
+          puts "Updated #{pid}"
+        rescue Errno::ECONNREFUSED => e
+          puts "Can't connect to Fedora! Are you sure jetty is running? (#{ActiveFedora::Base.connection_for_pid(pid).inspect})"
+        rescue Exception => e
+          puts("Received a Fedora error while loading #{pid}\n#{e}")
+          logger.error("Received a Fedora error while loading #{pid}\n#{e}")
+        end
+      end
+    end
+
+    desc "Remove default Hydra fixtures"
+    task :delete do
+      ENV["dir"] ||= File.join("spec", "fixtures")
+      loader = ActiveFedora::FixtureLoader.new(ENV['dir'])
+      Dir.glob("#{ENV['dir']}/*.foxml.xml").each do |fixture_path|
+        ENV["pid"] = File.basename(fixture_path, ".foxml.xml").sub("_",":")
+        Rake::Task["repo:delete"].reenable
+        Rake::Task["repo:delete"].invoke
+      end
+    end
+
+    desc "Refresh default Hydra fixtures"
+    task :refresh => [:delete, :load]
+
+  end
+end
+  

data/lib/railties/hydra_jetty.rake

@@ -0,0 +1,53 @@
+namespace :jetty do
+  desc "Apply all configs to Testing Server (relies on hydra:jetty:config tasks unless you override it)"
+  task :config do
+    Rake::Task["hydra:jetty:config"].invoke
+  end
+end
+
+namespace :hydra do
+  namespace :jetty do
+    desc "Copies the default Solr & Fedora configs into the bundled Hydra Testing Server"
+    task :config do
+      Rake::Task["hydra:jetty:config_fedora"].invoke
+      Rake::Task["hydra:jetty:config_solr"].invoke
+    end
+    
+    desc "Copies the contents of solr_conf into the Solr development-core and test-core of Testing Server"
+    task :config_solr do
+      FileList['solr_conf/conf/*'].each do |f|  
+        cp("#{f}", 'jetty/solr/development-core/conf/', :verbose => true)
+        cp("#{f}", 'jetty/solr/test-core/conf/', :verbose => true)
+      end
+    end
+
+    desc "Copies a custom fedora config for the bundled Hydra Testing Server"
+    task :config_fedora do
+      # load a custom fedora.fcfg - 
+      if defined?(Rails.root)
+        app_root = Rails.root
+      else
+        app_root = File.join(File.dirname(__FILE__),"..")
+      end
+       
+      fcfg = File.join(app_root,"fedora_conf","conf","development","fedora.fcfg")
+      if File.exists?(fcfg)
+        puts "copying over development/fedora.fcfg"
+        cp("#{fcfg}", 'jetty/fedora/default/server/config/', :verbose => true)
+      else
+        puts "#{fcfg} file not found -- skipping fedora config"
+      end
+      fcfg = File.join(app_root,"fedora_conf","conf","test","fedora.fcfg")
+      if File.exists?(fcfg)
+        puts "copying over test/fedora.fcfg"
+        cp("#{fcfg}", 'jetty/fedora/test/server/config/', :verbose => true)
+      else
+        puts "#{fcfg} file not found -- skipping fedora config"
+      end
+    end
+
+    desc "Copies the default SOLR config files and starts up the fedora instance."
+    task :load => [:config, 'jetty:start']
+
+  end
+end

data/spec/.gitignore

@@ -0,0 +1 @@
+internal

data/spec/controllers/catalog_controller_spec.rb

@@ -0,0 +1,101 @@
+require 'spec_helper'
+
+# See cucumber tests (ie. /features/edit_document.feature) for more tests, including ones that test the edit method & view
+# You can run the cucumber tests with 
+#
+# cucumber --tags @edit
+# or
+# rake cucumber
+
+describe CatalogController do
+  
+  before do
+    session[:user]='bob'
+  end
+  
+  it "should use CatalogController" do
+    controller.should be_an_instance_of(CatalogController)
+  end
+  
+  
+  describe "Paths Generated by Custom Routes:" do
+    # paths generated by custom routes
+    it "should map {:controller=>'catalog', :action=>'index'} to GET /catalog" do
+      { :get => "/catalog" }.should route_to(:controller => 'catalog', :action => 'index')
+    end
+    it "should map {:controller=>'catalog', :action=>'show', :id=>'test:3'} to GET /catalog/test:3" do
+      { :get => "/catalog/test:3" }.should route_to(:controller => 'catalog', :action => 'show', :id=>'test:3')
+    end
+    it "should map {:controller=>'catalog', :action=>'edit', :id=>'test:3'} to GET /catalog/test:3" do
+      { :get => "/catalog/test:3/edit" }.should route_to(:controller => 'catalog', :action => 'edit', :id=>'test:3')
+    end
+
+    it "should map catalog_path" do
+      # catalog_path.should == '/catalog'
+      catalog_path("test:3").should == '/catalog/test:3'
+    end
+  end
+  
+  it "should not choke on objects with periods in ids (ie Fedora system objects)" do    
+     pending "Need to override blacklight routes"	
+
+	## We could do something like this to remove the catalog/show route and replace it with a route that allows dots (e.g. resources :catalog, :id=> /.+/)
+	  # def add_route
+	  #   new_route = ActionController::Routing::Routes.builder.build(name, route_options)
+	  #   ActionController::Routing::Routes.routes.insert(0, new_route)
+	  # end
+
+	  # def remove_route
+	  #   ActionController::Routing::Routes.routes.reject! { |r| r.instance_variable_get(:@requirements)[:slug_id] == id }
+	  # end
+
+    catalog_path("fedora-system:FedoraObject-3.0").should == '/catalog/fedora-system:FedoraObject-3.0'
+    { :get => "/catalog/fedora-system:FedoraObject-3.0" }.should route_to(:controller => 'catalog', :action => 'show', :id=>'fedora-system:FedoraObject-3.0')
+  end
+  
+  describe "index" do
+    
+    describe "access controls" do
+      before(:all) do
+        @public_only_results = Blacklight.solr.find Hash[:fq=>"access_t:public"]
+        # @public_only_results = Blacklight.solr.find Hash[:phrases=>{:access_t=>"public"}]
+        # @private_only_results = Blacklight.solr.find Hash[:phrases=>{:access_t=>"private"}]
+        @private_only_results = Blacklight.solr.find Hash[:fq=>"access_t:private"]
+      end
+
+      it "should only return public documents if role does not have permissions" do
+        controller.stub(:current_user).and_return(nil)
+        get :index
+        assigns(:document_list).count.should == @public_only_results.docs.count
+      end
+      it "should return all documents if role does have permissions" do
+        pending "Need to put documents into solr"
+        mock_user =  FactoryGirl.build(:user, :email=>"BigWig@example.com")
+        mock_user.stub(:is_being_superuser?).and_return(true)
+        controller.stub(:current_user).and_return(mock_user)
+        get :index
+        ### This fails when there are more than 10 public documents in the solr index
+        ### TODO: instead, expect a certain query(especially the :fq component) to solr
+        assigns(:document_list).count.should > @public_only_results.docs.count
+      end
+    end
+  end
+  
+  describe "filters" do
+    describe "index" do
+      it "should trigger enforce_index_permissions" do
+        controller.should_receive(:add_access_controls_to_solr_params)
+        controller.should_receive(:enforce_index_permissions)
+        get :index
+      end
+    end
+    describe "show" do
+      it "should trigger enforce_show_permissions" do
+        controller.stub(:current_user).and_return(nil)
+        controller.should_receive(:enforce_show_permissions)
+        get :show, :id=>'test:3'
+      end
+    end
+  end
+  
+end