Module: Blacklight::HierarchyHelper

Defined in:
app/helpers/blacklight/hierarchy_helper.rb

Defined Under Namespace

Classes: HierarchicalFacetItem

Instance Method Summary collapse

Instance Method Details

#facet_after(prefix, order) ⇒ Object 



118
119
120
121
 
# File 'app/helpers/blacklight/hierarchy_helper.rb', line 118

def facet_after(prefix, order)
  orders = blacklight_config.facet_display[:hierarchy][prefix]
  orders[orders.index(order) + 1] || orders.first
end

#facet_order(prefix) ⇒ Object 



113
114
115
116
 
# File 'app/helpers/blacklight/hierarchy_helper.rb', line 113

def facet_order(prefix)
  param_name = "#{prefix}_facet_order".to_sym
  params[param_name] || blacklight_config.facet_display[:hierarchy][prefix].first
end

#facet_tree(hkey) ⇒ Object

then possible hkey values would be ‘wf’, ‘callnum_top’, and ‘exploded_tag’.

the key in the :hierarchy hash is the “prefix” for the solr field with the hierarchy info. the value

in the hash is a list, where the first element is a list of suffixes, and the second element is the delimiter
used to break up the sections of hierarchical data in the solr field being read.  when joined, the prefix and
suffix should form the field name.  so, for example, 'wf_wps', 'wf_wsp', 'wf_swp', 'callnum_top_facet', and
'exploded_tag_ssim' would be the solr fields with blacklight-hierarchy related configuration according to the
hash above.  ':' would be the delimiter used in all of those fields except for 'callnum_top_facet', which would
use '/'.  exploded_tag_ssim might contain values like ['Book', 'Book : Multi-Volume Work'], and callnum_top_facet
might contain values like ['LB', 'LB/2395', 'LB/2395/.C65', 'LB/2395/.C65/1991'].

note: the suffixes (e.g. ‘ssim’ for ‘exploded_tag’ in the above example) can’t have underscores, otherwise things break.

Parameters:

  • hkey (String) —

    • a key to access the rest of the hierarchy tree, as defined in controller config.facet_display declaration.

    e.g. if you had this in controller:

    config.facet_display = {
  :hierarchy => {
    'wf' => [['wps','wsp','swp'], ':'],
    'callnum_top' => [['facet'], '/'],
    'exploded_tag' => [['ssim'], ':']
 }

    }



80
81
82
83
84
85
86
87
88
89
90
91
92
93
94
95
96
97
98
99
100
101
 
# File 'app/helpers/blacklight/hierarchy_helper.rb', line 80

def facet_tree(hkey)
  @facet_tree ||= {}
  return @facet_tree[hkey] unless @facet_tree[hkey].nil?
  return @facet_tree[hkey] unless blacklight_config.facet_display[:hierarchy] && blacklight_config.facet_display[:hierarchy][hkey]
  @facet_tree[hkey] = {}
  facet_config = blacklight_config.facet_display[:hierarchy][hkey]
  split_regex = Regexp.new("\s*#{Regexp.escape(facet_config.length >= 2 ? facet_config[1] : ':')}\s*")
  facet_config.first.each do |key|
    # TODO: remove baked in notion of underscores being part of the blacklight facet field names
    facet_field = [hkey, key].compact.join('_')
    @facet_tree[hkey][facet_field] ||= {}
    data = @response.aggregations[facet_field]
    next if data.nil?
    data.items.each do |facet_item|
      path = facet_item.value.split(split_regex)
      loc = @facet_tree[hkey][facet_field]
      loc = loc[path.shift] ||= {} while path.length > 0
      loc[:_] = HierarchicalFacetItem.new(facet_item.value, facet_item.value.split(split_regex).last, facet_item.hits)
    end
  end
  @facet_tree[hkey]
end

#hide_facet?(field_name) ⇒ Boolean

FIXME: remove baked in underscore separator in field name

Returns:

  • (Boolean) 


124
125
126
127
128
 
# File 'app/helpers/blacklight/hierarchy_helper.rb', line 124

def hide_facet?(field_name)
  return false unless is_hierarchical?(field_name)
  prefix = field_name.split(/_/).first
  field_name != "#{prefix}_#{facet_order(prefix)}"
end

#is_hierarchical?(field_name) ⇒ Boolean

FIXME: remove baked in underscore separator in field name

Returns:

  • (Boolean) 


108
109
110
111
 
# File 'app/helpers/blacklight/hierarchy_helper.rb', line 108

def is_hierarchical?(field_name)
  (prefix, order) = field_name.split(/_/, 2)
  (list = blacklight_config.facet_display[:hierarchy][prefix]) && list.include?(order)
end

#render_facet_hierarchy_item(field_name, data, key) ⇒ Object

Putting bare HTML strings in a helper sucks. But in this case, with a lot of recursive tree-walking going on, it’s an order of magnitude faster than either render(:partial) or content_tag



5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
 
# File 'app/helpers/blacklight/hierarchy_helper.rb', line 5

