discerner 1.1.18

checksums.yaml

@@ -0,0 +1,7 @@
+---
+SHA1:
+  metadata.gz: ecb4c17f2e220beb34f78081d0343faed81e933d
+  data.tar.gz: e9a87d805da56897978848a1b18a222ade053255
+SHA512:
+  metadata.gz: 7bb80f4d67f66ef9de64556061661afc6b33c1f3f8864d1ee7bd52b138e34e897ff3e64ef41bec204a1b39590bb818384d43d33a5a73284ccaf0d6252f2c0163
+  data.tar.gz: 00a4af1d6d7021621496f8fb684db7244b4f1ca0ee60914de05a4ad68524c1af8573ba4a56ef7c18f88b05b1200259b601dc852e4828d01a9f77f904a06218ce

data/MIT-LICENSE

@@ -0,0 +1,20 @@
+Copyright 2012 YOURNAME
+
+Permission is hereby granted, free of charge, to any person obtaining
+a copy of this software and associated documentation files (the
+"Software"), to deal in the Software without restriction, including
+without limitation the rights to use, copy, modify, merge, publish,
+distribute, sublicense, and/or sell copies of the Software, and to
+permit persons to whom the Software is furnished to do so, subject to
+the following conditions:
+
+The above copyright notice and this permission notice shall be
+included in all copies or substantial portions of the Software.
+
+THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND,
+EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF
+MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND
+NONINFRINGEMENT. IN NO EVENT SHALL THE AUTHORS OR COPYRIGHT HOLDERS BE
+LIABLE FOR ANY CLAIM, DAMAGES OR OTHER LIABILITY, WHETHER IN AN ACTION
+OF CONTRACT, TORT OR OTHERWISE, ARISING FROM, OUT OF OR IN CONNECTION
+WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE SOFTWARE.

data/README.md

@@ -0,0 +1,97 @@
+# Discerner
+
+Discerner is an engine for Rails that provides basic search UI, search reqults export UI and allows to configure available search parameters/values. Discerner is not aimed to be a SQL-generator, but it allows the host application to access stored search conditions and provide search results.
+
+Reader's note: this README uses [YARD][] markup to provide links to
+Discerner's API documentation. If you aren't already, consider reading it
+on [rubydoc.info][] so that the links will be followable.
+
+[YARD]: http://yardoc.org/
+[rubydoc.info]: http://rubydoc.info/github/NUBIC/discerner/master/file/README.md
+
+# Requirements
+
+This code has been run and tested on Ruby 1.9. and Ruby 2.1
+
+# Dependencies
+
+* haml
+* sass
+* jquery-rails
+* jquery-ui-rails
+
+# Installation
+
+## Install gem with Bundler
+
+```ruby
+gem 'discerner'
+bundle install
+```
+## Run the installer
+
+```ruby
+rails generate discerner:install
+```
+
+By default, Discerner installer performs following tasks:
+
+* it copies Discerner's migrations into db/migrate and runs migrations
+* it sets up default Discerner operators. As of now, default operators cannot be changed.
+* it prompts for current_user helper name and inserts `discerner_user` method into the application controller. This allows Discerner to attibure created searches to the current user.
+* it adds discerner helpers used for configuring dicerner functionality into application helper. This will be changed in the future.
+  * show_discerner_results? - helper used to determine if search results should be displayed.
+  * export_discerner_results? - helper used to determine if search results should be exportable.
+  * enable_combined_searches? - helper used to determine if search interface should allow to combine searches
+* it mounts Discerner::Engine
+* it copies sample search dictionary into lib/setup
+
+Discerner installer accepts following parameters:
+
+* --no-migrate - prevent installer from running migrations. If this flag is set, Discerner operators would have to be loaded manually using **rake discerner:setup:operators**
+* --current-user-helper   - allows to specify current user method name
+* --customize-controllers - copy Discerner controllers into application, so they can be customized
+* --customize-models      - copy Discerner models into application, so they can be customized
+* --customize-helpers     - copy Discerner helpers into application, so they can be customized
+* --customize-layout      - copy Discerner layout into application, so it can be customized
+* --customize-all         - copy Discerner controllers, models, helpers, and layout into application, so they can be customized
+
+
+# Usage
+## Setting up dictionaries
+
+```ruby
+rails generate discerner:dictionary [FILENAME]
+```
+Discerner uses dictionaries to define parameters and values that can be used for constructing searches. Discerner dictionary generator performs following tasks:
+
+* it parses provided file and sets up or updates corresponding search dictionary, its parameter categories, parameters and parameter values
+* it creates a model for each specified dictionary that is expected to implement "search" and "export" methods.
+* it generates template views for search results and export.
+
+Discerner dictionary generator accepts following parameters:
+
+* --no-load   - skip dictionary generation/update
+* --no-models - skip models generation
+* --no-views  - skip views generation
+
+Installer adds a sample dictionary than can be used as a template anr/or can be parsed and used to explore Discerner Search UI:
+
+```ruby
+rails generate discerner:dictionary lib/setup/dictionaries.yml
+```
+
+## Updating dictionaries
+
+In most cases, dictionary generator needs to be run only once per dictionary. Dictionary updates, excluding name change, should be handled by re-parcing definition file with Discerner parser:
+
+```ruby
+rails discerner:setup:dictionaries FILE=xxx
+```
+
+Discerner parser processes YML definition file line by line, detecting and creating/updating dictionaries, parameter categories, parameters and parameter values. It runs in silent mode by default, --trace option can be used to make it verbose.
+
+## User Interface
+
+Index of all saved searches scoped by current user (if available) can be accessed from '/searches' route.
+

