blacklight_range_limit 8.5.0 → 9.0.0.beta1

data/app/assets/stylesheets/blacklight_range_limit/blacklight_range_limit.css

@@ -1,60 +0,0 @@
-form.range_limit {
-  /* leave room for buttons not to collide on line wrap */
-  line-height: 3;
-}
-
-.range_limit .range-limit-input-group {
-  max-width: 350px;
-  width: 100% !important;
-}
-
-.range_limit input.range_begin, .range_limit input.range_end {
-  display: inline-block;
-  width: 4.5em;
-}
-
-.limit_content .subsection {
-  margin-top: 0.5em;
-}
-
-.hover_legend {
-  padding: 0.25em;
-}
-
-.slider_js .slider-selection {
-  /* color from flot selection */
-  background: #e8cfac;
-}
-
-.slider_js .slider-horizontal {
-  margin-left: 5px;
-  margin-right: 5px;
-}
-
-.chart_js .flot-x-axis {
-  font-size: 14px;
-}
-
-.modal-body .view_larger {
-  display: none;
-}
-
-/* Prevent an unstyled flash of content for values we'll replace with a chart */
-.js .distribution .facet-values {
-  display: none;
-}
-
-.modal-body .range_limit {
-  justify-content: center;
-}
-
-.view_larger {
-  display: block;
-  text-align: center;
-}
-
-.range_limit .chart_js {
-  min-height: 80px;
-  margin-left: -12px;
-  margin-right: -14px;
-}

data/app/assets/stylesheets/blacklight_range_limit.css

@@ -1,7 +0,0 @@
-/* Master manifest file for engine, so local app can require
- * this one file, but get all our files -- and local app
- * require does not need to change if we change file list. 
- *
- *= require 'slider'
- *= require_tree './blacklight_range_limit'
- */

data/app/helpers/range_limit_helper.rb

