jqr-helpers 1.0.0.beta1 → 1.0.0

data/Readme.md

@@ -0,0 +1,128 @@
+# Jqr-Helpers
+
+`jqr-helpers` is a set of methods that create tags that are watched by unobtrusive JavaScript
+events. It is primarily designed to cut down on JavaScript event handling and
+callbacks and try to allow as much as possible to happen with Rails helpers.
+
+The two main uses of these methods are to create dialogs and handle
+Ajax requests without having to write JavaScript code. In particular, the options
+available to the methods provide more support for the most common ways of using
+these sorts of things in a web application environment.
+
+Although there is some overlap with Rails 3 UJS methods, the important part
+is the added options available. These make more assumptions than the built-in
+helper methods, but are optimized to make it much easier to use them in
+common scenarios. The existing methods are not altered.
+
+jqr-helpers was developed using jQuery 1.10 and jQuery-UI 1.10, but it should
+be compatible with earlier versions as well. The assumption is that all
+required JS files are included, including jQuery, jQuery-UI, and the jquery-rails
+UJS adapter. jqr-helpers does not attempt to include them itself.
+
+## Using jqr-helpers ##
+
+If you are running Rails >= 3.1, the required assets should be installed
+automatically as part of the asset pipeline. You can require them as needed:
+
+    //= require jqr-helpers
+    *= require jqr-helpers
+
+If you are running Rails 3.0, you can manually copy the JavaScript and CSS
+into your public folders:
+
+    rails g jqr_helpers:install
+
+## Helper Methods ##
+
+* `link_to_dialog` - open a dialog when a link is clicked
+* `button_to_dialog` - open a dialog when a button is clicked
+* `confirm_button` - open a nice jQuery confirm dialog (rather than a built-in browser one)
+* `link_to_remote_dialog` - open a remote dialog when a link is clicked (i.e. load
+the dialog content from a remote route)
+* `button_to_remote_dialog` - open a remote dialog when a button is clicked
+* `link_to_ajax` - send an Ajax request when a link is clicked
+* `button_to_ajax` - send an Ajax request when a button is clicked
+* `form_tag_ajax` - send an Ajax request when a form is submitted
+* `form_for_ajax` - ditto but using Rails's `form_for` helper
+
+There are two sets of options that recur throughout the methods here:
+
+## Dialog Options ##
+
+These are parameters to pass to the `jQuery.dialog()` function.
+See <http://api.jqueryui.com/dialog/>.
+
+An extra custom option is `:title` - setting it to `false` will hide the
+title bar.
+
+Another thing to note is the special values for buttons. Usually the buttons
+must have JavaScript callbacks, but 99% of the time you want the classic
+OK and Cancel buttons. Passing `submit` and `close` as the values
+of the buttons (or the values of the "click" attribute of the buttons)
+will do just that - submit the form inside the dialog or close it.
+
+Example:
+
+    button_to_dialog('my-dialog-id', 'Open Dialog', :buttons =>
+      {'OK' => 'submit', 'Cancel' => 'close'})
+
+You can also use a special option, `:default_buttons => true`, as a shortcut
+to the above buttons, since it's so common to have an OK and Cancel
+button.
+
+Another option is `:close_x => true` - this will print a green X at the top
+right of the dialog. Generally this is used when `:title => false`.
+
+Note about dialog ID - you can always pass in the special value `:next` for
+this. This will use whatever element is just after the clicked element
+for the dialog contents. This can be useful for printing simple dialogs inside a
+foreach loop that shouldn't require a totally separate route + view.
+
+Dialogs will by default be centered on the page and have a max height of 80%
+the page height.
+
+## Ajax Options ##
+
+By default, the `options` parameter in the various `_to_ajax` functions are
+passed into the underlying function (e.g. `link_to_ajax` will pass them to
+`link_to`), but there is support for several special options as well.
+
+*Selector options* will act on another element once the request is complete.
+Selectors can be IDs (`#selector`), or classes (`.selector`).
+A class selector will be interpreted as an *ancestor* (parent) of the
+element that sent the request that has the given class. So e.g. if you
+are using `button_to_ajax`, giving `:update => '.my-parent'` will look for
+an ancestor of the button tag with the class of `my-parent`.
+
+* `:update` - update the given selector with the returned content.
+* `:append` - insert the content as a child inside the given selector.
+* `:delete` - delete all content of the given selector.
+
+Other Ajax options:
+
+* `:callback` (String) - the name of a JS function to call on completion.
+The function will be in the scope of the original element, and
+will be passed the result data of the Ajax request.
+* `:use_dialog_opener` (Boolean) - if the Ajax request is sent from inside
+a dialog, this indicates that the update/append/delete options should
+look at the element that opened the dialog rather than the element that
+fired the Ajax request. This is true by default for forms and false for
+other elements.
+* `:close_dialog` (Boolean) - if the Ajax request is sent from inside a dialog,
+this indicates that the dialog should be closed when the request completes
+successfully. This is true by default for forms and false for
+other elements.
+
+## jQuery Events ##
+
+There are two special events triggered by jqr-helpers:
+
+* `jqr.load` - this is triggered when a remote call populates an element with
+data. The scope for the callback is the element which has just had data
+populated.
+* `jqr.beforedialogopen` - for remote dialogs, this is triggered when the
+link or button is clicked to open the dialog but before the request is sent out.
+
+***
+
+jqr-helpers was developed by [Wishabi](http://www.wishabi.com).

data/app/assets/javascripts/jqr-helpers.js

@@ -0,0 +1,227 @@
+(function($) {
+  function showThrobber(element) {
+    $(element).after("<img src='/images/jqr-helpers/throbber.gif' class='throbber'/>");
+    $(element).attr('disabled', 'disabled');
+  }
+
+  function hideThrobber(element) {
+    $(element).next().remove();
+    $(element).removeAttr('disabled');
+  }
+
+  var ujsDialogElement = null; // the element that opened the dialog
+
+  // called from dialog button value
+  function ujsSubmitDialogForm() {
+    $('.ui-dialog:visible form').first().submit();
+  }
+
+  // called from dialog button value
+  function ujsDialogClose() {
+    $('.ui-dialog-content:visible').dialog('destroy');
+  }
+
+  function ujsDialogOpen() {
+    if ($(this).parent().height() > $(window).height()) {
+      $(this).height($(window).height() * 0.8);
+      $(this).parent().css('top',
+          ($(window).height() - $(this).parent().height()) / 2
+      );
+      $(this).css('overflow-y', 'auto');
+    }
+    var x = $(this).find('.ujs-dialog-x');
+    if (x.length) {
+      $(this).parent().append(x); // to keep it fixed to the dialog
+      // don't let the dialog be resized - the resize functionality
+      // clashes with the X close functionality
+      $(this).dialog('option', 'resizable', false);
+    }
+  }
+
+  function ujsDialogClick(event) {
+    ujsDialogElement = $(this);
+    var dialogID = $(this).data('dialog-id');
+    var dialogElement = $('#' + dialogID);
+    if (dialogID == 'next') dialogElement = $(this).next();
+    if ($(this).data('close-x')) {
+      dialogElement.prepend('<span class="ujs-dialog-x"></span>');
+    }
+    var dialogOptions = $(this).data('dialog-options');
+    var open = dialogOptions['open'];
+    dialogOptions = $.extend(dialogOptions, {
+      'open': function() {
+        ujsDialogOpen.call(this);
+        if (open) {
+          var openFunc = eval(open);
+          openFunc.call(this);
+        }
+      }
+    });
+    if (dialogOptions.buttons) {
+      $.each(dialogOptions.buttons, function(index, element) {
+        if (element == 'submit') {
+          dialogOptions.buttons[index] = ujsSubmitDialogForm;
+        }
+        else if (element.click == 'submit') {
+          dialogOptions.buttons[index].click = ujsSubmitDialogForm;
+        }
+        else if (element == 'close') {
+          dialogOptions.buttons[index] = ujsDialogClose;
+        }
+        else if (element.click == 'close') {
+          dialogOptions.buttons[index].click = ujsDialogClose;
+        }
+      });
+    }
+    var url = $(this).data('dialog-url');
+    if (url) {
+      $(this).trigger('jqr.beforedialogopen');
+      $(document.body).append('<div class="ui-widget-overlay ui-front">');
+      $(document.body).append('<div id="remote-dialog-throbber">');
+      if (dialogElement.length == 0) {
+        $('body').append("<div id='" + dialogID + "'>");
+        dialogElement = $('#' + dialogID);
+      }
+      dialogElement.load(url, function() {
+        $('.ui-widget-overlay').remove();
+        $('#remote-dialog-throbber').remove();
+        $(this).dialog(dialogOptions);
+        $(dialogElement).trigger('jqr.load');
+      });
+    }
+    else {
+      dialogElement.dialog(dialogOptions);
+    }
+    event.stopPropagation();
+    return false;
+  }
+
+  function ujsDialogCloseClick() {
+    ujsDialogClose();
+    return false;
+  }
+
+  function ujsAjaxBeforeSend() {
+    showThrobber(this);
+    var disableElement = $(this);
+    if ($(this).is('form'))
+      disableElement = $('button, input[type=submit]', this).first();
+    disableElement.attr('disabled', 'disabled');
+  }
+
+  function ujsAjaxSuccess(evt, data, status, xhr) {
+    hideThrobber(this);
+    var disableElement = $(this);
+    if ($(this).is('form'))
+      disableElement = $('button, input[type=submit]', this).first();
+    disableElement.attr('disabled', false);
+    var element = $(this);
+    var targetElement = element;
+    // if this was sent from a dialog, close the dialog and look at the
+    // element that opened it for update/append/delete callbacks.
+    if ($('.ui-dialog:visible').length) {
+      if (element.data('use-dialog-opener'))
+        targetElement = ujsDialogElement;
+      if (element.data('close-dialog'))
+        ujsDialogClose();
+    }
+    if (element.data('callback')) {
+      var callback = eval(element.data('callback'));
+      callback.call(targetElement, data);
+    }
+    if (data && data.trim().charAt(0) != '<' && data != 'success') {
+      alert(data);
+      return;
+    }
+    var selector = element.data('selector');
+    var target = null;
+    if (selector) {
+      if (selector[0] == '#') target = $(selector);
+      else target = $(targetElement).parents(selector);
+      switch (element.data('result-method')) {
+        case 'update':
+          target = $(data).replaceAll(target);
+          target.trigger('jqr.load');
+          break;
+        case 'append':
+          target.append(data);
+          target.trigger('jqr.load');
+          break;
+        case 'delete':
+          target.remove();
+          break;
+      }
+      target.effect('highlight');
+    }
+    return false;
+  }
+
+  function ujsAjaxError(evt, xhr, status, error) {
+    alert(error || 'An error occurred.');
+    hideThrobber(this);
+  }
+
+  function ujsConfirmClick() {
+    var div = $('<div>');
+    var form = this.form;
+    div.html($(this).data('message'));
+    $('body').append(div);
+    div.dialog({
+      modal: true,
+      width: 'auto',
+      maxWidth: '75%',
+      minWidth: '400',
+      minHeight: 'auto',
+      dialogClass: 'confirm-dialog no-title',
+      buttons: {
+        'Yes': function() {
+          form.submit();
+        },
+        'No': function() {
+          div.dialog('close');
+          div.remove();
+        }
+      }
+    });
+    return false;
+  }
+
+  $(function() {
+    $('.ujs-tab-container', this).tabs({
+      beforeLoad: function(event, ui) {
+        if (ui.tab.data('loaded')) {
+          event.preventDefault();
+          return;
+        }
+        ui.jqXHR.success(function() {
+          ui.tab.data('loaded', true);
+        });
+        $(ui.panel).html('Loading...');
+        ui.jqXHR.fail(function(jqXHR, textStatus, errorThrown) {
+          ui.panel.html('Error loading the tab: ' + errorThrown);
+        });
+      }
+    });
+
+    if ($().on) { // newer jQueries
+      $(document).on('click', '.ujs-dialog', ujsDialogClick);
+      $(document).on('click', '.ujs-dialog-close, .ujs-dialog-x',
+          ujsDialogCloseClick);
+      $(document).on('ajax:beforeSend', '.ujs-ajax', ujsAjaxBeforeSend);
+      $(document).on('ajax:success', '.ujs-ajax', ujsAjaxSuccess);
+      $(document).on('ajax:error', '.ujs-ajax', ujsAjaxError);
+      $(document).on('click', '[data-ujs-confirm=true]', ujsConfirmClick);
+    }
+    else {
+      $('.ujs-dialog').live('click', ujsDialogClick);
+      $('.ujs-dialog-close, .ujs-dialog-x').live('click', ujsDialogCloseClick);
+      $('.ujs-ajax').live('ajax:beforeSend', ujsAjaxBeforeSend);
+      $('.ujs-ajax').live('ajax:success', ujsAjaxSuccess);
+      $('.ujs-ajax').live('ajax:error', ujsAjaxError);
+      $('[data-ujs-confirm=true]').live('click', ujsConfirmClick);
+    }
+
+  });
+
+}(jQuery));
+

data/app/assets/stylesheets/jqr-helpers.css

@@ -0,0 +1,21 @@
+form.ujs-ajax, form.ujs-ajax div {
+    display: inline;
+}
+
+.ujs-dialog-modal {
+    position: fixed !important;
+}
+
+.ujs-dialog-x {
+    position: absolute;
+    top: -14px;
+    right: -13px;
+    cursor: pointer;
+    background-image: url('/images/jqr-helpers/close.png');
+    width: 30px;
+    height: 30px;
+}
+
+.ui-dialog.no-title .ui-dialog-titlebar {
+    display: none;
+}

data/jqr-helpers.gemspec

@@ -0,0 +1,22 @@
+Gem::Specification.new do |s|
+  s.name         = 'jqr-helpers'
+  s.require_paths = %w(. lib lib/jqr-helpers)
+  s.version      = '1.0.0'
+  s.date         = '2013-11-19'
+  s.summary      = 'Helpers to print unobtrusive jQuery-UI tags.'
+  s.description  = <<-EOF
+    This gem allows the use of several helper methods.
+    The tags output contain classes and data attributes that are grabbed by
+    unobtrusive JavaScript code and turned into jQuery UI widgets.
+    Helpers include Ajax requests to update elements on the page, dialogs
+    (including remote dialogs), and tab containers.
+EOF
+  s.authors      = ['Daniel Orner']
+  s.email        = 'daniel.orner@wishabi.com'
+  s.files        = `git ls-files`.split($/)
+  s.homepage     = 'https://github.com/wishabi/jqr-helpers'
+  s.license       = 'MIT'
+
+  s.add_dependency 'rails', '>= 3.0'
+
+end

data/lib/jqr-helpers.rb

@@ -0,0 +1 @@
+require 'jqr-helpers/railtie' if defined?(Rails)

data/lib/jqr-helpers/helpers.rb

@@ -0,0 +1,213 @@
+module JqrHelpers
+  module Helpers
+
+    # Add a link to create a jQuery dialog.
+    # If a block is given, dialog_options and html_options are shifted left by
+    # 1 and the block is used as the html_content.
+    # @param dialog_id [String] The ID of the element to put in the dialog.
+    # @param html_content [String] Text or HTML tags to use as the link body.
+    # @param dialog_options [Hash] See above.
+    # @param html_options [Hash] Attributes to put on the link tag. There is
+    #  a special :tag_name option that can be used to change the tag being
+    #  created. Default is :a, but you can pass :div, :span, etc.
+    # @return [String]
+    def link_to_dialog(dialog_id, html_content='', dialog_options={},
+      html_options={}, &block)
+
+      if block_given?
+        html_options = dialog_options
+        dialog_options = html_content.presence || {}
+        html_content = capture(&block)
+      end
+
+      html_options[:class] ||= ''
+      html_options[:class] << ' ujs-dialog'
+      html_options[:'data-dialog-id'] = dialog_id
+      html_options[:'data-close-x'] = dialog_options[:close_x]
+
+      tag_name = html_options.delete(:tag_name) || :a
+      html_options[:href] = '#' if tag_name == :a
+
+      if dialog_options[:title] == false # not nil or blank
+        dialog_options[:dialogClass] ||= ''
+        dialog_options[:dialogClass] << ' ujs-dialog-modal no-title'
+      else
+        dialog_options[:title] ||= 'Dialog'
+      end
+      dialog_options[:modal] = true
+      dialog_options[:width] ||= 'auto'
+      if dialog_options.delete(:default_buttons)
+        dialog_options[:buttons] = {
+          :OK => 'submit',
+          :Cancel => 'close'
+        }
+      end
+
+      html_options[:'data-dialog-options'] = dialog_options.to_json
+
+      content_tag tag_name, html_content, html_options
+    end
+
+    # Add a button to create a jQuery dialog.
+    # @param dialog_id [String] The ID of the element to put in the dialog.
+    # @param html_content [String] Text or HTML tags to use as the button body.
+    # @param html_options [Hash] Attributes to put on the button tag.
+    # @param dialog_options [Hash] See above.
+    # @return [String]
+    def button_to_dialog(dialog_id, html_content, dialog_options={},
+      html_options={})
+      link_to_dialog(dialog_id, html_content, dialog_options,
+                     html_options.merge(:tag_name => 'button'))
+    end
+
+    # Create a button that prompts a jQuery confirm dialog, which is nicer-looking
+    # than the default window.confirm() which is used by Rails. Done using
+    # button_to, so note that a form element will be added.
+    # @param html_content [String] the text or content to go inside the button
+    # @param url [String] the URL which the button should go to if confirmed
+    # @param message [String] the confirm message to prompt
+    # @param html_options [Hash] HTML attributes.
+    def confirm_button(html_content, url, message, html_options)
+      button_to html_content, url, html_options.merge(
+        :'data-message' => simple_format(message), # turn text into HTML
+        :'data-ujs-confirm' => true
+      )
+    end
+
+    # Same as link_to_dialog, but loads content from a remote URL instead of
+    # using content already on the page.
+    # If a block is given, dialog_options and html_options are shifted left by
+    # 1 and the block is used as the html_content.
+    # @param id [String] A unique ID to use to reference the dialog options.
+    #  This is ultimately created as an element with that ID in the DOM,
+    #  but the element does not have to exist already, unlike link_to_dialog.
+    # @param url [String] The URL to load the content from.
+    # @param html_content [String] Text or HTML tags to use as the link body.
+    # @param dialog_options [Hash] See above.
+    # @param html_options [Hash] Attributes to put on the link tag. There is
+    #  a special :tag_name option that can be used to change the tag being
+    #  created. Default is :a, but you can pass :div, :span, etc.
+    # @return [String]
+    def link_to_remote_dialog(id, url, html_content, dialog_options={},
+      html_options={}, &block)
+
+      if block_given?
+        html_options = dialog_options
+        dialog_options = html_content
+        html_content = capture(&block)
+      end
+
+      html_options[:'data-dialog-url'] = url
+      link_to_dialog(id, html_content, dialog_options, html_options)
+    end
+
+    # Same as button_to_dialog, but loads content from a remote URL instead of
+    # using content already on the page.
+    # @param id [String] A unique ID to use to reference the dialog options.
+    #  This is ultimately created as an element with that ID in the DOM,
+    #  but the element does not have to exist already, unlike button_to_dialog.
+    # @param url [String] The URL to load the content from.
+    # @param html_content [String] Text or HTML tags to use as the button body.
+    # @param dialog_options [Hash] See above.
+    # @param html_options [Hash] Attributes to put on the button tag.
+    # @return [String]
+    def button_to_remote_dialog(id, url, html_content, dialog_options={},
+      html_options={})
+      link_to_remote_dialog(id, url, html_content, dialog_options,
+                     html_options.merge(:tag_name => 'button'))
+    end
+
+    # Create a link that fires off a jQuery Ajax request. This is basically
+    # a wrapper around link_to :remote => true.
+    # If a block is given, url and options will be shifted left by 1 position
+    # and the block contents will be used for the body.
+    # @param body [String] the text/content that goes inside the tag.
+    # @param url [String] the URL to connect to.
+    # @param options [Hash] Ajax options - see above.
+    # @return [String]
+    def link_to_ajax(body, url, options={}, &block)
+      if block_given?
+        options = url
+        url = body
+        body = capture(&block)
+      end
+
+      options[:remote] = true
+      options.merge!(_process_ajax_options(options))
+
+      link_to body, url, options
+    end
+
+    # Create a button that fires off a jQuery Ajax request. This is basically
+    # a wrapper around button_to :remote => true.
+    # @param body [String] the text/content that goes inside the tag.
+    # @param url [String] the URL to connect to.
+    # @param options [Hash] Ajax options - see above.
+    # @return [String]
+    def button_to_ajax(body, url, options={})
+
+      options[:remote] = true
+      options[:form] ||= {}
+      options[:form].merge!(_process_ajax_options(options))
+
+      button_to body, url, options
+    end
+
+    # Create a form tag that submits to an Ajax request. Basically a wrapper for
+    # form_tag with :remote => true.
+    # @param url [String] the URL to connect to.
+    # @param options [Hash] Ajax options - see above.
+    # @return [String]
+    def form_tag_ajax(url, options={}, &block)
+
+      options[:remote] = true
+      # note that we only override if nil - not false
+      options[:close_dialog] = true if options[:close_dialog].nil?
+      options[:use_dialog_opener] = true if options[:use_dialog_opener].nil?
+      options.merge!(_process_ajax_options(options))
+
+      form_tag url, options, &block
+    end
+
+    # Identical to form_tag_ajax except that this passes the given model into
+    # form_for instead of form_tag.
+    # @param record [ActiveRecord::Base]
+    # @param options [Hash]
+    # @return [String]
+    def form_for_ajax(record, options={}, &block)
+      options[:remote] = true
+      # note that we only override if nil - not false
+      options[:close_dialog] = true if options[:close_dialog].nil?
+      options[:use_dialog_opener] = true if options[:use_dialog_opener].nil?
+      options[:html] ||= {}
+      options[:html].merge!(_process_ajax_options(options))
+
+      form_for record, options, &block
+
+    end
+
+    private
+
+    # Process options related to Ajax requests (e.g. button_to_ajax).
+    # @param options [Hash]
+    # @return [Hash] HTML options to inject.
+    def _process_ajax_options(options)
+      new_options = {}
+      new_options[:class] = options[:class] || ''
+      new_options[:class] << ' ujs-ajax'
+      new_options[:'data-type'] = 'html'
+      new_options[:'data-callback'] = options.delete(:callback)
+      new_options[:'data-close-dialog'] = options.delete(:close_dialog)
+      new_options[:'data-use-dialog-opener'] = options.delete(:use_dialog_opener)
+
+      [:update, :append, :delete].each do |result_method|
+        selector = options.delete(result_method)
+        if selector
+          new_options[:'data-selector'] = selector
+          new_options[:'data-result-method'] = result_method
+        end
+      end
+    new_options
+    end
+  end
+end

data/lib/jqr-helpers/install_generator.rb

@@ -0,0 +1,25 @@
+require 'rails'
+require 'rails/generators'
+
+module JqrHelpers
+  module Generators
+    class InstallGenerator < ::Rails::Generators::Base
+
+      desc 'This generator installs jqr-helper JavaScript, CSS, and image files.'
+      source_root File.expand_path('../../../app/assets', __FILE__)
+
+      def copy_files
+        log 'Copying files...'
+        files = [
+          'javascripts/jqr-helpers.js',
+          'stylesheets/jqr-helpers.css',
+          'images/jqr-helpers/close.png',
+          'images/jqr-helpers/throbber.gif'
+        ]
+        files.each do |file|
+          copy_file file, "public/#{file}"
+        end
+      end
+    end
+  end
+end

data/lib/jqr-helpers/railtie.rb

@@ -0,0 +1,12 @@
+require 'helpers'
+
+module JqrHelpers
+  class Railtie < Rails::Railtie
+    initializer 'jqr-helpers.helpers' do
+      ActionView::Base.send :include, Helpers
+    end
+    generators do
+      require 'install_generator'
+    end
+  end
+end

data/lib/jqr-helpers/version.rb

@@ -0,0 +1,5 @@
+module JqrHelpers
+  module Rails
+    VERSION = '1.0.0'
+  end
+end

metadata

@@ -1,8 +1,8 @@
 --- !ruby/object:Gem::Specification
 name: jqr-helpers
 version: !ruby/object:Gem::Version
-  prerelease: 6
-  version: 1.0.0.beta1
+  prerelease: 
+  version: 1.0.0
 platform: ruby
 authors:
 - Daniel Orner
@@ -36,7 +36,18 @@ email: daniel.orner@wishabi.com
 executables: []
 extensions: []
 extra_rdoc_files: []
-files: []
+files:
+- Readme.md
+- app/assets/images/jqr-helpers/close.png
+- app/assets/images/jqr-helpers/throbber.gif
+- app/assets/javascripts/jqr-helpers.js
+- app/assets/stylesheets/jqr-helpers.css
+- jqr-helpers.gemspec
+- lib/jqr-helpers.rb
+- lib/jqr-helpers/helpers.rb
+- lib/jqr-helpers/install_generator.rb
+- lib/jqr-helpers/railtie.rb
+- lib/jqr-helpers/version.rb
 homepage: https://github.com/wishabi/jqr-helpers
 licenses:
 - MIT
@@ -46,8 +57,6 @@ require_paths:
 - .
 - lib
 - lib/jqr-helpers
-- lib/generators
-- app/helpers
 required_ruby_version: !ruby/object:Gem::Requirement
   none: false
   requirements:
@@ -57,9 +66,9 @@ required_ruby_version: !ruby/object:Gem::Requirement
 required_rubygems_version: !ruby/object:Gem::Requirement
   none: false
   requirements:
-  - - ! '>'
+  - - ! '>='
     - !ruby/object:Gem::Version
-      version: 1.3.1
+      version: '0'
 requirements: []
 rubyforge_project: 
 rubygems_version: 1.8.25