hydra-head 3.1.0.pre5 → 3.1.0.rc1

data/app/helpers/hydra/hydra_uploader_helper_behavior.rb

@@ -0,0 +1,18 @@
+module Hydra::HydraUploaderHelperBehavior
+  
+  # Generate the appropriate url for posting uploads to
+  # Uses the +container_id+ method to figure out what container uploads should go into
+  def upload_url
+    upload_url = asset_file_assets_path(:asset_id=>container_id)
+  end
+  
+  # The id of the container that uploads should be posted into
+  # If params[:container_id] is not set, it uses params[:id] (assumes that you're uploading items into the current object)
+  def container_id
+    if !params[:asset_id].nil?
+      return params[:asset_id]
+    else
+      return params[:id]
+    end
+  end
+end

data/app/helpers/hydra/inline_editable_metadata_helper_behavior.rb

@@ -0,0 +1,15 @@
+module Hydra::InlineEditableMetadataHelperBehavior
+  
+  def inline_editable_text_field(object_name, method, options = {})
+  end
+  
+  def inline_editable_text_area(object_name, method, options = {})
+  end
+  
+  def inline_editable_select(object_name, method, options = {})
+  end
+  
+  def inline_editable_checkbox(object_name, method, options = {})
+  end
+  
+end

data/app/helpers/hydra/javascript_includes_helper_behavior.rb

@@ -0,0 +1,91 @@
+# Use this helper to declare which javascript should be loaded in which views
+# Internally, it relies on include_javascript_for_#{controller}_#{action} helper methods 
+# These helper methods will usually append their includes to the controller's javascript_includes array
+#
+# @example Within your views (or in your controllers), call the helper like this
+#   include_javascript_for "hydrangea_articles", "edit"
+#
+# To declare your own array of includes for a specific content type or action, define a helper method in your host application or plugin like this
+# @example Declaring the javascript includes for hydrangea_datasets show view while reusing the includes from catalog_edit
+#   def include_javascript_for_hydrangea_datasets_show
+#     include_javascript_for_catalog_edit
+#     javascript_includes << ['hydrangeaArticleBehaviors.js', {:plugin=>:hydrangea_articles}]
+#   end
+module Hydra::JavascriptIncludesHelperBehavior
+  
+  # Add the appropriate javascripts for the specified content type & action into the Controller's javascript_includes array
+  # If you have defined custom javascript includes for that content_type & action, they will be used.
+  # @param [String or Symbol] content_type
+  # @param [String or Symbol] action
+  # @example This will rely on the include_javascript_for_hydranea_articles_edit helper method if it's defined.  Defaults to calling include_default_javascript("edit")
+  #   include_javascript_for "hydrangea_articles", "edit" 
+  def include_javascript_for(content_type, action, opts={})
+    begin
+      method_name = "include_javascript_for_#{content_type.to_s}_#{action.to_s}"
+      logger.debug "attempting to include #{method_name}"
+      self.send(method_name.to_sym)
+    rescue
+      logger.debug "... no specific includes defined for #{content_type.to_s}.  Using defaults for #{action.to_s} views"
+      include_default_javascript( action )
+    end
+  end
+  
+  # Add the default javascript to the controller's javascript_includes
+  # Takes a method argument (ie. show or edit) to decide which defaults to use.
+  # Currently configured to use the javascript includes for catalog show / edit.
+  # @param [String or Symbol] method Currently only "show" and "edit" have defaults set
+  def include_default_javascript(method)
+    case method.to_s
+    when "show"
+      include_javascript_for_catalog_show
+    when "edit"
+      include_javascript_for_catalog_edit
+    else
+      logger.debug "No default javascript includes defined for #{method} views.  Doing nothing."
+    end
+  end
+  
+  #
+  #   Helpers for Catalog Show & Edit Javascript Includes
+  #
+  
+  # Adds the appropriate javascripts to javascript_includes for CatalogController show views
+  # Override this if you want to change the set of javascript_includes for CatalogController show views
+  def include_javascript_for_catalog_show
+    javascript_includes << ['custom', {:plugin=>"hydra-head"}] 
+    
+    # This file contains the page initialization scripts for catalog show views
+    javascript_includes << ["catalog/show", {:plugin=>"hydra-head"}]
+  end
+  
+  # Adds the appropriate javascripts to javascript_includes for CatalogController edit views
+  # Override this if you want to change the set of javascript_includes for CatalogController edit views
+  def include_javascript_for_catalog_edit
+    # This _would_ include the fluid infusion javascripts, but we don't want them
+    # javascript_includes << infusion_javascripts(:default_no_jquery, :extras=>[:inline_editor_integrations], :debug=>true, :render_html=>false)
+    
+    javascript_includes << ["jquery.jeditable.mini.js", {:plugin=>"hydra-head"}]
+    javascript_includes << ["jquery.form.js", {:plugin=>"hydra-head"}]
+    javascript_includes << ['custom', {:plugin=>"hydra-head"}]
+    
+    javascript_includes << ["jquery.hydraMetadata.js", {:plugin=>"hydra-head"}]
+    javascript_includes << ["jquery.notice.js", {:plugin=>"hydra-head"}]
+    
+    javascript_includes << ["jquery.jeditable.mini.js", "date-picker/js/datepicker", "jquery.form.js", 'custom', "catalog/edit", "jquery.hydraMetadata.js", "jquery.notice.js", {:plugin=>"hydra-head"}]
+    # For DatePicker
+    javascript_includes << ["jquery.ui.widget.js","jquery.ui.datepicker.js", "mediashelf.datepicker.js", {:plugin=>"hydra-head" }]
+    
+    # For Fancybox
+    javascript_includes << ["fancybox/jquery.fancybox-1.3.1.pack.js", {:plugin=>"hydra-head"}] 
+    stylesheet_links << ["/javascripts/fancybox/jquery.fancybox-1.3.1.css", {:plugin=>"hydra-head"}] 
+
+    # For slider controls 
+    javascript_includes << ["select_to_ui_slider/selectToUISlider.jQuery.js", {:plugin=>"hydra-head"}] 
+    stylesheet_links << ["/javascripts/select_to_ui_slider/css/ui.slider.extras.css", {:plugin=>"hydra-head"}] 
+    stylesheet_links << ["slider", {:plugin=>"hydra-head"}] 
+    
+    # This file contains the page initialization scripts for catalog edit views
+    javascript_includes << ["catalog/edit", {:plugin=>"hydra-head"}]
+  end
+  
+end