data/Rakefile

@@ -0,0 +1,29 @@
+#!/usr/bin/env rake
+begin
+  require 'bundler/setup'
+  require 'cucumber/rake/task'
+  require 'rspec/core/rake_task'
+  require 'rubygems/package_task'
+end
+
+gemspec = eval(File.read('discerner.gemspec'), binding, 'discerner.gemspec')
+Gem::PackageTask.new(gemspec).define
+APP_RAKEFILE = File.expand_path("../test/dummy/Rakefile", __FILE__)
+$:.unshift File.join(File.dirname(__FILE__), 'spec','support')
+load 'rails/tasks/engine.rake' if File.exists?(APP_RAKEFILE)
+load 'lib/tasks/discerner_tasks.rake'
+load 'test/lib/tasks/discerner_test_tasks.rake'
+RSpec::Core::RakeTask.new(:spec)
+task :default => :spec
+
+namespace :cucumber do
+  Cucumber::Rake::Task.new(:wip, 'Run features that are being worked on') do |t|
+    t.profile = 'wip'
+  end
+
+  Cucumber::Rake::Task.new(:features) do |t|
+    t.cucumber_opts = "features --format pretty"
+  end
+end
+
+task :cucumber => 'cucumber:features'

data/app/assets/javascripts/discerner/application.js

@@ -0,0 +1,20 @@
+// This is a manifest file that'll be compiled into application.js, which will include all the files
+// listed below.
+//
+// Any JavaScript/Coffee file within this directory, lib/assets/javascripts, vendor/assets/javascripts,
+// or vendor/assets/javascripts of plugins, if any, can be referenced here using a relative path.
+//
+// It's not advisable to add code directly here, but if you do, it'll appear at the bottom of the
+// the compiled file.
+//
+// WARNING: THE FIRST BLANK LINE MARKS THE END OF WHAT'S TO BE PROCESSED, ANY BLANK LINE SHOULD
+// GO AFTER THE REQUIRES BELOW.
+//
+//= require jquery
+//= require jquery_ujs
+//= require jquery.ui.widget
+//= require jquery.ui.autocomplete
+//= require jquery.ui.datepicker
+//= require jquery.ui.button
+//= require discerner/jquery/jquery.blockUI
+//= require_tree .

data/app/assets/javascripts/discerner/combobox.js