@@ -1,130 +0,0 @@
-module RangeLimitHelper
-  extend Deprecation
-
-  def range_limit_url(options = {})
-    main_app.url_for(search_state.to_h.merge(action: 'range_limit').merge(options))
-  end
-  deprecation_deprecate :range_limit_url
-
-  def range_limit_panel_url(options = {})
-    search_facet_path(id: options[:id])
-  end
-  deprecation_deprecate :range_limit_panel_url
-
-  # type is 'begin' or 'end'
-  def render_range_input(solr_field, type, input_label = nil, maxlength=4)
-    range_form_component(solr_field).render_range_input(type, input_label, maxlength)
-  end
-  deprecation_deprecate :render_range_input
-
-  # type is 'min' or 'max'
-  # Returns smallest and largest value in current result set, if available
-  # from stats component response.
-  def range_results_endpoint(solr_field, type)
-    presenter = range_facet_field_presenter(solr_field)
-
-    case type.to_s
-    when 'min'
-      presenter.min
-    when 'max'
-      presenter.max
-    end
-  end
-  deprecation_deprecate :range_results_endpoint
-
-  def range_display(solr_field, my_params = params)
-    facet_config = blacklight_config.facet_fields[solr_field]
-    presenter = range_facet_field_presenter(solr_field)
-    return unless presenter.selected_range
-
-    facet_item = Blacklight::Solr::Response::Facets::FacetItem.new(value: presenter.selected_range, hits: presenter.response.total)
-
-    facet_config.item_presenter.new(facet_item, facet_config, self, solr_field).label
-  end
-  deprecation_deprecate :range_display
-
-  ##
-  # A method that is meant to be overridden downstream to format how a range
-  # label might be displayed to a user. By default it just returns the value
-  # as rendered by the presenter
-  def format_range_display_value(value, solr_field)
-    Deprecation.warn(RangeLimitHelper, 'Helper #format_range_display_value is deprecated without replacement')
-    facet_item_presenter(facet_configuration_for_field(solr_field), value, solr_field).label
-  end
-
-  # Show the limit area if:
-  # 1) we have a limit already set
-  # OR
-  # 2) stats show max > min, OR
-  # 3) count > 0 if no stats available.
-  def should_show_limit(solr_field)
-    presenter = range_facet_field_presenter(solr_field)
-
-    presenter.selected_range ||
-      (presenter.max && presenter.min && presenter.max > presenter.min) ||
-      @response.total.positive?
-  end
-
-  def stats_for_field(solr_field)
-    range_facet_field_presenter(solr_field).send(:stats_for_field)
-  end
-  deprecation_deprecate :stats_for_field
-
-  def stats_for_field?(solr_field)
-    stats_for_field(solr_field).present?
-  end
-  deprecation_deprecate :stats_for_field?
-
-  def add_range_missing(solr_field, my_params = params)
-    Blacklight::SearchState.new(my_params.except(:page), blacklight_config).filter(solr_field).add(Blacklight::SearchState::FilterField::MISSING)
-  end
-  deprecation_deprecate :add_range_missing
-
-  def add_range(solr_field, from, to, my_params = params)
-    Blacklight::SearchState.new(my_params.except(:page), blacklight_config).filter(solr_field).add(from..to)
-  end
-  deprecation_deprecate :add_range
-
-  def has_selected_range_limit?(solr_field)
-    range_facet_field_presenter(solr_field).selected_range.present?
-  end
-  deprecation_deprecate :has_selected_range_limit?
-
-  def selected_missing_for_range_limit?(solr_field)
-    search_state.filter(solr_field).values.first == Blacklight::SearchState::FilterField::MISSING
-  end
-  deprecation_deprecate :selected_missing_for_range_limit?
-
-  def remove_range_param(solr_field, my_params = params)
-    Blacklight::SearchState.new(my_params.except(:page), blacklight_config).filter(solr_field).remove(0..0)
-  end
-
-  # Looks in the solr @response for ["facet_counts"]["facet_queries"][solr_field], for elements
-  # expressed as "solr_field:[X to Y]", turns them into
-  # a list of hashes with [:from, :to, :count], sorted by
-  # :from. Assumes integers for sorting purposes.
-  def solr_range_queries_to_a(solr_field)
-    range_facet_field_presenter(solr_field).range_queries.map do |item|
-      { from: item.value.first, to: item.value.last, count: item.hits }
-    end
-  end
-  deprecation_deprecate :solr_range_queries_to_a
-
-  def range_config(solr_field)
-    BlacklightRangeLimit.range_config(blacklight_config, solr_field)
-  end
-  deprecation_deprecate :range_config
-
-  private
-
-  def range_facet_field_presenter(key)
-    facet_config = blacklight_config.facet_fields[key] || Blacklight::Configuration::FacetField.new(key: key, **BlacklightRangeLimit.default_range_config)
-    facet_field_presenter(facet_config, Blacklight::Solr::Response::Facets::FacetField.new(key, [], response: @response))
-  end
-
-  def range_form_component(key)
-    presenter = range_facet_field_presenter(key)
-
-    BlacklightRangeLimit::RangeFormComponent.new(facet_field: presenter)
-  end
-end

data/app/javascript/blacklight_range_limit/index.js

@@ -1,11 +0,0 @@
-import BlacklightRangeLimit from 'range_limit_shared'
-import 'range_limit_plotting'
-import 'range_limit_distro_facets'
-import 'range_limit_slider'
-
-BlacklightRangeLimit.initialize = function(modalSelector) {
-  BlacklightRangeLimit.initializeDistroFacets(modalSelector)
-  BlacklightRangeLimit.initializeSlider(modalSelector)
-}
-
-export default BlacklightRangeLimit

data/app/javascript/blacklight_range_limit/range_limit_distro_facets.js