data/app/helpers/hydra/personalization_helper_behavior.rb

@@ -0,0 +1,44 @@
+module Hydra::PersonalizationHelperBehavior
+
+  DEFAULT_USER_ATTRIBUTES = ['full_name', 'affiliation', 'photo']
+
+  # Helper methods to retrieve information from the user attributes
+  # 
+  # == get_full_name_from_login
+  #
+  # Given a login, returns a string concatenating first_name and last_name
+  #
+  # == get_affiliation_from_login 
+  #
+  # Given a login, returns a string
+  #
+  # == get_photo_from_login
+  #
+  # Given a login, returns a string representing either a path or a url pointing to an image file
+  DEFAULT_USER_ATTRIBUTES.each do |m|
+    class_eval <<-EOC
+      def #{m}_from_login login
+        get_user_attribute(login, '#{m}')
+      end
+    EOC
+  end
+
+  # Creates an image tag with the user#photo attribute as the source
+  # @param [string] login the login of the user
+  # @return an html image tag or an empty string
+  def user_photo_tag login
+    path = photo_from_login login
+    path == "" ? "" : image_tag(path)
+  end
+
+  private
+
+  # Retrieves an attribute from the user
+  # @param [string] login the login of the user
+  # @param [string] the name of the attribute: out of the box values are first_name, last_name, full_name, affiliation, and photo
+  def get_user_attribute login, attribute
+    user = User.find_by_login(login) 
+    user.nil? ? "" : user.send(attribute.to_sym)
+  end
+
+end

data/app/helpers/hydra/release_process_helper_behavior.rb