@@ -0,0 +1,301 @@
+// courtesy of https://github.com/garyzhu/jquery.ui.combobox/blob/master/jquery.ui.combobox.js
+// more courtesy https://github.com/garyzhu/jquery.ui.combobox/commit/65433ee5af6e9b87b594e5bb5c4b16b030806e24
+/*
+ * Combobox widget. This widget extends the jQuery UI autocomplete widget.
+ *
+ * usage:  $("#select_element").combox();
+ *         $("#input_element").combox( {minLength: 2, delay: 200, source: anArray} );
+ *
+ * For select elements, the source list is automatically generated from the option elements.
+ *
+ * To configure a label decorator (i.e. "[admin]"), set the decoratorField when you
+ * initialize the combobox. The field corresponds to the object field, if the source is
+ * an array of objects. Or it's the attribute in <option> if the source is a select drop-down menu.
+ */
+
+(function($) {
+  $.widget("ui.combobox", $.ui.autocomplete, {
+    options: {
+      /* override default values here */
+      minLength: 2,
+      /* the argument to pass to ajax to get the complete list */
+      ajaxGetAll: {
+        get: "all"
+      },
+      /* you can specify the field to use as a label decorator,
+       * it's appended to the end of the label and is excluded
+       * from pattern matching.
+       */
+      decoratorField: null
+    },
+
+    _create: function() {
+      if (this.element.is("SELECT")) {
+        this._selectInit();
+        return;
+      }
+      $.ui.autocomplete.prototype._create.call(this);
+      var input = this.element,
+          watermark = ('Search for ' + this.options.watermark); // custom watermark
+
+      // custom part - setting and removing watermark
+      function clearWatermark () {
+        if (input.val() === watermark) {
+          input.val('');
+        }
+      };
+
+      function setWatermark () {
+        input.val(watermark);
+        input.bind('focus', clearWatermark);
+      };
+
+      if (input.not("SELECT")) {
+        input.blur( function (e) {
+          if ($(this).val() === '') {
+            input.val(watermark);
+          }
+          e.preventDefault();
+          return false;
+        });
+
+        $(document).ready(function () {
+          if ($(input).val() === '') {
+            setWatermark();
+          }
+        });
+      }
+      // end of custom part
+
+      input.addClass("ui-widget ui-widget-content ui-corner-left").click(function() {
+        this.select();
+      });
+
+      this.button = $("<button type='button'>&nbsp;</button>")
+      .attr("tabIndex", -1)
+      .attr("title", "Show All Items")
+      .insertAfter(input).button({
+        disabled: true,
+        // to be enabled when the menu is ready.
+        icons: {
+          primary: "ui-icon-triangle-1-s"
+        },
+        text: false
+      })
+      .removeClass("ui-corner-all")
+      .addClass("ui-corner-right ui-button-icon")
+      .click(function(event) {
+        // when user clicks the show all button, we display the cached full menu
+        var data = input.data("ui-combobox");
+        clearTimeout(data.closing);
+        if (!input.isFullMenu) {
+          data._swapMenu();
+        }
+        /* input/select that are initially hidden (display=none, i.e. second level menus),
+          will not have position cordinates until they are visible. */
+        input.combobox("widget").css("display", "block").position($.extend({
+          of: input
+        }, data.options.position));
+        input.focus();
+        data._trigger("open");
+        // containers such as jquery-ui dialog box will adjust it's zIndex to overlay above other elements.
+        // this becomes a problem if the combobox is inside of a dialog box, the full drop down will show
+        // under the dialog box.
+        if (input.combobox("widget").zIndex() <= input.parent().zIndex()) {
+          input.combobox("widget").zIndex(input.parent().zIndex() + 1);
+        }
+      });
+
+      /* to better handle large lists, put in a queue and process sequentially */
+      $(document).queue(function() {
+        var data = input.data("ui-combobox");
+        if ($.isArray(data.options.source)) {
+          $.ui.combobox.prototype._renderFullMenu.call(data, data.options.source);
+        } else if (typeof data.options.source === "string") {
+          $.getJSON(data.options.source, data.options.ajaxGetAll, function(source) {
+            $.ui.combobox.prototype._renderFullMenu.call(data, source);
+          });
+        } else {
+          $.ui.combobox.prototype._renderFullMenu.call(data, data.source());
+        }
+      });
+    },
+
+    /* initialize the full list of items, this menu will be reused whenever the user clicks the show all button */
+    _renderFullMenu: function(source) {
+      var self = this,
+          input = this.element,
+          ul = input.data("ui-combobox").menu.element,
+          lis = [];
+      source = this._normalize(source);
+      input.data("ui-combobox").menuAll = input.data("ui-combobox").menu.element.clone(true).appendTo("body")[0];
+      for (var i = 0; i < source.length; i++) {
+        var item = source[i],
+            label = item.label;
+        if (this.options.decoratorField != null) {
+          var d = item[this.options.decoratorField] || (item.option && $(item.option).attr(this.options.decoratorField));
+          if (d != undefined) label = label + " " + d;
+        }
+        lis[i] = "<li class=\"ui-menu-item\" role=\"menuitem\"><a class=\"ui-corner-all\" tabindex=\"-1\">" + label + "</a></li>";
+      }
+      ul[0].innerHTML = lis.join("");
+      this._resizeMenu();
+
+      var items = $("li", ul).on("mouseover", "mouseout", function(event) {
+        if (event.type == "mouseover") {
+          self.menu.focus(event, $(this));
+        } else {
+          self.menu.blur();
+        }
+      });
+      for (var i = 0; i < items.length; i++) {
+        $(items[i]).data("ui-autocomplete-item", source[i]);
+      }
+      input.isFullMenu = true;
+      this._swapMenu()
+      // full menu has been rendered, now we can enable the show all button.
+      self.button.button("enable");
+      setTimeout(function() {
+        $(document).dequeue();
+      }, 0);
+    },
+
+    /* overwrite. make the matching string bold and added label decorator */
+    _renderItem: function(ul, item) {
+      var label = item.label.replace(new RegExp("(?![^&;]+;)(?!<[^<>]*)(" + $.ui.autocomplete.escapeRegex(this.term) + ")(?![^<>]*>)(?![^&;]+;)", "gi"), "<strong>$1</strong>");
+      if (this.options.decoratorField != null) {
+        var d = item[this.options.decoratorField] || (item.option && $(item.option).attr(this.options.decoratorField));
+        if (d != undefined) {
+          label = label + " " + d;
+        }
+      }
+      return $("<li></li>")
+        .data("ui-autocomplete-item", item)
+        .append("<a>" + label + "</a>")
+        .appendTo(ul);
+    },
+
+    close: function() {
+       if (this.element.isFullMenu) {
+         this._swapMenu();
+       }
+       // super()
+       $.ui.autocomplete.prototype.close.call(this);
+    },
+
+    /* overwrite. to cleanup additional stuff that was added */
+    destroy: function() {
+      if (this.element.is("SELECT")) {
+        this.input.removeData("ui-combobox", "menuAll");
+        this.input.remove();
+        this.element.removeData().show();
+        return;
+      }
+      // super()
+      $.ui.autocomplete.prototype.destroy.call(this);
+      // clean up new stuff
+      this.element.removeClass("ui-widget ui-widget-content ui-corner-left");
+      this.button.remove();
+    },
+
+    /* overwrite. to swap out and preserve the full menu */
+    search: function(value, event) {
+      var input = this.element;
+      if (input.isFullMenu) {
+        this._swapMenu();
+      }
+      // super()
+      $.ui.autocomplete.prototype.search.call(this, value, event);
+    },
+
+    _change: function(event) {
+      if (!this.selectedItem) {
+        var matcher = new RegExp("^" + $.ui.autocomplete.escapeRegex(this.element.val()) + "$", "i"),
+            match = $.grep(this.options.source, function(value) {
+            return matcher.test(value.label);
+          });
+        if (match.length) {
+          if (match[0].option != undefined) match[0].option.selected = true;
+        } else {
+          // remove invalid value, as it didn't match anything
+          if (this.options.selectElement) {
+            var firstItem = this.options.selectElement.children("option:first");
+            this.element.val(firstItem.text());
+            firstItem.prop("selected", true);
+          } else {
+            this.element.val("");
+          }
+          $(event.target).data("ui-combobox").previous = null; // this will force a change event
+        }
+      }
+      // super()
+      $.ui.autocomplete.prototype._change.call(this, event);
+    },
+
+    _swapMenu: function() {
+      var input = this.element,
+          data = input.data("ui-combobox"),
+          tmp = data.menuAll;
+      data.menuAll = data.menu.element.hide()[0];
+      data.menu.element[0] = tmp;
+      input.isFullMenu = !input.isFullMenu;
+    },
+
+    /* build the source array from the options of the select element */
+    _selectInit: function() {
+      var select = this.element,
+          selectClass = select.attr("class"),
+          selectStyle = select.attr("style"),
+          selected = select.children(":selected"),
+          value = $.trim(selected.text());
+      select.hide();
+      this.options.source = select.children("option").map(function() {
+        return {
+          label: $.trim(this.text),
+          option: this
+        };
+      }).toArray();
+      var userSelectCallback = this.options.select;
+      var userSelectedCallback = this.options.selected;
+      this.options.select = function(event, ui) {
+        ui.item.option.selected = true;
+        select.change();
+        if (userSelectCallback) userSelectCallback(event, ui);
+        // compatibility with jQuery UI's combobox.
+        if (userSelectedCallback) userSelectedCallback(event, ui);
+      };
+      this.options.selectElement = select;
+      this.input = $("<input>").insertAfter(select).val(value);
+      if (selectStyle) {
+        this.input.attr("style", selectStyle);
+      }
+      if (selectClass) {
+        this.input.attr("class", selectClass);
+      }
+      this.input.combobox(this.options);
+    },
+    inputbox: function() {
+      if (this.element.is("SELECT")) {
+        return this.input;
+      } else {
+        return this.element;
+      }
+    },
+
+    // custom part - setting combobox value
+    setValue: function (value) {
+      var input = $(this.element[0]).siblings('input.ui-autocomplete-input').first(),
+          selectEl = document.getElementById(this.element.attr('id')),
+          options = selectEl.options,
+          length = options.length;
+      for (var a = 0; a < length; a += 1) {
+        if (options[a].text === value) {
+          selectEl.selectedIndex = a;
+          input.val(options[a].text);
+          return false;
+        }
+      };
+    }
+    // end of custom part
+  });
+})(jQuery);

