hydra-head 3.0.0pre1

data/lib/hydra/generic_content.rb

@@ -0,0 +1,113 @@
+require "hydra"
+require "httparty"
+require "mime/types"
+
+module Hydra::GenericContent
+  
+  def self.included(klass)
+   klass.send :include, Hydra::ModelMethods
+  end
+  
+  # For each value in DEFAULT_CONTENT_DATASTREAMS, instances will have 3 corresponding methods for
+  # * getting the datastream's content
+  # * setting a new file as the datastream's content
+  # * checking whether the current object has the datastream already
+  #
+  # Example: DEFAULT_CONTENT_DATASTREAMS = ['content','original']
+  # These methods will be available on the object:
+  #
+  # .has_original?, original, orginal=()
+  # .has_content?, content, content=()
+  #
+  DEFAULT_CONTENT_DATASTREAMS = ['content','original']
+  
+  DEFAULT_CONTENT_DATASTREAMS.each do |m|
+    class_eval <<-EOM
+      def has_#{m}?
+        self.datastreams.keys.include? "#{m}"
+      end
+
+      def #{m}
+        datastreams["#{m}"].content if has_#{m}?
+      end
+
+      def #{m}=(file)
+        create_or_update_datastream( "#{m}", file )
+      end
+    EOM
+  end
+    
+  private
+
+  def from_url url, ds_name
+    puts "creating datastream object for: #{url}"
+    ds = ActiveFedora::Datastream.new(:dsid=> ds_name, :label => ds_name, :controlGroup => "M", :dsLocation => url, :mimeType=>mime_type(url.split(/\//).last))
+    add_datastream(ds)
+    save
+  end
+  
+  def from_binary binary_info, ds_name
+    file =  binary_to_file(binary_info[:blob],ds_name,binary_info[:extension])
+    add_file_datastream(file,:dsid=>ds_name,:label=>ds_name)
+    save
+  end
+  
+  def binary_to_file blob, suffix, ext=nil
+    file_name = Time.now.strftime("%Y%m%d-%H%M%S")
+    f = File.new("#{Rails.root}/tmp/#{file_name}-#{suffix}.#{ext}","w")
+    f.write blob
+    f.close
+    return f
+  end
+  
+  def create_or_update_datastream ds_name, file
+    case file
+    when File
+        logger.debug "adding #{ds_name} file datastream"
+        add_file_datastream(file, :dsid => ds_name, :label => ds_name, :mimeType => mime_type(file.path))
+    when String
+        from_url(file, ds_name)
+    when Hash
+      if file.has_key? :blob
+        from_binary(file, ds_name)
+      elsif file.has_key? :file
+        add_file_datastream(file[:file], :dsid => ds_name, :label => ds_name, :mimeType => mime_type(file[:file_name]))
+      end
+    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] 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   
+  
+  # augments add_file_datastream to also put file size (in bytes/KB/MB/GB/TB) in mods:physicaldescription/mods:extent 
+  def add_file_datastream(file, opts={})
+    label = opts.has_key?(:label) ? opts[:label] : ""
+    mimeType = opts.has_key?(:mimeType) ? opts[:mimeType] : ""
+    ds = ActiveFedora::Datastream.new(:dsLabel => label, :controlGroup => 'M', :blob => file, :mimeType => mimeType)
+    opts.has_key?(:dsid) ? ds.dsid=(opts[:dsid]) : nil
+    add_datastream(ds)
+    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_in_memory["descMetadata"].update_indexed_attributes( [:physical_description, :extent] => size )
+  end
+  
+  def mime_type file_name
+    mime_types = MIME::Types.of(file_name)
+    mime_type = mime_types.empty? ? "application/octet-stream" : mime_types.first.content_type
+  end
+end

data/lib/hydra/generic_image.rb

@@ -0,0 +1,100 @@
+# Hydra::GenericImage
+#
+# Default content datastreams:
+#   Included from Hydra::GenericContent: content, original (optional)
+#   Included from Hydra::GenericImage: max, thumbnail, screen
+#
+# Sample Usages:
+#   For good sample usage, see the documentation for HydraImage.
+require "hydra"
+
+module Hydra::GenericImage
+  def self.included klass
+    klass.send(:include, Hydra::GenericContent)
+  end
+
+  class Hydra::GenericImage::NoFileError < RuntimeError; end;
+  class Hydra::GenericImage::UnknownImageType < RuntimeError; end;
+
+  DEFAULT_IMAGE_DATASTREAMS = ["max","thumbnail","screen"]
+
+  DERIVATION_DEFAULTS = {
+    :max => {:op => "convert", :convertTo => "jpg"},
+    :thumbnail => {:op => "resize",:newWidth=> 100},
+    :screen => {:op => "resize", :newWidth => 960}
+  }
+
+  attr_accessor :derivation_overrides, :generate_derived_images
+  
+  def derivation_options
+    if @derivation_overrides
+      return DERIVATION_DEFAULTS.merge( @derivation_overrides )
+    else
+      return DERIVATION_DEFAULTS
+    end
+  end
+
+  DEFAULT_IMAGE_DATASTREAMS.each do |ds_name|
+    class_eval <<-EOM
+      def has_#{ds_name}?
+        self.datastreams.keys.include? "#{ds_name}"
+      end
+
+      def #{ds_name}
+        datastreams["#{ds_name}"].content if has_#{ds_name}?
+      end
+      
+      def #{ds_name}=(file)
+        create_or_update_datastream("#{ds_name}",file)
+      end
+      
+      def derive_#{ds_name}
+        derive_datastream "#{ds_name}"
+      end
+    EOM
+  end
+  
+  def derive_all
+    DEFAULT_IMAGE_DATASTREAMS.each { |ds| self.send "derive_#{ds.to_sym}" }
+  end
+
+
+  private
+
+  def delete_derivatives
+    DEFAULT_IMAGE_DATASTREAMS.each { |ds| datastreams[ds].delete if datastreams.has_key? ds }
+  end
+  
+  def derive_datastream ds_name
+    ds_location = derivation_url(ds_name.to_sym, derivation_options[ds_name.to_sym])
+    ds = ActiveFedora::Datastream.new(:dsid => ds_name, :label => ds_name, :dsLocation => ds_location, :controlGroup => "M", :mimeType => "image/jpeg")
+    add_datastream(ds)
+    save
+  end
+
+  def derivation_url ds_name, opts={}
+    source_ds_name = ds_name == :max ? "content" : "max"
+    raise "Oops! Cannot find source datastream." unless datastreams.keys.include? source_ds_name
+    if ds_name == :max && datastreams["content"].attributes["mimeType"] == "image/jpeg"
+      url = datastream_url(source_ds_name)
+    else
+      opts_array=[]
+      opts.merge!(:url => datastream_url(source_ds_name)).each{|k,v| opts_array << "#{k}=#{v}" }
+      url = "#{admin_site}imagemanip/ImageManipulation?" + opts_array.join("&")
+    end
+    return url
+  end
+
+  def admin_site=admin_base_url
+    @admin_site = admin_base_url
+  end
+
+  def admin_site
+    @admin_site ||= Fedora::Repository.instance.send(:connection).site.to_s.gsub(/fedora$/,"")
+  end
+
+  def datastream_url ds_name="content"
+    "#{admin_site}fedora/objects/#{pid}/datastreams/#{ds_name}/content"
+  end
+
+end

data/lib/hydra/image.rb

@@ -0,0 +1,177 @@
+# Hydra::Image
+#
+# Default content datastreams: MASTER, MAX, THUMBNAIL, SCREEN
+#
+# Sample Usages:
+#
+# Generate an image and then assign an image to it:
+# hi = Hydra::Image.new(:derivatives=>true)
+# f = File.new("/path/to/image.tiff")
+# hi.image=f
+# 
+# Generate an image from a url:
+# hi = Hydra::Image.new(:file=>"http://example.com/some_image.jpg", :derivatives=>true)
+# 
+#
+# Generate an image from a file:
+# f = File.new("/path/to/image.tiff")
+# hi = Hydra::Image.new(:file=>f, :derivatives=>true)
+#
+# Generate an image with alternate resizing:
+# hi = Hydra::Image.new(:file=>file)
+# hi.derivations = {:thumbnail=> {:op => "resize", :newWidth => 75 }
+# hi.send(:generate_derivatives)
+#
+
+require "hydra"
+require "httparty"
+
+module Hydra
+class Image < ActiveFedora::Base
+  include Hydra::ModelMethods
+  include HTTParty
+
+  class Hydra::Image::NoFileError < RuntimeError; end;
+  class Hydra::Image::UnknownImageType < RuntimeError; end;
+
+  DEFAULT_IMAGE_DATASTREAMS = ["MASTER","MAX","THUMBNAIL","SCREEN"]
+
+  DS_DEFAULTS = {
+    :max => {:op => "convert", :convertTo => "jpg"},
+    :thumbnail => {:op => "resize",:newWidth=> 100},
+    :screen => {:op => "resize", :newWidth => 960}
+  }
+
+  attr_accessor :derivations, :generate_derived_images
+
+  def initialize( attrs={})
+    existing_image = true if attrs[:pid]
+    @generate_derived_images = attrs[:derivatives] ? attrs[:derivatives] : false
+    super
+    unless existing_image
+      if attrs.has_key?(:file) #&& attrs[:file].class == File
+        self.image = attrs[:file]
+        attrs.delete(:file)
+      elsif attrs.has_key?(:stream) && attrs.has_key?(:image_type)
+        data = attrs[:stream]
+        attrs.delete(:stream)
+        self.image = data, attrs[:image_type]
+      else
+        #raise Hydra::Image::NoFileError, "No file indicated."
+      end
+    end
+  end
+
+  has_relationship "parts", :is_part_of, :inbound => true
+  
+  # Uses the Hydra Rights Metadata Schema for tracking access permissions & copyright
+  has_metadata :name => "rightsMetadata", :type => Hydra::RightsMetadata 
+
+  # A place to put extra metadata values
+  has_metadata :name => "properties", :type => ActiveFedora::MetadataDatastream do |m|
+    m.field 'collection', :string
+    m.field 'depositor', :string
+  end
+
+  def image=(image_data)
+    delete_file_datastreams
+    case image_data
+      when File
+        master_from_file image_data
+      when Array
+        needs_cleanup = true
+        image_file =  string_to_file(image_data[0],"MASTER",image_data[1])
+        master_from_file image_file
+      when String
+        master_from_url image_data
+      else
+        raise Hydra::Image::UnknownImageType, "Specified image is neither a file nor an appropriate image blob: #{image_data.class.to_s}"
+    end
+    save
+    File.delete(image_file.path) if needs_cleanup
+    generate_derivatives if @generate_derived_images
+  end
+
+  def ds_options
+    if @derivations
+      return DS_DEFAULTS.merge( @derivations )
+    else
+      return DS_DEFAULTS
+    end
+  end
+
+  def derivative_datastream ds_name
+    opts = ds_options[ds_name]
+    ds_location = derivation_url(ds_name, opts)
+    ds = ActiveFedora::Datastream.new(:dsid => ds_name.to_s.upcase, :label => ds_name.to_s.upcase, :dsLocation => ds_location, :controlGroup => "M", :mimeType => "image/jpeg")
+    add_datastream(ds)
+    save
+  end
+
+  DEFAULT_IMAGE_DATASTREAMS.each do |m|
+    class_eval <<-EOM
+      def has_#{m.downcase}?
+        self.datastreams.keys.include? "#{m}"
+      end
+
+      def #{m.downcase}
+        datastreams["#{m}"].content if has_#{m.downcase}?
+      end
+    EOM
+  end
+
+  private
+
+  def master_from_file image_file
+    add_file_datastream(image_file,:dsid=>"MASTER",:label=>"MASTER")
+    
+  end
+
+  def master_from_url url
+    puts "creating datastream object for: #{url}"
+    mime_types = MIME::Types.of(url.split(/\//).last)
+    mime_type ||= mime_types.empty? ? "application/octet-stream" : mime_types.first.content_type
+    ds = ActiveFedora::Datastream.new(:dsid=> "MASTER", :label => "MASTER", :controlGroup => "M", :dsLocation => url, :mimeType=>mime_type)
+    add_datastream(ds)
+    save
+  end
+
+  def generate_derivatives
+    DEFAULT_IMAGE_DATASTREAMS.each {|ds| derivative_datastream ds.downcase.to_sym unless ds == "MASTER"}
+  end
+
+  def delete_file_datastreams
+    DEFAULT_IMAGE_DATASTREAMS.each {|ds_name| datastreams[ds_name].delete if datastreams.has_key? ds_name}
+  end
+
+  def derivation_url ds_name, opts={}
+    source_ds_name = ds_name == :max ? "MASTER" : "MAX"
+    if ds_name == :max && datastreams["MASTER"].attributes["mimeType"] == "image/jpeg"
+      url = datastream_url(source_ds_name)
+    else
+      opts_array=[]
+      opts.merge!(:url => datastream_url(source_ds_name)).each{|k,v| opts_array << "#{k}=#{v}" }
+      url = "#{admin_site}imagemanip/ImageManipulation?" + opts_array.join("&")
+    end
+    return url
+  end
+
+  def admin_site
+    Fedora::Repository.instance.send(:connection).site.to_s.gsub(/fedora$/,"")
+  end
+
+  def string_to_file blob, suffix, ext=nil
+    file_name = Time.now.strftime("%Y%m%d-%H%M%S")
+    ext = "jpg" unless suffix == "MASTER"
+    f = File.new("#{Rails.root}/tmp/#{file_name}-#{suffix}.#{ext}","w")
+    f.write blob
+    f.close
+    return f
+  end
+
+  def datastream_url ds_name="MASTER"
+    "#{admin_site}fedora/objects/#{pid}/datastreams/#{ds_name}/content"
+  end
+
+end
+end

data/lib/hydra/model_methods.rb

@@ -0,0 +1,95 @@
+module Hydra::ModelMethods
+  #
+  # Adds metadata about the depositor to the asset
+  #
+  def apply_depositor_metadata(depositor_id)
+    prop_ds = self.datastreams_in_memory["properties"]
+    rights_ds = self.datastreams_in_memory["rightsMetadata"]
+  
+    if !prop_ds.nil? && prop_ds.respond_to?(:depositor_values)
+      prop_ds.depositor_values = depositor_id unless prop_ds.nil?
+    end
+    rights_ds.update_indexed_attributes([:edit_access, :person]=>depositor_id) 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_in_memory["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.kind_of?(ActiveFedora::NokogiriDatastream)
+        if desc_metadata_ds.class.terminology.has_term?(:title)
+          desc_metadata_ds.update_values([:title]=>new_title)
+        end
+      elsif desc_metadata_ds.respond_to?(:title_values)
+        desc_metadata_ds.title_values = new_title
+      end
+    end
+  end
+
+  # Call insert_contributor on the descMetadata datastream
+  def insert_contributor(type, opts={})
+    ds = self.datastreams_in_memory["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_in_memory["descMetadata"]
+    result = ds.remove_contributor(type,index)
+    return result
+  end
+  
+  # Call to remove file obects
+  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.file_objects
+    self.file_objects.each.inject([]) do |file_assets, fo|
+      if fo.relationships[:self].has_key?(:is_part_of) && fo.relationships[:self][:is_part_of].length == 1 && fo.relationships[:self][:is_part_of][0].match(/#{self.pid}$/)
+        file_assets << fo
+      end
+      file_assets
+    end
+  end
+end