@@ -1,76 +0,0 @@
-/**
- * Closure functions in this file are mainly concerned with initializing, resizing, and updating
- * range limit functionality based off of page load, facet opening, page resizing, and otherwise
- * events.
- */
-
-import BlacklightRangeLimit from 'range_limit_shared'
-
-BlacklightRangeLimit.initializeDistroFacets = function(modalSelector) {
-  // Facets already on the page? Turn em into a chart.
-  $(".range_limit .profile .distribution.chart_js ul").each(function() {
-      BlacklightRangeLimit.turnIntoPlot($(this).parent());
-  });
-
-  BlacklightRangeLimit.checkForNeededFacetsToFetch();
-
-  // Listen for twitter bootstrap collapsible open events, to render flot
-  // in previously hidden divs on open, if needed.
-  $("body").on("show.bs.collapse", function(event) {
-    // Was the target a .facet-content including a .chart-js?
-    var container =  $(event.target).filter(".facet-content").find(".chart_js");
-
-    // only if it doesn't already have a canvas, it isn't already drawn
-    if (container && container.find("canvas").length == 0) {
-      // be willing to wait up to 1100ms for container to
-      // have width -- right away on show.bs is too soon, but
-      // shown.bs is later than we want, we want to start rendering
-      // while animation is still in progress.
-      BlacklightRangeLimit.turnIntoPlot(container, 1100);
-    }
-  });
-
-  // For Blacklight version < 8, when loaded in a modal
-  $(modalSelector).on('shown.bs.modal', function() {
-    $(this).find(".range_limit .profile .distribution.chart_js ul").each(function() {
-      BlacklightRangeLimit.turnIntoPlot($(this).parent());
-    });
-
-    // Case when there is no currently selected range
-    BlacklightRangeLimit.checkForNeededFacetsToFetch();
-  });
-
-  // Use a mutation observer to detect when the HTML dialog is open
-  BlacklightRangeLimit.initPlotModalObserver(modalSelector);
-
-  $("body").on("shown.bs.collapse", function(event) {
-    var container =  $(event.target).filter(".facet-content").find(".chart_js");
-    BlacklightRangeLimit.redrawPlot(container);
-  });
-
-  // debouce borrowed from underscore
-  // Returns a function, that, as long as it continues to be invoked, will not
-  // be triggered. The function will be called after it stops being called for
-  // N milliseconds. If `immediate` is passed, trigger the function on the
-  // leading edge, instead of the trailing.
-  const debounce = function(func, wait, immediate) {
-    var timeout;
-    return function() {
-      var context = this, args = arguments;
-      var later = function() {
-        timeout = null;
-        if (!immediate) func.apply(context, args);
-      };
-      var callNow = immediate && !timeout;
-      clearTimeout(timeout);
-      timeout = setTimeout(later, wait);
-      if (callNow) func.apply(context, args);
-    };
-  };
-
-  $(window).on("resize", debounce(function() {
-    $(".chart_js").each(function(i, container) {
-      BlacklightRangeLimit.redrawPlot($(container));
-    });
-  }, 350));
-}

data/app/javascript/blacklight_range_limit/range_limit_plotting.js