@@ -0,0 +1,32 @@
+module Hydra::ReleaseProcessHelperBehavior
+  
+  def display_release_status_notice(document)
+    readiness = document.test_release_readiness
+    if readiness == true
+      flash[:notice] ||= []
+      if document.submitted_for_release?
+        flash[:notice] << "This item has been released for library circulation."
+      else
+        flash[:notice] << "This item is ready to be released for library circulation."
+      end
+    else
+      flash[:error] ||= []
+      flash[:error] = flash[:error] | readiness[:failures]
+    end
+  end
+
+  def check_embargo_date_format
+    if params.keys.include? [:embargo, :embargo_release_date]
+      em_date = params[[:embargo, :embargo_release_date]]["0"]
+      unless em_date.blank?
+        begin 
+          !Date.parse(em_date)
+        rescue
+          params[[:embargo,:embargo_release_date]]["0"] = ""
+          raise "Unacceptable date format"
+        end
+      end
+    end
+  end  
+  
+end

data/app/helpers/hydra_assets_helper.rb

@@ -1,66 +1,4 @@
-require 'mediashelf/active_fedora_helper'
-require 'sanitize'
 module HydraAssetsHelper
-  include MediaShelf::ActiveFedoraHelper
-
-  # Create a link for creating a new asset of the specified content_type
-  # If user is not logged in, the link leads to the login page with appropriate redirect params for creating the asset after logging in
-  # @param [String] link_label for the link
-  # @param [String] content_type 
-  def link_to_create_asset(link_label, content_type)
-    if current_user
-      link_to link_label, {:action => 'new', :controller => 'assets', :content_type => content_type}, :class=>"create_asset"
-    else      
-      link_to link_label, new_user_session_path(:redirect_params => {:action => "new", :controller=> "assets", :content_type => content_type}), :class=>"create_asset"
-    end
-  end
-  
-  # Render a link to delete the given asset from the repository.
-  # Includes a confirmation message. 
-  def delete_asset_link(pid, asset_type_display="asset")
-    "<a href=\"#{ url_for(:action=>:delete, :controller=>:catalog, :id=>pid)}\" class=\"delete_asset_link\" >Delete this #{asset_type_display}</a>".html_safe
-  end
-
-  def document_type(document)
-    if (document[Blacklight.config[:show][:display_type]]) 
-      document[Blacklight.config[:show][:display_type]].first.gsub("info:fedora/afmodel:","")
-    else ""
-    end
-  end
-
-  def get_person_from_role(doc,role,opts={})  
-    i = 0
-    while i < 10
-      persons_roles = doc["person_#{i}_role_t"].map{|w|w.strip.downcase} unless doc["person_#{i}_role_t"].nil?
-      if persons_roles and persons_roles.include?(role.downcase)
-        return {:first=>doc["person_#{i}_first_name_t"], :last=>doc["person_#{i}_last_name_t"]}
-      end
-      i += 1
-    end
-  end
-
-  def get_file_asset_count(document)
-    count = 0
-    obj = load_af_instance_from_solr(document)
-    count += obj.file_objects.length unless obj.nil?
-    count
-  end
-  
-  def get_file_asset_description(document)
-    obj = load_af_instance_from_solr(document)
-    if obj.nil? || obj.file_objects.empty?
-      return ""
-    else
-       fobj = FileAsset.load_instance_from_solr(obj.file_objects.first.pid)
-       fobj.nil? ? "" : short_description(fobj.datastreams["descMetadata"].get_values("description").first)
-    end
-  end
-
-  def short_description(desc,max=150)
-    if desc.length > max
-      desc = desc[0..max].concat("...")
-    end
-    short_description = desc.capitalize
-  end
-  
+  include Hydra::HydraAssetsHelperBehavior
 end
+

data/app/helpers/hydra_djatoka_helper.rb

@@ -1,23 +1,4 @@
 module HydraDjatokaHelper
-  
-  def hydra_djatoka_url_for(document, opts={})
-    
-    if document.kind_of?(SolrDocument)
-      pid = document.id
-    elsif document.kind_of?(Mash) 
-      pid = document[:id]
-    elsif document.respond_to?(:pid)
-        pid = document.pid
-    end
-    
-    if !pid.nil?
-      if opts[:scale]
-        result = url_for(:controller=>:get,:action=>"show",:id=>pid, :format=>"jp2", "image_server[scale]"=>opts[:scale])
-      else
-        result = url_for(:controller=>:get,:action=>"show",:id=>pid, :format=>"jp2", "image_server"=>true)
-      end
-    end
-      
-  end
-  
-end
+  include Hydra::HydraDjatokaHelperBehavior
+end
+

