acts_as_data_table 0.0.1

data/lib/acts_as_data_table_helper.rb.bak

@@ -0,0 +1,165 @@
+module ActsAsDataTableHelper
+
+  def scope_filter_link(group, filter, options = {})
+
+  end
+#
+#   #----------------------------------------------------------------
+#   #                          Filters
+#   #----------------------------------------------------------------
+#
+#   # Generates a link to to add or remove a certain filter to the
+#   # current controller/action.
+#   # Parameters:
+#   # +group+::            The group name the filter belongs to
+#   #
+#   # ===Options
+#   #   +:filter+::        The filter name to be applied
+#   #   +:caption+::       The link caption, defaults to a localization
+#   #   +:remove+::        If set to +true+, the filter will be removed instead of (re-)added
+#   #   +:args+::          Args to be used when applying the filter
+#   #   +:auto_remove+::   If set to true, a click on an active filter will remove it again.
+#   #
+#   #   All other options will be used as html_options for the resulting link
+#   #--------------------------------------------------------------
+#   def scope_filter_link(group, options = {})
+#     filter_name     = options.delete(:filter)
+#     caption         = options.delete(:caption) || t("activerecord.scopes.#{searchable_session.model.table_name}.#{filter_name}")
+#     args            = options.delete(:args)
+#     surrounding_tag = options.delete(:surrounding)
+#     auto_remove     = options.delete(:auto_remove) && searchable_session.active_filter?(group, filter_name, args)
+#     remove          = options.delete(:remove)
+#
+#     if remove || auto_remove
+#       url = {:scope_filters => {:remove => group}}
+#     else
+#       url = {:scope_filters => {:group => group, :name => filter_name, :args => args}}
+#     end
+#
+#     classes = options[:class].try(:split, ' ') || []
+#     classes << 'active' if searchable_session.active_filter?(group, filter_name, args)
+#     options[:class] = classes.join(' ')
+#     link = link_to_remote caption, :url => url, :method => :get, :html => options
+#     surrounding_tag ? content_tag(surrounding_tag, link, :class => options[:class]) : link
+#   end
+#
+#   # Generates the URL to remove all filters from the current action
+#   #--------------------------------------------------------------
+#   def remove_all_scope_filters_url
+#     {:scope_filters => {:remove_all => true}}
+#   end
+#
+#   # Generates the URL to be used as form action to add a new filter
+#   #--------------------------------------------------------------
+#   def scope_filter_form_url(group, filter_name)
+#     {:scope_filters => {:group => group, :name => filter_name}}
+#   end
+#
+#   # Generates the form element name for filter args inside
+#   # a form
+#   #--------------------------------------------------------------
+#   def scope_filter_field_name(arg_name)
+#     "scope_filters[args][#{arg_name}]"
+#   end
+#
+#   # Generates a form field id for the given scope and arg
+#   #--------------------------------------------------------------
+#   def scope_filter_field_id(scope, arg_name)
+#     [scope, arg_name].join('_')
+#   end
+#
+#   # Builds the caption for an active filter
+#   #--------------------------------------------------------------
+#   def scope_filter_caption(active_filter)
+#     searchable_session.model.scope_caption(active_filter[:filter], active_filter[:args])
+#   end
+#
+#   # Returns the arguments for a currently active filter or nil
+#   # if the given filter is currently not active.
+#   #-------------------------------------------------------------
+#   def scope_filter_arg(filter_name, arg_name)
+#     @filter_args ||= {}
+#     @filter_args[filter_name.to_s] ||= {}
+#
+#     unless @filter_args[filter_name.to_s].has_key? arg_name.to_s
+#       filter = active_scope_filters.select{|f| f[:filter].to_s == filter_name.to_s}.first
+#       if filter
+#         @filter_args[filter_name.to_s] = filter[:args]
+#       else
+#         #If the filter is currently not active, cache the argument anyway with nil
+#         @filter_args[filter_name.to_s] ||= {}
+#         @filter_args[filter_name.to_s][arg_name.to_s] = nil
+#       end
+#     end
+#
+#     @filter_args[filter_name.to_s][arg_name.to_s]
+#   end
+#
+#   # Returns all active filters in a format which is easier to
+#   # process than the original hash structure. Each element of the
+#   # returned array contains the following properties:
+#   #
+#   # +:delete_url+:: A url hash which contains the necessary parameters to
+#   #                 remove the current filter from the active list
+#   #
+#   # +:group+::      The filter group this filter is in (in case you want to
+#   #                 user the +filter_link+ helper method)
+#   #
+#   # +:filter+::     The filter name
+#   #
+#   # +:args+::       The arguments the filter was applied to (for display reasons)
+#   #--------------------------------------------------------------
+#   def active_scope_filters
+#     return @active_filters if @active_filters
+#
+#     @active_filters = []
+#     searchable_session.active_filters.each do |group, filters|
+#       filters.each do |filter, args|
+#         @active_filters << {:delete_url => {:scope_filters => {:remove => group}},
+#                             :group      => group,
+#                             :filter     => filter,
+#                             :args       => HashWithIndifferentAccess.new(args)}
+#       end
+#     end
+#     @active_filters
+#   end
+#
+#   # Returns the active scope filter for a given filter group
+#   # If you hand in a block, the filter will be available inside
+#   # If there is no active filter for the given group,
+#   # the block is not executed.
+#   #--------------------------------------------------------------
+#   def active_scope_filter(group, &proc)
+#     filter = active_scope_filters.select {|sf| sf[:group].to_s == group.to_s}.first
+#     if block_given?
+#       yield filter if filter
+#     else
+#       filter
+#     end
+#   end
+#
+#   #----------------------------------------------------------------
+#   #                        Sorting Columns
+#   #----------------------------------------------------------------
+#
+#   def sortable_column(model_name, column_name, caption = nil, &proc)
+#     sortable = Struct.new(:caption, :direction, :active, :url_replace, :url_add_toggle, :url_remove).new
+#
+#     sortable.direction      = searchable_session.sorting_direction(model_name, column_name)
+#     sortable.active         = sortable.direction.present?
+#
+#     sortable.url_replace    = {:sorting_columns => {:replace => true, :model_name => model_name, :column_name => column_name}}
+#     sortable.url_add_toggle = {:sorting_columns => {:add     => true, :model_name => model_name, :column_name => column_name}}
+#     sortable.url_remove     = {:sorting_columns => {:remove  => true, :model_name => model_name, :column_name => column_name}}
+#     sortable.caption        = caption
+#
+#
+#     #If a block is given, we let the user handle the content of the table
+#     #header himself. Otherwise, we'll generate the default links.
+#     if block_given?
+#       yield sortable
+#     else
+#       render :partial => 'shared/sortable_column', :object => sortable
+#     end
+#   end
+end