@@ -1,186 +0,0 @@
-// second arg, if provided, is a number of ms we're willing to
-// wait for the container to have width before giving up -- we'll
-// set 50ms timers to check back until timeout is expired or the
-// container is finally visible. The timeout is used when we catch
-// bootstrap show event, but the animation hasn't barely begun yet -- but
-// we don't want to wait until it's finished, we want to start rendering
-// as soon as we can.
-
-import BlacklightRangeLimit from 'range_limit_shared'
-
-BlacklightRangeLimit.turnIntoPlot = function turnIntoPlot(container, wait_for_visible) {
-  // flot can only render in a a div with a defined width.
-  // for instance, a hidden div can't generally be rendered in (although if you set
-  // an explicit width on it, it might work)
-  //
-  // We'll count on later code that catch bootstrap collapse open to render
-  // on show, for currently hidden divs.
-
-  // for some reason width sometimes return negative, not sure
-  // why but it's some kind of hidden.
-  if (container.width() > 0) {
-    var height = container.width() * BlacklightRangeLimit.display_ratio;
-
-    // Need an explicit height to make flot happy.
-    container.height( height )
-
-    BlacklightRangeLimit.areaChart($(container));
-
-    $(container).trigger(BlacklightRangeLimit.redrawnEvent);
-  }
-  else if (wait_for_visible > 0) {
-    setTimeout(function() {
-      BlacklightRangeLimit.turnIntoPlot(container, wait_for_visible - 50);
-    }, 50);
-  }
-}
-
-BlacklightRangeLimit.parseSegment = function parseSegment(el) {
-  if ($(el).find("span.single").first().data('blrlSingle')) {
-    var val = BlacklightRangeLimit.parseNum($(el).find("span.single").first().data('blrlSingle'));
-
-    return [val, val];
-  } else {
-    var from = BlacklightRangeLimit.parseNum($(el).find("span.from").first().data('blrlBegin'));
-    var to = BlacklightRangeLimit.parseNum($(el).find("span.to").first().data('blrlEnd'));
-
-    return [from, to];
-  }
-}
-
-// Takes a div holding a ul of distribution segments produced by
-// blacklight_range_limit/_range_facets and makes it into
-// a flot area chart.
-BlacklightRangeLimit.areaChart = function areaChart(container) {
-  //flot loaded? And canvas element supported.
-  if ( BlacklightRangeLimit.domDependenciesMet()  ) {
-
-    // Grab the data from the ul div
-    var series_data = new Array();
-    var pointer_lookup = new Array();
-    var x_ticks = new Array();
-    var min = BlacklightRangeLimit.parseSegment($(container).find("ul li:first-child").first())[0];
-    var max = BlacklightRangeLimit.parseSegment($(container).find("ul li:last-child").first())[1];
-
-    $(container).find("ul li").each(function() {
-        var segment = BlacklightRangeLimit.parseSegment(this);
-        var from = segment[0];
-        var to = segment[1];
-
-        var count = BlacklightRangeLimit.parseNum($(this).find("span.facet-count,span.count").text());
-        var avg = (count / (to - from + 1));
-
-        //We use the avg as the y-coord, to make the area of each
-        //segment proportional to how many documents it holds.
-        series_data.push( [from, avg ] );
-        series_data.push( [to+1, avg] );
-
-        x_ticks.push(from);
-
-        pointer_lookup.push({'from': from, 'to': to, 'count': count, 'label': $(this).find(".facet-select,.facet_select").html() });
-    });
-
-    x_ticks.push( max + 1 );
-
-    var plot;
-    var config = $(container).closest('.blrl-plot-config').data('plot-config') || $(container).closest('.facet-limit').data('plot-config') || {};
-
-    try {
-      plot = $.plot($(container), [series_data],
-          $.extend(true, config, {
-          yaxis: {  ticks: [], min: 0, autoscaleMargin: 0.1},
-        //xaxis: { ticks: x_ticks },
-        xaxis: { tickDecimals: 0 }, // force integer ticks
-        series: { lines: { fill: true, steps: true }},
-        grid: {clickable: true, hoverable: true, autoHighlight: false, margin: { left: 0, right: 0 }},
-        selection: {mode: "x"}
-      }));
-    }
-    catch(err) {
-      alert(err);
-    }
-
-    var find_segment_for = BlacklightRangeLimit.function_for_find_segment(pointer_lookup);
-    var last_segment = null;
-    $(container).tooltip({'html': true, 'placement': 'bottom', 'trigger': 'manual', 'delay': { show: 0, hide: 100}});
-
-    $(container).bind("plothover", function (event, pos, item) {
-      var segment = find_segment_for(pos.x);
-
-      if(segment != last_segment) {
-        var title = find_segment_for(pos.x).label  + ' (' + BlacklightRangeLimit.parseNum(segment.count) + ')';
-        $(container).attr("title", title).tooltip("_fixTitle").tooltip("show");
-
-        last_segment  = segment;
-       }
-    });
-
-    $(container).bind("mouseout", function() {
-      last_segment = null;
-      $(container).tooltip('hide');
-    });
-    $(container).bind("plotclick", function (event, pos, item) {
-        if ( plot.getSelection() == null) {
-          segment = find_segment_for(pos.x);
-          plot.setSelection(BlacklightRangeLimit.normalized_selection(segment.from, segment.to));
-        }
-    });
-    $(container).bind("plotselected plotselecting", function(event, ranges) {
-      if (ranges != null ) {
-        var from = Math.floor(ranges.xaxis.from);
-        var to = Math.floor(ranges.xaxis.to);
-
-        var form = $(container).closest(".limit_content").find("form.range_limit");
-        form.find("input.range_begin").val(from);
-        form.find("input.range_end").val(to);
-
-        var slider_placeholder = $(container).closest(".limit_content").find("[data-slider-placeholder]");
-        if (slider_placeholder) {
-          slider_placeholder.slider("setValue", [from, to]);
-        }
-      }
-    });
-
-    var form = $(container).closest(".limit_content").find("form.range_limit");
-    form.find("input.range_begin, input.range_end").on('input', function () {
-      plot.setSelection( BlacklightRangeLimit.form_selection(form, min, max), true );
-    });
-    $(container).closest(".limit_content").find(".profile .range").on("slide", function(event, ui) {
-      var values = $(event.target).data("slider").getValue();
-      form.find("input.range_begin").val(values[0]);
-      form.find("input.range_end").val(values[1]);
-      plot.setSelection(BlacklightRangeLimit.normalized_selection(values[0], Math.max(values[0], values[1])), true);
-    });
-
-    // initially entirely selected, to match slider
-    plot.setSelection(BlacklightRangeLimit.normalized_selection(min, max));
-  }
-}
-
-// after a collapsible facet contents is fully shown,
-// resize the flot chart to current conditions. This way, if you change
-// browser window size, you can get chart resized to fit by closing and opening
-// again, if needed.
-BlacklightRangeLimit.redrawPlot = function redrawPlot(container) {
-  if (container && container.width() > 0) {
-    // resize the container's height, since width may have changed.
-    container.height( container.width() * BlacklightRangeLimit.display_ratio  );
-
-    // redraw the chart.
-    var plot = container.data("plot");
-    if (plot) {
-      // how to redraw after possible resize?
-      // Cribbed from https://github.com/flot/flot/blob/master/jquery.flot.resize.js
-      plot.resize();
-      plot.setupGrid();
-      plot.draw();
-      // plus trigger redraw of the selection, which otherwise ain't always right
-      // we'll trigger a fake event on one of the boxes
-      var form = $(container).closest(".limit_content").find("form.range_limit");
-      form.find("input.range_begin").trigger("change");
-
-      // send our custom event to trigger redraw of slider
-      $(container).trigger(BlacklightRangeLimit.redrawnEvent);
-    }
-  }
-}

