mighty_grid 1.0.0 → 2.0.0.rc1

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA1:
-  metadata.gz: e6f6866acde2692702bbbf6885eb459ed8960c43
-  data.tar.gz: c8af8d724f7cf2db8edda2fdeed240682b753ed6
+  metadata.gz: ae66ac068670599398526077c090a43897244668
+  data.tar.gz: 599f7821d5b8c9c008313738d1b3ccb19e10aa0a
 SHA512:
-  metadata.gz: af481f7256ba0b787d976f53a0586250d1c1944d30db94f0b896a41a6f7835c455e0db346129564f8acbca155e4f2652c181bc4c496f0ee8494a1a79658c47f6
-  data.tar.gz: 78cf52302e3c844da064560dca2adcb5ceb18f1fe5b452f6d770331568417c6f91f5a73ba01fbec2ec340dae7f915b2992fc586d2ba7691a391c659b5f3f869b
+  metadata.gz: 4a41aaade69e5ad4e51d84c46291288064f997abcd9a5d97a1c30a053bf9c5a8ba1b3e0e767195b3b089022075ce4f457999235b9124c072d26b1be2b972fd57
+  data.tar.gz: ae204f9bac3fb47080dc7c21a96f325121c44919f1ea86d98bb98c28c21b6b51d9d5058fff02e7e970e0ac348ab1a35fd7518d1ebf61099f7613babaa1a4181d

data/Gemfile

@@ -19,4 +19,6 @@ group :test do
   gem "codeclimate-test-reporter", require: nil
   gem 'pg', require: false
   gem 'mysql2', require: false
+
+  gem 'pry'
 end

data/README.md

@@ -8,23 +8,34 @@ Add this line to your application's Gemfile:
 
     gem 'mighty_grid'
 
-And then execute:
+Then run the following generator command in order to generate files for gem customization:
 
-    $ bundle
+    $ rails g mighty_grid:install
 
-Or install it yourself as:
+After generation you will see the following files:
 
-    $ gem install mighty_grid
+  * `config/initializers/mighty_grid.rb`
+  * `config/locales/mighty_grid.en.yml`
 
 ## Quick Start
 
+### Grid
+
+Any grid can be defined in a folder `app/grids` for example as follows:
+
+```
+Class ProductsGrid < MightyGrid::Base
+  scope { Product }
+end
+```
+
 ### Controller
 
-You can define class or relation in <tt>init_grid</tt> method.
+You can initialize grid like this:
 
 ```
 def index
-  @products_grid = init_grid(Product)
+  @products_grid = ProductsGrid.new(params)
 end
 ```
 
@@ -42,7 +53,7 @@ end
 
 ### General configuration options
 
-You can configure the following default values by overriding these values using <tt>MightyGrid.configure</tt> method.
+You can configure the following default values by overriding these values using <tt>MightyGrid.setup</tt> method.
 
 ```
 per_page                # 15 by default
@@ -61,20 +72,17 @@ pagination_theme        # 'mighty_grid' by default
 ```
 
 There's a handy generator that generates the default configuration file into config/initializers directory.
-Run the following generator command, then edit the generated file.
-
-    $ rails g mighty_grid:install
 
 ## Running tests
 
 To run the tests you need specify database and Rails version.
 
-* List of available Rails versions: 3.2, 4.0, 4.1.
+* List of available Rails versions: 4.0, 4.1, 4.2.
 * List of DB: sqlite, postgresql, mysql.
 
 Example run:
 
-    $ DB=postgresql appraisal rails_32 rake spec cucumber
+    $ DB=postgresql appraisal rails_41 rake spec cucumber
 
 ## Contributing
 

data/features/support/env.rb

@@ -7,6 +7,7 @@ end
 require 'bundler/setup'
 Bundler.require
 
+require 'rspec/matchers'
 require 'capybara/cucumber'
 
 if defined? Rails

data/lib/generators/mighty_grid/install_generator.rb

@@ -8,7 +8,7 @@ module MightyGrid
       desc 'Copies MightyGrid configuration and locale files to your application.'
 
       def copy_config_file
-        template 'mighty_grid_config.rb', 'config/initializers/mighty_grid_config.rb'
+        template 'mighty_grid.rb', 'config/initializers/mighty_grid.rb'
       end
 
       def copy_locale_file

data/lib/generators/mighty_grid/templates/{mighty_grid_config.rb → mighty_grid.rb}