data/lib/named_scope_filters.rb

@@ -0,0 +1,273 @@
+module Stex
+  module Acts
+    module DataTable
+      module NamedScopeFilters
+        module ActiveRecord
+          def self.included(base)
+            base.send :extend, ClassMethods
+          end
+
+          module ClassMethods
+            # Generates methods to automatically combine named scopes
+            # based on the given input
+            # Arguments are all named scopes you'd like to include into
+            # The parameter includes all filters which may be used by the automatic
+            # data filtering later.
+            # {:group_name => [scope1, scope2, [scope_with_arguments, arg1, arg2], scope4]}
+            #--------------------------------------------------------------
+            def has_named_scope_filters(filter_groups = {})
+              if filter_groups.empty? #No groups given, no filters created
+                throw 'is_named_scope_filterable needs arguments to run.'
+              end
+
+              #Convert filters
+              filter_groups.each do |group_name, filters|
+                filters = Array(filters)
+                filters.map! {|f| Array(f)}
+
+                #Check if all given named scopes actually exist
+                filters.each do |ns|
+                  scope_name = ns.first
+                  logger.warn "The scope '#{scope_name}' in group '#{group_name}' does not exist." unless scopes.has_key?(scope_name)
+                end
+              end
+
+              #Create a method to test if a given filter is valid
+              define_singleton_method 'named_scope_filter?' do |group, name, args|
+                filter_groups[group] && filter_groups[group].assoc(name).present?
+              end
+
+              #Generate a method to actually apply the various filters to the current
+              #model.
+              define_singleton_method(:apply_scope_filters) do |scope_filter_groups|
+                result = self
+                scope_filter_groups.each do |group_name, scope_filters|
+                  set_scopes = filter_groups[group_name.to_sym]
+                  scope_filters.each do |filter, args|
+                    set_filter = set_scopes.assoc(filter.to_sym)
+                    arg_names  = set_filter.drop(1)
+                    scope_args = arg_names.map {|a| args[a.to_s]}
+                    result = result.send(set_filter.first, *scope_args)
+                  end
+                end
+                result
+              end
+
+              #Generate a method to label applied filters.
+              #This method only does default labelling and will most likely be
+              #overridden in the actual model
+              define_singleton_method(:scope_caption) do |scope_name, args|
+                options = {:scope => "activerecord.scopes.#{table_name}", :default => scope_name}
+                symbol_args = {}
+                args.each do |k,v|
+                  symbol_args[k.to_sym] = v
+                end
+                I18n.t(scope_name, options.merge(symbol_args))
+              end
+            end
+
+            #def is_named_scope_sortable(*args)
+            #  options = args.pop if args.last.is_a?(Hash)
+            #  processed_args = args.map {|a| generate_sortable_columns_and_includes(a)}.flatten
+            #
+            #  column_names = []
+            #  unfiltered_includes = []
+            #
+            #  processed_args.each do |arg|
+            #    column_names += arg[:columns]
+            #    unfiltered_includes += arg[:includes]
+            #  end
+            #
+            #  #TODO: filter longer include chains, have to get a real example first.
+            #
+            #
+            #  1
+            #end
+
+
+            ## Processes arguments for the sortable generator
+            ## Returns column names and necessary includes
+            ##--------------------------------------------------------------
+            #def generate_sortable_columns_and_includes(arg, model = self)
+            #  columns  = []
+            #  includes = []
+            #  #Associations from the current model
+            #  if arg.is_a?(Hash)
+            #    arg.each do |association_name, columns_and_associations|
+            #      association_endpoint = Stex::Acts::Searchable::DataHolder.graph.associations_for(model)[association_name.to_s]
+            #      Array(columns_and_associations).each do |new_arg|
+            #        processed_arg = generate_sortable_columns_and_includes(new_arg, association_endpoint)
+            #        columns += processed_arg[:columns]
+            #        if processed_arg[:includes].any?
+            #          includes << {association_name => processed_arg[:includes]}
+            #        else
+            #          includes << association_name if processed_arg[:columns].any?
+            #        end
+            #      end
+            #    end
+            #  else
+            #    columns << "#{model.table_name}.#{arg}" if model.column_names.include?(arg.to_s)
+            #  end
+            #
+            #  {:columns => columns, :includes => includes}
+            #end
+          end
+        end
+
+        module ActionController
+          def self.included(base)
+            base.send :extend, ClassMethods
+          end
+
+          module ClassMethods
+            # Generates the necessary controller methods to add and remove filters
+            # Expects the model name and a list of methods the filters will be used for
+            # Important: Do not use the model constant (e.g. User), it might break
+            # your database setup.
+            #
+            # == Examples
+            # scope_filters :user, :index
+            #--------------------------------------------------------------
+            def scope_filters(model_name, *args)
+              helper_method :searchable_session
+
+              before_filter :add_scope_filter, :only => args
+              before_filter :remove_scope_filter, :only => args
+              before_filter :remove_all_scope_filters, :only => args
+              before_filter :load_active_scope_filters, :only => args
+
+              helper :acts_as_data_table
+
+              # Adds a filter to the current data table. Works with the
+              # named scope filterable plugin.
+              # Expects the following params to be set:
+              #  :scope_filters =>
+              #   :group -- The group the named scope belongs to
+              #   :name  -- The named scope name inside the group
+              #   :args  -- Array of arguments to be passed to the named scope
+              # If any of these params (except filter_args which is optional)
+              # is not set, the filter will not be added.
+              #--------------------------------------------------------------
+              define_method(:add_scope_filter) do
+                return if params[:scope_filters].blank?
+                return if [:group, :name].any? { |p| params[:scope_filters][p].blank? }
+
+                group = params[:scope_filters][:group].to_sym
+                name  = params[:scope_filters][:name].to_sym
+                args  = params[:scope_filters][:args]
+                args  = nil if args.blank? #No empty string here
+
+                model = model_name.to_s.classify.constantize
+
+                #If the given filter is not valid, do not add it to the filters list
+                return unless model.named_scope_filter?(group, name, args)
+                searchable_session.add_filter(group, name, args)
+              end
+
+              # Removes a filter from the current data table.
+              # Expects the following params to be set:
+              # :scope_filters =>
+              #   :group -- The group the named scope belongs to
+              #   :remove => true
+              #--------------------------------------------------------------
+              define_method(:remove_scope_filter) do
+                return if params[:scope_filters].blank?
+                return if params[:scope_filters][:remove].blank?
+                searchable_session.remove_filter(params[:scope_filters][:remove])
+              end
+
+              # Removes all filters from the current controller and action
+              #--------------------------------------------------------------
+              define_method(:remove_all_scope_filters) do
+                return if params[:scope_filters].blank?
+                return if params[:scope_filters][:remove_all].blank?
+                searchable_session.remove_all_filters
+              end
+
+              # Session Helper instance accessor
+              #--------------------------------------------------------------
+              define_method(:searchable_session) do
+                @searchable_session = Stex::Acts::DataTable::SessionHelper.new(session, controller_path, action_name, model_name)
+              end
+
+              # Loads the active filters into an instance variable, just in case
+              # that naming changes later
+              #--------------------------------------------------------------
+              define_method(:load_active_scope_filters) do
+                @loaded_scope_filters = searchable_session.active_filters
+              end
+
+              #Make the helper methods private so rails does not handle them as actions
+              private :add_scope_filter, :remove_scope_filter, :searchable_session, :load_active_scope_filters
+            end
+
+            # Adds methods for automatic column sorting to the controller
+            # Parameters:
+            # actions_and_defaults:: Hash of actions which will be used to
+            #         display sortable content and their initial sorting
+            #         columns.
+            #
+            # == Example
+            #   column_sorting :index => [['users.last_name', 'ASC'], ['users.first_name', 'ASC']]
+            #--------------------------------------------------------------
+            def column_sorting(actions_and_defaults = {})
+
+              before_filter :add_or_toggle_sorting_column, :only => actions_and_defaults.keys
+              before_filter :replace_sorting_column, :only => actions_and_defaults.keys
+              before_filter :remove_sorting_column, :only => actions_and_defaults.keys
+              before_filter :load_sorting_columns, :only => actions_and_defaults.keys
+
+              param_namespace = :sorting_columns
+
+              # Adds a sorting column to the current sorting columns or
+              # toggles its direction if it is already part of the
+              # active sorting.
+              #
+              # Parameters
+              #   :sorting_columns => {
+              #     :model_name  => 'sale',
+              #     :column_name => 'reference'
+              #   }
+              #--------------------------------------------------------------
+              define_method(:add_or_toggle_sorting_column) do
+                return if params[param_namespace].blank?
+                return if [:add, :model_name, :column_name].select {|p| params[param_namespace][p].blank?}.any?
+                searchable_session.add_or_toggle_sorting_column(params[param_namespace][:model_name], params[param_namespace][:column_name])
+              end
+
+              # Replaces all current sorting columsn with the given one
+              #--------------------------------------------------------------
+              define_method(:replace_sorting_column) do
+                return if params[param_namespace].blank?
+                return if [:replace, :model_name, :column_name].select {|p| params[param_namespace][p].blank?}.any?
+                searchable_session.replace_sorting_column(params[param_namespace][:model_name], params[param_namespace][:column_name])
+              end
+
+              # Removes a column from the current sorting columns
+              #--------------------------------------------------------------
+              define_method(:remove_sorting_column) do
+                return if params[param_namespace].blank?
+                return if [:remove, :model_name, :column_name].select {|p| params[param_namespace][p].blank?}.any?
+                searchable_session.remove_sorting_column(params[param_namespace][:model_name], params[param_namespace][:column_name])
+              end
+
+              # Loads the current sorting string into an instance variable
+              #--------------------------------------------------------------
+              define_method(:load_sorting_columns) do
+                @current_sorting_string = searchable_session.sorting_columns_string
+
+                #If there is no user-set sorting, load the default sorting into the session.
+                if @current_sorting_string.blank?
+                  searchable_session.load_sorting_defaults(actions_and_defaults[action_name.to_sym])
+                end
+
+                @current_sorting_string = searchable_session.sorting_columns_string
+              end
+
+            end
+          end
+        end
+      end
+    end
+  end
+end