data/app/javascript/blacklight_range_limit/range_limit_shared.js

@@ -1,112 +0,0 @@
-/**
- * BlacklightRangeLimit module setup.
- */
-'use strict';
-
-const BlacklightRangeLimit = function (options) {
-  this.options = options || {};
-}
-
-BlacklightRangeLimit.display_ratio = 1/(1.618 * 2); // half a golden rectangle, why not
-/* A custom event "plotDrawn.blacklight.rangeLimit" will be sent when flot plot
-    is (re-)drawn on screen possibly with a new size. target of event will be the DOM element
-    containing the plot.  Used to resize slider to match. */
-BlacklightRangeLimit.redrawnEvent = "plotDrawn.blacklight.rangeLimit";
-
-// takes a string and parses into an integer, but throws away commas first, to avoid truncation when there is a comma
-// use in place of javascript's native parseInt
-BlacklightRangeLimit.parseNum = function parseNum(str) {
-  str = String(str).replace(/[^0-9-]/g, '');
-  return parseInt(str, 10);
-};
-
-BlacklightRangeLimit.form_selection = function form_selection(form, min, max) {
-  var begin_val = BlacklightRangeLimit.parseNum($(form).find("input.range_begin").val());
-  if (isNaN(begin_val) || begin_val < min) {
-    begin_val = min;
-  }
-  var end_val = BlacklightRangeLimit.parseNum($(form).find("input.range_end").val());
-  if (isNaN(end_val) || end_val > max) {
-    end_val = max;
-  }
-
-  return BlacklightRangeLimit.normalized_selection(begin_val, end_val);
-}
-
-// Add AJAX fetched range facets if needed, and add a chart to em
-BlacklightRangeLimit.checkForNeededFacetsToFetch = function checkForNeededFacetsToFetch() {
-  $(".range_limit .profile .distribution a.load_distribution").each(function() {
-    var container = $(this).parent('div.distribution');
-
-    $(container).load($(this).attr('href'), function(response, status) {
-      if ($(container).hasClass("chart_js") && status == "success" ) {
-        BlacklightRangeLimit.turnIntoPlot(container);
-        }
-    });
-  });
-}
-
-BlacklightRangeLimit.function_for_find_segment = function function_for_find_segment(pointer_lookup_arr) {
-  return function(x_coord) {
-    for (var i = pointer_lookup_arr.length-1 ; i >= 0 ; i--) {
-      var hash = pointer_lookup_arr[i];
-      if (x_coord >= hash.from)
-        return hash;
-    }
-    return pointer_lookup_arr[0];
-  };
-}
-
-// Send endpoint to endpoint+0.99999 to have display
-// more closely approximate limiting behavior esp
-// at small resolutions. (Since we search on whole numbers,
-// inclusive, but flot chart is decimal.)
-BlacklightRangeLimit.normalized_selection = function normalized_selection(min, max) {
-  max += 0.99999;
-
-  return {xaxis: { 'from':min, 'to':max}}
-}
-
-// Check if Flot is loaded
-BlacklightRangeLimit.domDependenciesMet = function domDependenciesMet() {
-  return typeof $.plot != "undefined"
-}
-
-BlacklightRangeLimit.modalObserverConfig = {
-  attributes: true,
-}
-
-BlacklightRangeLimit.initSliderModalObserver = function(modalSelector) {
-  // Use a mutation observer to detect when the modal dialog is open
-  const modalObserver = new MutationObserver(function(mutations) {
-    mutations.forEach(function(mutation) {
-      if (mutation.attributeName !== 'open') {return;}
-      if (mutation.target.hasAttribute('open')) {
-        $(modalSelector).find(".range_limit .profile .range.slider_js").each(function() {
-          BlacklightRangeLimit.buildSlider(this);
-        });
-      }
-    });
-  });
-  modalObserver.observe(document.querySelector(modalSelector), BlacklightRangeLimit.modalObserverConfig);
-}
-
-BlacklightRangeLimit.initPlotModalObserver = function(modalSelector) {
-  // Use a mutation observer to detect when the modal dialog is open
-  const modalObserver = new MutationObserver(function(mutations) {
-    mutations.forEach(function(mutation) {
-      if (mutation.attributeName !== 'open') {return;}
-      if (mutation.target.hasAttribute('open')) {
-        $(modalSelector).find(".range_limit .profile .distribution.chart_js ul").each(function() {
-          BlacklightRangeLimit.turnIntoPlot($(this).parent());
-        });
-
-        // Case when there is no currently selected range
-        BlacklightRangeLimit.checkForNeededFacetsToFetch();
-      }
-    });
-  });
-  modalObserver.observe(document.querySelector(modalSelector), BlacklightRangeLimit.modalObserverConfig);
-}
-
-export default BlacklightRangeLimit