data/app/assets/javascripts/discerner/discerner.js

@@ -0,0 +1,19 @@
+Discerner = {};
+Discerner.Constants = {};
+Discerner.Search = {};
+Discerner.SearchParameter = {};
+Discerner.SearchParameterValue = {}
+Discerner.SearchCombination = {};
+Discerner.CategorizedAutocomplter = {};
+Discerner.ExportParameters = {};
+Discerner.Url = {};
+NestedAttributes = {};
+
+Discerner.Constants.EFFECT_SPEED = 1750;
+
+$(function() {
+  $(document).on('keyup', '#discerner_searches_filter input[type="text"]', function() {
+    $.get($("#discerner_searches_filter").attr("action"), $("#discerner_searches_filter").serialize(), null, "script");
+    return false;
+  });
+})

data/app/assets/javascripts/discerner/export_parameters.js

@@ -0,0 +1,13 @@
+Discerner.ExportParameters.UI = function() {
+  $(document).on('click','#discerner_exportable_fields a.select_all_parameters', function(){
+    $(this).closest("div[class^='parameter_category_']").find("input[type='checkbox']:not(:checked)").prop('checked', true);
+    $(this).removeClass('select_all_parameters').addClass('deselect_all_parameters').html('Deselect all');
+    return false
+  });
+
+  $(document).on('click','#discerner_exportable_fields a.deselect_all_parameters', function(){
+    $(this).closest("div[class^='parameter_category_']").find("input[type='checkbox']:checked").prop('checked', false);
+    $(this).removeClass('deselect_all_parameters').addClass('select_all_parameters').html('Select all');
+    return false
+  });
+}