data/lib/tasks/acts_as_data_table.rake

@@ -0,0 +1,4 @@
+# desc "Explaining what the task does"
+# task :acts_as_searchable do
+#   # Task goes here
+# end

data/rails/init.rb

@@ -0,0 +1,4 @@
+#Automatically include the js_erb helper in each controller
+# ActionController::Base.class_eval do
+#   helper :rjs
+# end

data/test/acts_as_searchable_test.rb

@@ -0,0 +1,8 @@
+require 'test_helper'
+
+class ActsAsSearchableTest < ActiveSupport::TestCase
+  # Replace this with your real tests.
+  test "the truth" do
+    assert true
+  end
+end

data/test/test_helper.rb

@@ -0,0 +1,4 @@
+require 'rubygems'
+require 'test/unit'
+require 'active_support'
+require 'active_support/test_case'

metadata

@@ -0,0 +1,142 @@
+--- !ruby/object:Gem::Specification 
+name: acts_as_data_table
+version: !ruby/object:Gem::Version 
+  hash: 29
+  prerelease: 
+  segments: 
+  - 0
+  - 0
+  - 1
+  version: 0.0.1
+platform: ruby
+authors: 
+- Stefan Exner
+autorequire: 
+bindir: bin
+cert_chain: []
+
+date: 2015-04-30 00:00:00 Z
+dependencies: 
+- !ruby/object:Gem::Dependency 
+  name: bundler
+  prerelease: false
+  requirement: &id001 !ruby/object:Gem::Requirement 
+    none: false
+    requirements: 
+    - - ~>
+      - !ruby/object:Gem::Version 
+        hash: 1
+        segments: 
+        - 1
+        - 7
+        version: "1.7"
+  type: :development
+  version_requirements: *id001
+- !ruby/object:Gem::Dependency 
+  name: rake
+  prerelease: false
+  requirement: &id002 !ruby/object:Gem::Requirement 
+    none: false
+    requirements: 
+    - - ~>
+      - !ruby/object:Gem::Version 
+        hash: 35
+        segments: 
+        - 10
+        - 0
+        version: "10.0"
+  type: :development
+  version_requirements: *id002
+- !ruby/object:Gem::Dependency 
+  name: rails
+  prerelease: false
+  requirement: &id003 !ruby/object:Gem::Requirement 
+    none: false
+    requirements: 
+    - - ~>
+      - !ruby/object:Gem::Version 
+        hash: 5
+        segments: 
+        - 2
+        - 3
+        version: "2.3"
+  type: :runtime
+  version_requirements: *id003
+description: Adds methods to models and controllers to perform automatic filtering, sorting and multi-column-queries without having to worry about the implementation.
+email: 
+- stex@sterex.de
+executables: []
+
+extensions: []
+
+extra_rdoc_files: []
+
+files: 
+- .gitignore
+- Gemfile
+- LICENSE.txt
+- README.md
+- Rakefile
+- acts_as_data_table.gemspec
+- app/coffeescripts/acts_as_data_table.coffee
+- app/helpers/acts_as_data_table_helper.rb
+- config/locales/acts_as_data_table.en.yml
+- generators/acts_as_data_table/acts_as_data_table_generator.rb
+- generators/acts_as_data_table/templates/assets/js/acts_as_data_table.js
+- init.rb
+- lib/acts_as_data_table.rb
+- lib/acts_as_data_table/multi_column_scopes.rb
+- lib/acts_as_data_table/scope_filters/action_controller.rb
+- lib/acts_as_data_table/scope_filters/active_record.rb
+- lib/acts_as_data_table/scope_filters/form_helper.rb
+- lib/acts_as_data_table/scope_filters/validator.rb
+- lib/acts_as_data_table/session_helper.rb
+- lib/acts_as_data_table/shared/action_controller.rb
+- lib/acts_as_data_table/shared/session.rb
+- lib/acts_as_data_table/sortable_columns/action_controller.rb
+- lib/acts_as_data_table/sortable_columns/active_record.rb
+- lib/acts_as_data_table/sortable_columns/renderers/bootstrap2.rb
+- lib/acts_as_data_table/sortable_columns/renderers/default.rb
+- lib/acts_as_data_table/version.rb
+- lib/acts_as_data_table_helper.rb.bak
+- lib/named_scope_filters.rb
+- lib/tasks/acts_as_data_table.rake
+- rails/init.rb
+- test/acts_as_searchable_test.rb
+- test/test_helper.rb
+homepage: https://www.github.com/stex/acts_as_data_table
+licenses: 
+- MIT
+post_install_message: 
+rdoc_options: []
+
+require_paths: 
+- lib
+required_ruby_version: !ruby/object:Gem::Requirement 
+  none: false
+  requirements: 
+  - - ">="
+    - !ruby/object:Gem::Version 
+      hash: 3
+      segments: 
+      - 0
+      version: "0"
+required_rubygems_version: !ruby/object:Gem::Requirement 
+  none: false
+  requirements: 
+  - - ">="
+    - !ruby/object:Gem::Version 
+      hash: 3
+      segments: 
+      - 0
+      version: "0"
+requirements: []
+
+rubyforge_project: 
+rubygems_version: 1.8.22
+signing_key: 
+specification_version: 3
+summary: Adds automatic scope based filtering and column sorting to controllers and models.
+test_files: 
+- test/acts_as_searchable_test.rb
+- test/test_helper.rb