@@ -1,4 +1,4 @@
-MightyGrid.configure do |config|
+MightyGrid.setup do |config|
   # config.per_page = 15
   # config.order_direction = 'asc'
   # config.order_type = 'single'

data/lib/mighty_grid/base.rb

@@ -1,17 +1,25 @@
 module MightyGrid
   class Base
-    attr_reader :klass, :name, :relation, :options, :mg_params, :controller
+    include MightyGrid::Filters
+    include MightyGrid::Parameters
+
+    attr_reader :klass, :name, :relation, :options, :mg_params, :params, :controller
     attr_accessor :output_buffer, :filters
 
-    def initialize(klass_or_relation, controller, opts = {})  #:nodoc:
-      @controller = controller
+    def initialize(params, opts = {})  #:nodoc:
+      @controller_params = params
+
+      # Get active controller through params
+      if controller = "#{params[:controller].camelize}Controller".safe_constantize
+        @controller = ObjectSpace.each_object(controller).first
+      end
 
-      @filters = {}
+      @filters = self.class.filters.dup
 
       @options = {
         page:       1,
-        per_page:   MightyGrid.config.per_page,
-        name:       MightyGrid.config.grid_name,
+        per_page:   MightyGrid.per_page,
+        name:       MightyGrid.grid_name,
         include:    nil,
         joins:      nil,
         conditions: nil,
@@ -22,15 +30,28 @@ module MightyGrid
       opts.assert_valid_keys(@options.keys)
       @options.merge!(opts)
 
-      @name = @options[:name].to_s
+      @klass = self.class.klass
+      @relation = self.class.relation
 
-      @relation = klass_or_relation
+      @relation = yield(@relation) if block_given?
 
-      @klass = klass_or_relation.is_a?(ActiveRecord::Relation) ? klass_or_relation.klass : klass_or_relation
+      @name = @options[:name].to_s
 
       load_grid_params
     end
 
+    class << self
+      attr_reader :klass, :relation
+
+      def scope(&block)
+        if block_given?
+          klass_or_relation = yield
+          @relation = klass_or_relation
+          @klass = klass_or_relation.is_a?(ActiveRecord::Relation) ? klass_or_relation.klass : klass_or_relation
+        end
+      end
+    end
+
     def read
       apply_filters
       if @mg_params[:order].present? && current_order_direction.present?
@@ -48,110 +69,9 @@ module MightyGrid
                     .group(@options[:group])
     end
 
-    # Apply filters
-    def apply_filters
-      filter_params.each do |filter_name, filter_value|
-        name, table_name = filter_name.split('.').reverse
-
-        if table_name && Object.const_defined?(table_name.classify)
-          model = table_name.classify.constantize
-        else
-          model = klass
-        end
-
-        next if filter_value.blank? || !model.column_names.include?(name)
-
-        if model && model.superclass == ActiveRecord::Base
-          field_type = model.columns_hash[name].type
-        else
-          next
-        end
-
-        table_name = model.table_name
-        if @filters.key?(filter_name.to_sym) && @filters[filter_name.to_sym].is_a?(Array)
-          @relation = @relation.where(table_name => { filter_name => filter_value })
-        elsif field_type == :boolean
-          value = %w(true 1 t).include?(filter_value) ? true : false
-          @relation = @relation.where(table_name => { filter_name => value })
-        elsif [:string, :text].include?(field_type)
-          @relation = @relation.where("#{table_name}.#{name} #{like_operator} ?", "%#{filter_value}%")
-        end
-      end
-    end
-
     # Get controller parameters
     def params
-      @controller.params
-    end
-
-    # Load grid parameters
-    def load_grid_params
-      @mg_params = {}
-      @mg_params[filter_param_name.to_sym] = {}
-      @mg_params.merge!(@options)
-      if current_grid_params
-        @mg_params.merge!(current_grid_params.symbolize_keys)
-        if @mg_params[:order].present? && !@mg_params[:order].to_s.include?('.')
-          @mg_params[:order] = "#{klass.table_name}.#{@mg_params[:order]}"
-        end
-      end
-    end
-
-    # Get current grid parameter by name
-    def get_current_grid_param(name)
-      current_grid_params.key?(name) ? current_grid_params[name] : nil
-    end
-
-    # Get filter parameters
-    def filter_params
-      @mg_params[filter_param_name.to_sym] || {}
-    end
-
-    # Get filter parameter name
-    def filter_param_name
-      'f'
-    end
-
-    # Add param in filters
-    def add_filter_param(param, value)
-      @mg_params[filter_param_name.to_sym][param] = value unless @mg_params[filter_param_name.to_sym].key?(param)
-    end
-
-    # Get filter name by field
-    def get_filter_name(field, model = nil)
-      field_name = model.present? ? "#{model.table_name}.#{field}" : field
-      "#{name}[#{filter_param_name}][#{field_name}]"
-    end
-
-    # Get current grid parameters
-    def current_grid_params
-      params[name] || {}
-    end
-
-    # Get order parameters
-    def order_params(attribute, model = nil, direction = nil)
-      order = model.present? ? "#{model.table_name}.#{attribute}" : attribute.to_s
-      direction ||= order == current_grid_params['order'] ? another_order_direction : 'asc'
-      { @name => { order: order, order_direction: direction } }
-    end
-
-    # Get current order direction if current order parameter coincides with the received parameter
-    def get_active_order_direction(parameters)
-      parameters[@name]['order'] == current_grid_params['order'] ? current_order_direction : nil
-    end
-
-    # Get current order direction
-    def current_order_direction
-      direction = nil
-      if current_grid_params.key?('order_direction') && %w(asc desc).include?(current_grid_params['order_direction'].downcase)
-        direction = current_grid_params['order_direction'].downcase
-      end
-      direction
-    end
-
-    # Get another order direction
-    def another_order_direction
-      current_grid_params.key?('order_direction') ? (%w(asc desc) - [current_grid_params['order_direction'].to_s]).first : MightyGrid.config.order_direction
+      @controller_params
     end
 
     # Get <tt>like</tt> or <tt>ilike</tt> operator depending on the database adapter

data/lib/mighty_grid/column.rb

@@ -18,7 +18,7 @@ module MightyGrid
       end
 
       @model = @options[:model]
-      fail MightyGridArgumentError.new('Model of field for filtering should have type ActiveRecord') if @model && @model.superclass != ActiveRecord::Base
+      fail MightyGrid::Exceptions::ArgumentError.new('Model of field for filtering should have type ActiveRecord') if @model && @model.superclass != ActiveRecord::Base
 
       @attrs = @options[:html] if @options.key?(:html)
       @th_attrs = @options[:th_html] if @options.key?(:th_html)

data/lib/mighty_grid/engine.rb

@@ -1,18 +1,21 @@
 module MightyGrid
-  class MightyGridEngine < ::Rails::Engine
-    initializer 'mighty_grid_railtie.configure_rails_initialization' do |app|
-
-      ActiveSupport.on_load :action_controller do
-        ActionController::Base.send(:include, MightyGrid::Controller)
-      end
+  class Engine < ::Rails::Engine
+    config.eager_load_namespaces << MightyGrid
 
+    initializer 'mighty_grid.helpers' do |app|
       ActiveSupport.on_load :action_view do
-        ::ActionView::Base.class_eval { include MightyGrid::GridViewHelper }
-
         # It is here only until this pull request is pulled: https://github.com/amatsuda/kaminari/pull/267
         require 'mighty_grid/kaminari_monkey_patching'
       end
+    end
 
+    config.after_initialize do
+      unless MightyGrid.configured?
+        warn """
+[Mighty Grid] Mighty Grid is not configured in the application and will use the default values.
+Use `rails generate mighty_grid:install` to generate the Mighty Grid configuration.
+        """
+      end
     end
   end
 end

data/lib/mighty_grid/exceptions.rb

@@ -0,0 +1,9 @@
+module MightyGrid
+  module Exceptions  #:nodoc:
+    class ArgumentError < ::ArgumentError #:nodoc:
+      def initialize(str)  #:nodoc:
+        super("MightyGrid: #{str}")
+      end
+    end
+  end
+end

data/lib/mighty_grid/filter_renderer.rb

@@ -11,41 +11,35 @@ module MightyGrid
       options = content_or_options if content_or_options.is_a?(Hash)
       human_name = (content_or_options.is_a?(Hash) || content_or_options.nil?) ? @grid.klass.human_attribute_name(name) : content_or_options
 
-      f_options = filter_options(name, options, false)
-
-      label_tag(get_filter_id(f_options), human_name, options, &block)
+      label_tag(get_filter_id(name), human_name, options, &block)
     end
 
     # Get <tt>input</tt> HTML tag
     def text_field(name, options = {})
-      f_options = filter_options(name, options)
-      text_field_tag(@grid.get_filter_name(name, f_options[:model]), get_filter_param(name, f_options[:model]), options)
+      text_field_tag(@grid.get_filter_name(name), get_filter_param(name), options)
     end
 
     # Get <tt>select</tt> HTML tag
-    def select(name, option_tags = nil, options = {})
-      @grid.filters[name] = option_tags
-      f_options = filter_options(name, options)
+    def select(name, options = {})
+      option_tags = @grid.filters[name].collection
 
       selected = nil
       if options.key?(:selected)
         selected = options.delete(:selected)
-        @grid.add_filter_param(get_filter_param_name(name, f_options[:model]), selected)
+        @grid.add_filter_param(name, selected)
       end
 
-      selected = get_filter_param(name, f_options[:model]) if get_filter_param(name, f_options[:model])
+      selected = get_filter_param(name) if get_filter_param(name)
       opts = options_for_select(option_tags, selected)
 
-      select_tag(@grid.get_filter_name(name, f_options[:model]), opts, options)
+      select_tag(@grid.get_filter_name(name), opts, options)
     end
 
     # Get <tt>checkbox</tt>
     def check_box(name, value = '1', checked = false, options = {})
       checked = true if get_filter_param(name)
 
-      f_options = filter_options(name, options)
-
-      check_box_tag(@grid.get_filter_name(name, f_options[:model]), value, checked, options)
+      check_box_tag(@grid.get_filter_name(name), value, checked, options)
     end
 
     # Get button for Apply filter changes
@@ -64,28 +58,18 @@ module MightyGrid
 
     private
 
-    def get_filter_param_name(name, model = nil)
-      model ? "#{model.table_name}.#{name}" : name.to_s
-    end
-
-    def get_filter_param(name, model = nil)
-      filter_name = get_filter_param_name(name, model)
-      @grid.filter_params.key?(filter_name) ? @grid.filter_params[filter_name] : nil
-    end
-
-    def get_filter_id(name: nil, model: nil)
-      @grid.get_filter_name(name, model).parameterize('_')
+    def get_filter_param(name)
+      if @grid.filter_params.key?(name.to_s)
+        @grid.filter_params[name.to_s]
+      elsif @grid.filter_params.blank? && @grid.filters[name.to_sym].default.present?
+        @grid.filters[name.to_sym].default
+      else
+        nil
+      end
     end
 
-    def filter_options(name, options, with_id = true)
-      opts = { name: name }
-      if options.is_a?(Hash) && options.key?(:model)
-        model = options.delete(:model)
-        fail MightyGridArgumentError.new('Model of field for filtering should have type ActiveRecord') if model.present? && model.superclass != ActiveRecord::Base
-        opts.merge!(model: model)
-        options.merge!(id: get_filter_id(opts)) if with_id
-      end
-      opts
+    def get_filter_id(name)
+      @grid.get_filter_name(name).parameterize('_')
     end
   end
 end

data/lib/mighty_grid/filters/base.rb

@@ -0,0 +1,27 @@
+module MightyGrid
+  module Filters
+    class Base
+      attr_reader :options, :attribute, :model, :default
+
+      class_attribute :default_options
+      self.default_options = {
+        name: nil,
+        attribute: nil,
+        model: nil,
+        default: nil
+      }
+
+
+      def initialize(options = {})
+        options = options.clone
+
+        options.assert_valid_keys(self.class.default_options.keys)
+
+        @options = options.reverse_merge!(self.class.default_options)
+        @attribute = @options.delete(:attribute) || @options[:name]
+        @model = @options.delete(:model)
+        @default = @options.delete(:default)
+      end
+    end
+  end
+end

data/lib/mighty_grid/filters/boolean_filter.rb

@@ -0,0 +1,6 @@
+module MightyGrid
+  module Filters
+    class BooleanFilter < Base
+    end
+  end
+end

data/lib/mighty_grid/filters/custom_filter.rb

@@ -0,0 +1,19 @@
+module MightyGrid
+  module Filters
+    class CustomFilter < Base
+      attr_reader :scope
+
+      def initialize(options = {}, &block)
+        self.class.default_options.merge!(scope: nil)
+
+        super(options)
+
+        if block_given?
+          @scope = block
+        else
+          @scope = @options.delete(:scope)
+        end
+      end
+    end
+  end
+end

data/lib/mighty_grid/filters/enum_filter.rb

@@ -0,0 +1,15 @@
+module MightyGrid
+  module Filters
+    class EnumFilter < Base
+      attr_reader :collection
+
+      def initialize(options = {})
+        self.class.default_options.merge!(collection: nil)
+
+        super(options)
+
+        @collection = @options[:collection]
+      end
+    end
+  end
+end

data/lib/mighty_grid/filters/string_filter.rb

@@ -0,0 +1,6 @@
+module MightyGrid
+  module Filters
+    class StringFilter < Base
+    end
+  end
+end

data/lib/mighty_grid/filters/text_filter.rb

@@ -0,0 +1,6 @@
+module MightyGrid
+  module Filters
+    class TextFilter < Base
+    end
+  end
+end

data/lib/mighty_grid/filters.rb

@@ -0,0 +1,113 @@
+require 'active_support/core_ext/class/attribute'
+require 'mighty_grid/map_type'
+
+module MightyGrid
+  module Filters
+    extend ActiveSupport::Autoload
+
+    autoload :Base
+    autoload :StringFilter
+    autoload :TextFilter
+    autoload :EnumFilter
+    autoload :BooleanFilter
+    autoload :CustomFilter
+
+    def self.included(base)
+      base.class_eval do
+        class_attribute :filters
+        self.filters = {}
+
+        extend MapType
+        map_type :string, to: MightyGrid::Filters::StringFilter
+        map_type :text, to: MightyGrid::Filters::TextFilter
+        map_type :enum, to: MightyGrid::Filters::EnumFilter
+        map_type :boolean, to: MightyGrid::Filters::BooleanFilter
+        map_type :custom, to: MightyGrid::Filters::CustomFilter
+      end
+
+      base.send :extend, ClassMethods
+      base.send :include, InstanceMethods
+    end
+
+    module InstanceMethods
+      # Get filter parameter name
+      def filter_param_name
+        'f'
+      end
+
+      # Get filter parameters
+      def filter_params
+        @mg_params[filter_param_name.to_sym] || {}
+      end
+
+      # Add param to filters
+      def add_filter_param(param, value)
+        @mg_params[filter_param_name.to_sym][param] = value unless @mg_params[filter_param_name.to_sym].key?(param)
+      end
+
+      # Get filter name by field
+      def get_filter_name(field, model = nil)
+        field_name = model.present? ? "#{model.table_name}.#{field}" : field
+        "#{name}[#{filter_param_name}][#{field_name}]"
+      end
+
+      # Apply filters
+      def apply_filters
+        @filters.each_pair do |filter_name, filter|
+          next if (filter_params.blank?   && filter.default.blank? ||
+                   filter_params.present? && filter_params[filter_name.to_s].blank?)
+
+          filter_value =
+            if filter_params.present?
+              filter_params[filter_name.to_s]
+            else
+              filter.default.to_s
+            end
+
+          table_name = filter.model.table_name
+
+          case filter
+          when EnumFilter
+            @relation = @relation.where(table_name => { filter.attribute => filter_value })
+          when BooleanFilter
+            value = %w(true 1 t).include?(filter_value) ? true : false
+            @relation = @relation.where(table_name => { filter.attribute => value })
+          when StringFilter, TextFilter
+            @relation = @relation.where("#{table_name}.#{filter.attribute} #{like_operator} ?", "%#{filter_value}%")
+          when CustomFilter
+            if filter.scope.kind_of?(Proc)
+              @relation = filter.scope.call(@relation, filter_value)
+            else
+              @relation = @relation.send(filter.scope, filter_value)
+            end
+          end
+        end
+      end
+    end
+
+    module ClassMethods
+      def filter(name, type = :string, options = {}, &block)
+        name = name.to_sym
+
+        unless self.mappings.key?(type)
+          fail MightyGrid::Exceptions::ArgumentError.new("filter for the specified type isn't supported.")
+        end
+
+        if name.present? && self.filters.key?(name)
+          fail MightyGrid::Exceptions::ArgumentError.new("filter with the specified name already exists.")
+        else
+          options.merge!(name: name)
+          options.merge!(model: @klass) unless options.key?(:model)
+          self.filters[name] = self.mappings[type].new(options, &block)
+        end
+      end
+
+      protected
+
+      def inherited(child_class)
+        super(child_class)
+        child_class.filters = self.filters.clone
+      end
+    end
+  end
+end

data/lib/mighty_grid/grid_renderer.rb

@@ -55,7 +55,7 @@ module MightyGrid
       elsif html_or_opts.nil? && block_given?
         @blank_slate_handler = block
       else
-        fail MightyGridArgumentError.new("blank_slate accepts only a string, a block, or :partial => 'path_to_partial' ")
+        fail MightyGrid::Exceptions::ArgumentError.new("blank_slate accepts only a string, a block, or :partial => 'path_to_partial' ")
       end
     end