def render_facet_hierarchy_item(field_name, data, key)
  item = data[:_]
  subset = data.reject { |k, _v| !k.is_a?(String) }

  li_class = subset.empty? ? 'h-leaf' : 'h-node'
  ul = ''
  li = if item.nil?
         key
       elsif facet_in_params?(field_name, item.qvalue)
         render_selected_qfacet_value(field_name, item)
       else
         render_qfacet_value(field_name, item)
       end

  unless subset.empty?
    subul = subset.keys.sort.collect do |subkey|
      render_facet_hierarchy_item(field_name, subset[subkey], subkey)
    end.join('')
    ul = "<ul>#{subul}</ul>".html_safe
  end

  %(<li class="#{li_class}">#{li.html_safe}#{ul.html_safe}</li>).html_safe
end

#render_facet_rotate(field_name) ⇒ Object

FIXME: remove baked in underscore separator in field name



155
156
157
158
159
160
161
162
163
 
# File 'app/helpers/blacklight/hierarchy_helper.rb', line 155

def render_facet_rotate(field_name)
  return unless is_hierarchical?(field_name)
  (prefix, order) = field_name.split(/_/, 2)
  return if blacklight_config.facet_display[:hierarchy][prefix].length < 2
  new_order = facet_after(prefix, order)
  new_params = rotate_facet_params(prefix, order, new_order)
  new_params["#{prefix}_facet_order"] = new_order
  link_to image_tag('icons/rotate.png', title: new_order.upcase).html_safe, new_params, class: 'no-underline'
end

#render_hierarchy(bl_facet_field, delim = '_') ⇒ String

Returns html for the facet tree.

Parameters:

  • as (Blacklight::Configuration::FacetField) —

    defined in controller with config.add_facet_field (and with :partial => ‘blacklight/hierarchy/facet_hierarchy’)

Returns:

  • (String) —

    html for the facet tree



31
32
33
34
35
36
37
38
39
40
41
 
# File 'app/helpers/blacklight/hierarchy_helper.rb', line 31

def render_hierarchy(bl_facet_field, delim = '_')
  field_name = bl_facet_field.field
  prefix = field_name.gsub("#{delim}#{field_name.split(/#{delim}/).last}", '')
  facet_tree_for_prefix = facet_tree(prefix)
  tree = facet_tree_for_prefix ? facet_tree_for_prefix[field_name] : nil

  return '' unless tree
  tree.keys.sort.collect do |key|
    render_facet_hierarchy_item(field_name, tree[key], key)
  end.join("\n").html_safe
end

#render_qfacet_value(facet_solr_field, item, options = {}) ⇒ Object 



43
44
45
 
# File 'app/helpers/blacklight/hierarchy_helper.rb', line 43

def render_qfacet_value(facet_solr_field, item, options = {})
  (link_to_unless(options[:suppress_link], item.value, path_for_facet(facet_solr_field, item.qvalue), class: 'facet_select') + ' ' + render_facet_count(item.hits)).html_safe
end

#render_selected_qfacet_value(facet_solr_field, item) ⇒ Object

Standard display of a SELECTED facet value, no link, special span with class, and ‘remove’ button.



48
49
50
51
52
53
54
55
56
 
# File 'app/helpers/blacklight/hierarchy_helper.rb', line 48

def render_selected_qfacet_value(facet_solr_field, item)
  remove_href = search_action_path(search_state.remove_facet_params(facet_solr_field, item.qvalue))
  content_tag(:span, render_qfacet_value(facet_solr_field, item, suppress_link: true), class: 'selected') + ' ' +
    link_to(content_tag(:span, '', class: 'glyphicon glyphicon-remove') +
            content_tag(:span, '[remove]', class: 'sr-only'),
            remove_href,
            class: 'remove'
           )
end

#rotate_facet_params(prefix, from, to, p = params.dup) ⇒ Object

FIXME: remove baked in underscore separator in field name



140
141
142
143
144
145
146
147
148
149
150
151
152
 
# File 'app/helpers/blacklight/hierarchy_helper.rb', line 140

def rotate_facet_params(prefix, from, to, p = params.dup)
  return p if from == to
  from_field = "#{prefix}_#{from}"
  to_field = "#{prefix}_#{to}"
  p[:f] = (p[:f] || {}).dup # the command above is not deep in rails3, !@#$!@#$
  p[:f][from_field] = (p[:f][from_field] || []).dup
  p[:f][to_field] = (p[:f][to_field] || []).dup
  p[:f][from_field].reject! { |v| p[:f][to_field] << rotate_facet_value(v, from, to); true }
  p[:f].delete(from_field)
  p[:f][to_field].compact!
  p[:f].delete(to_field) if p[:f][to_field].empty?
  p
end

#rotate_facet_value(val, from, to) ⇒ Object

FIXME: remove baked in colon separator



131
132
133
134
135
136
137
 
# File 'app/helpers/blacklight/hierarchy_helper.rb', line 131

def rotate_facet_value(val, from, to)
  components = Hash[from.split(//).zip(val.split(/:/))]
  new_values = components.values_at(*to.split(//))
  new_values.pop while new_values.last.nil?
  return nil if new_values.include?(nil)
  new_values.compact.join(':')
end