data/app/helpers/hydra_fedora_metadata_helper.rb

@@ -1,349 +1,4 @@
-require "inline_editable_metadata_helper"
-require "block_helpers"
-require "active_support"
-require "redcloth" # Provides textile parsing support for textile_area method
-
 module HydraFedoraMetadataHelper
-  
-  def fedora_text_field(resource, datastream_name, field_key, opts={})
-    field_name = field_name_for(field_key)
-    field_values = get_values_from_datastream(resource, datastream_name, field_key, opts)
-    field_values = [""] if field_values.empty?
-    field_values = [field_values.first] unless opts.fetch(:multiple, true)
-    
-    required = opts.fetch(:required, true) ? "required" : ""
-
-    body = ""
-    
-    field_values.each_with_index do |current_value, z|
-      base_id = generate_base_id(field_name, current_value, field_values, opts)
-      name = "asset[#{datastream_name}][#{field_name}][#{z}]"
-        body << "<input class=\"editable-edit edit\" id=\"#{base_id}\" data-datastream-name=\"#{datastream_name}\" name=\"#{name}\" value=\"#{h(current_value.strip)}\" #{required} type=\"text\" />"
-        body << "<a href=\"\" title=\"Delete '#{h(current_value)}'\" class=\"destructive field\">Delete</a>" if opts.fetch(:multiple, true) && !current_value.empty?
-    end
-    
-    result = field_selectors_for(datastream_name, field_key)
-    result << body
-    
-    return result.html_safe
-  end
-  
-  def fedora_text_area(resource, datastream_name, field_key, opts={})
-    fedora_textile_text_area(resource, datastream_name, field_key, opts)
-  end
-  
-  # Textile textarea varies from the other methods in a few ways
-  # Since we're using jeditable with this instead of fluid, we need to provide slightly different hooks for the javascript
-  # * we are storing the datastream name in data-datastream-name so that we can construct a load url on the fly when initializing the textarea
-  def fedora_textile_text_area(resource, datastream_name, field_key, opts={})
-    field_name = field_name_for(field_key)
-    field_values = get_values_from_datastream(resource, datastream_name, field_key, opts)
-    field_values = [""] if field_values.empty?
-    if opts.fetch(:multiple, true)
-      container_tag_type = :li
-    else
-      field_values = [field_values.first]
-      container_tag_type = :span
-    end
-    body = ""
-    
-    field_values.each_with_index do |current_value, z|
-      base_id = generate_base_id(field_name, current_value, field_values, opts)
-      name = "asset[#{datastream_name}][#{field_name}][#{z}]"
-      processed_field_value = Sanitize.clean( RedCloth.new(current_value, [:sanitize_html]).to_html, Sanitize::Config::BASIC)
-        body << "<textarea class=\"editable-edit edit\" id=\"#{base_id}\" data-datastream-name=\"#{datastream_name}\" name=\"#{name}\" rows=\"10\" cols=\"25\">#{h(current_value.strip)}</textarea>"
-        body << "<a href=\"\" title=\"Delete '#{h(current_value)}'\" class=\"destructive field\">Delete</a>" unless z == 0
-    end
-    
-    result = field_selectors_for(datastream_name, field_key)
-    result << body
-
-    return result.html_safe
-    
-  end
-  
-  # Expects :choices option.  Option tags for the select are generated from the :choices option using Rails "options_for_select":http://apidock.com/rails/ActionView/Helpers/FormOptionsHelper/options_for_select helper
-  # If no :choices option is provided, returns a regular fedora_text_field
-  def fedora_select(resource, datastream_name, field_key, opts={})
-    if opts[:choices].nil?
-      result = fedora_text_field(resource, datastream_name, field_key, opts)
-    else
-      choices = opts[:choices]
-      field_name = field_name_for(field_key)
-      field_values = get_values_from_datastream(resource, datastream_name, field_key, opts)
-      
-      body = ""
-      z = 0
-      base_id = generate_base_id(field_name, field_values.first, field_values, opts.merge({:multiple=>false}))
-      name = "asset[#{datastream_name}][#{field_name}][#{z}]"
-
-      body << "<select name=\"#{name}\" class=\"metadata-dd select-edit\" id=\"#{field_name}\">"
-        body << options_for_select(choices, field_values)
-      body << "</select>"
-      
-      result = field_selectors_for(datastream_name, field_key)
-      result << body
-    end
-    return result.html_safe
-  end
-  
-  def fedora_date_select(resource, datastream_name, field_key, opts={})
-    field_name = field_name_for(field_key)
-    field_values = get_values_from_datastream(resource, datastream_name, field_key, opts)
-    base_id = generate_base_id(field_name, field_values.first, field_values, opts.merge({:multiple=>false}))
-    name = "asset[#{datastream_name}][#{base_id}]"
-    
-    value = field_values.first
-    field_value = value.nil? ? "" : value
-        
-    field_value[/(\d+)-(\d+)-(\d+)/]
-    year = ($1.nil? or $1.empty?) ? "" : $1.to_i
-    month = ($2.nil? or $2.empty?) ? "-1" : $2
-    day = ($3.nil? or $3.empty?) ? "-1" : $3
-    
-    # Make sure that month and day values are double-digit
-    [month, day].each {|v| v.length == 1 ? v.insert(0, "0") : nil }
-    
-    
-    year_options = Array.new(101) {|i| 1910+i}
-    # year_options = Array.new(4) {|i| 1990+i}
-    
-    year_options.insert(0, ["Year", "-1"])
-    
-    body = ""
-    body << "<div class=\"date-select\" name=\"#{name}\">"
-      body << "<input class=\"controlled-date-part w4em\" style=\"width:4em;\" type=\"text\" id=\"#{base_id}-sel-y\" name=\"#{base_id}-sel-y\" maxlength=\"4\" value=\"#{year}\" />"    
-      body << "<select class=\"controlled-date-part\" id=\"#{base_id}-sel-mm\" name=\"#{base_id}-sel-mm\">"
-        body << options_for_select([["Month","-1"],["January", "01"],["February", "02"],["March", "03"],
-                                      ["April", "04"],["May", "05"],["June", "06"],["July", "07"],["August", "08"],
-                                      ["September", "09"],["October", "10"],["November", "11"],["December", "12"]
-                                      ], month)
-      body << "</select> / "
-      body << "<select class=\"controlled-date-part\" id=\"#{base_id}-sel-dd\" name=\"#{base_id}-sel-dd\">"
-        body << options_for_select([["Day","-1"],"01", "02", "03", "04", "05", "06", "07", "08", "09", "10", "11", "12", "13", "14", "15", "16", "17", "18", "19", "20", "21", "22", "23", "24", "25", "26", "27", "28", "29", "30", "31"], day)
-      body << "</select>"
-    body << "</div>"
-    body << <<-EOF
-    <script type="text/javascript">
-    // <![CDATA[  
-      // since the form element ids need to be generated on the server side for the options, the options are attached to the wrapping div via the jQuery data() method.
-      $('div.date-select[name="#{name}"]').data("opts", {                            
-        formElements:{"#{base_id}-sel-dd":"d","#{base_id}-sel-y":"Y","#{base_id}-sel-mm":"m"}         
-      });          
-    // ]]>
-    </script>
-    EOF
-    
-    result = field_selectors_for(datastream_name, field_key)
-    result << body
-    return result.html_safe
-  end
-
-  def fedora_submit(resource, datastream_name, field_key, opts={})
-    result = ""
-    h_name = OM::XML::Terminology.term_hierarchical_name(*field_key)    
-    field_key.each do |pointer|
-      result << tag(:input, :type=>"submit", :name=>"field_selectors[#{datastream_name}][#{h_name}]", :value => field_key.to_s.capitalize)
-    end
-    return result.html_safe
-  end
-  
-  def fedora_checkbox(resource, datastream_name, field_key, opts={})
-    result = ""
-    field_values = get_values_from_datastream(resource, datastream_name, field_key, opts)
-    h_name = OM::XML::Terminology.term_hierarchical_name(*field_key)    
-    
-    v_name = field_key.last.to_s
-
-    checked = field_values.first.downcase == "yes" ? "checked" : ""
-    
-    result = field_selectors_for(datastream_name, field_key)
-    
-    # adding so that customized checked and unchecked values can be passed in
-    checked_value = (opts[:default_values] && opts[:default_values][:checked]) ? opts[:default_values][:checked] : "yes"
-    unchecked_value = (opts[:default_values] && opts[:default_values][:unchecked]) ? opts[:default_values][:unchecked] : "no"
-
-    result << tag(:input, :type=>"hidden", :id=>"#{h_name}_checked_value", :value=>checked_value )
-    result << tag(:input, :type=>"hidden", :id=>"#{h_name}_unchecked_value", :value=>unchecked_value )
-    
-    if field_values.first.downcase == "yes"
-      result << tag(:input, :type=>"checkbox", :id=>h_name, :class=>"fedora-checkbox", :name=>"asset[#{datastream_name}][#{h_name}][0]", :value=>checked_value, :checked=>"checked")
-    else
-      result << tag(:input, :type=>"checkbox", :id=>h_name, :class=>"fedora-checkbox", :name=>"asset[#{datastream_name}][#{h_name}][0]", :value=>unchecked_value)
-    end
-    return result.html_safe
-  end
-  
-  # Expects :choices option. 
-  # :choices should be a hash with value/label pairs
-  # :choices => {"first_choice"=>"Apple", "second_choice"=>"Pear" }
-  # If no :choices option is provided, returns a regular fedora_text_field
-  def fedora_radio_button(resource, datastream_name, field_key, opts={})
-    if opts[:choices].nil?
-      result = fedora_text_field(resource, datastream_name, field_key, opts)
-    else
-      choices = opts[:choices]
-      
-      field_name = field_name_for(field_key)
-      field_values = get_values_from_datastream(resource, datastream_name, field_key, opts)
-      h_name = OM::XML::Terminology.term_hierarchical_name(*field_key)    
-      default_value = opts.keys.include?(:default_value) ? opts[:default_value] : ""
-      
-      selected_value = field_values.empty? ? "" : field_values.first
-      selected_value = default_value if selected_value.blank?
-
-      body = ""
-      z = 0
-      base_id = generate_base_id(field_name, field_values.first, field_values, opts.merge({:multiple=>false}))
-      name = "asset[#{datastream_name}][#{field_name}][#{z}]"
-      
-      result = field_selectors_for(datastream_name, field_key)
-      choices.sort.each do |choice,label|
-        if choice == selected_value
-          result << tag(:input, :type=>"radio", :id=>"availability_#{choice}", :class=>"fedora-radio-button", :name=>"asset[#{datastream_name}][#{h_name}][0]", :value=>choice.downcase, :checked=>true)
-        else
-          result << tag(:input, :type=>"radio", :id=>"availability_#{choice}", :class=>"fedora-radio-button", :name=>"asset[#{datastream_name}][#{h_name}][0]", :value=>choice.downcase)
-        end
-        result << " <label>#{label}</label> "
-      end
-      result
-    end
-    return result.html_safe
-  end
-  
-  
-  def fedora_text_field_insert_link(datastream_name, field_key, opts={})
-    field_name = field_name_for(field_key) || field_key
-    field_type = field_name == "person" ? "person" : "textfield"    
-    link_text = "Add #{(opts[:label] || field_key.last || field_key).to_s.camelize.titlecase}"
-    result = "<a class='addval #{field_type}' href='#' data-datastream-name=\"#{datastream_name}\" title='#{link_text}'>#{link_text}</a>"
-    return result.html_safe
-  end
-  
-  def fedora_text_area_insert_link(datastream_name, field_key, opts={})
-    field_name = field_name_for(field_key)
-    link_text = "Add #{(opts[:label] || field_key.last || field_key).to_s.camelize.titlecase}"
-    result = "<a class='addval textarea' href='#' data-datastream-name=\"#{datastream_name}\" title='#{link_text}'>#{link_text}</a>"    
-    return result.html_safe
-  end
-  
-  def fedora_field_label(datastream_name, field_key, label=nil)
-    field_name = field_name_for(field_key)
-    if label.nil?
-      label = field_name
-    end
-    if params and params[:action] == "show"
-      return content_tag(:span, label).html_safe
-    else
-      return content_tag("label", label, :for=>field_name).html_safe
-    end
-  end
-  
-  # Generate hidden inputs to handle mapping field names to server-side metadata mappings
-  # this allows us to round-trip OM metadata mappings
-  # also (importantly) allows us to avoid executing xpath queries from http requests.
-  # *Note*: It's important that you serialize these inputs in order from top to bottom (standard HTML form behavior)
-  def field_selectors_for(datastream_name, field_key)
-    result = ""
-    if field_key.kind_of?(Array)
-      h_name = OM::XML::Terminology.term_hierarchical_name(*field_key)
-      field_key.each do |pointer|
-        if pointer.kind_of?(Hash)
-          k = pointer.keys.first
-          v = pointer.values.first
-
-          result << tag(:input, :type=>"hidden", :class=>"fieldselector", :name=>"field_selectors[#{datastream_name}][#{h_name}][][#{k}]", :value=>v)
-        else
-          result << tag(:input, :type=>"hidden", :class=>"fieldselector", :name=>"field_selectors[#{datastream_name}][#{h_name}][]", :value=>pointer.to_s)
-        end
-      end
-    end
-    return result
-  end
-  
-  # hydra_form_for block helper 
-  # allows you to construct an entire hydra form by passing a block into this method
-  class HydraFormFor < BlockHelpers::Base
-
-    def initialize(resource, opts={})
-      @resource = resource
-    end
-    
-    def fedora_label(datastream_name, field_key, opts={})
-      helper.fedora_label(@resource, datastream_name, field_key, opts)
-    end
-    
-    def fedora_text_field(datastream_name, field_key, opts={})
-      helper.fedora_label(@resource, datastream_name, field_key, opts)
-    end
-
-    def fedora_text_area(datastream_name, field_key, opts={})
-      helper.fedora_text_area(@resource, datastream_name, field_key, opts)
-    end
-    
-    def fedora_select(datastream_name, field_key, opts={})
-      helper.fedora_select(@resource, datastream_name, field_key, opts)
-    end
-
-    def fedora_submit(datastream_name, field_key, opts={})
-      helper.fedora_submit(@resource, datastream_name, field_key, opts)
-    end
-    
-    def fedora_checkbox(datastream_name, field_key, opts={})
-      helper.fedora_checkbox(@resource, datastream_name, field_key, opts)
-    end
-    
-    def fedora_radio_button(datastream_name, field_key, opts={})
-      helper.fedora_radio_button(@resource, datastream_name, field_key, opts)
-    end    
-    
-    def fedora_text_field_insert_link(datastream_name, field_key, opts={})
-      helper.fedora_text_field_insert_link(@resource, datastream_name, field_key, opts={})
-    end
-    
-    def fedora_field_label(datastream_name, field_key, opts={})
-      helper.fedora_field_label(@resource, datastream_name, field_key, opts)
-    end
-
-    def display(body)
-      inner_html = content_tag :input, :type=>"hidden", :name=>"content_type", :value=>@resource.class.to_s.underscore
-      inner_html = inner_html << body
-      content_tag :form, inner_html
-    end
-
-  end
-  
-  #
-  # Internal helper methods
-  #
-  
-  # retrieve field values from datastream.
-  # If :values is provided, skips accessing the datastream and returns the contents of :values instead.
-  def get_values_from_datastream(resource, datastream_name, field_key, opts={})
-    if opts.has_key?(:values)
-      values = opts[:values]
-      if values.nil? then values = [opts.fetch(:default, "")] end
-    else
-      values = resource.get_values_from_datastream(datastream_name, field_key, opts.fetch(:default, ""))
-      if values.empty? then values = [ opts.fetch(:default, "") ] end
-    end
-    return values
-  end
-  
-  def field_name_for(field_key)
-    if field_key.kind_of?(Array)
-      return OM::XML::Terminology.term_hierarchical_name(*field_key)
-    else
-      field_key.to_s
-    end
-  end
-  
-  def generate_base_id(field_name, current_value, values, opts)
-    if opts.fetch(:multiple, true)
-      return field_name+"_"+values.index(current_value).to_s
-    else
-      return field_name
-    end
-  end
-  
+  include Hydra::HydraFedoraMetadataHelperBehavior
 end
+