listings 0.0.3 → 0.1.0

data/app/assets/javascripts/listings.js

@@ -147,7 +147,7 @@ $(function(){
   });
 
   function searchEscape(value) {
-    if (value == /\w+/) {
+    if (value.toString().indexOf(" ") == -1) {
       return value;
     } else if (value.indexOf("'") > -1) {
       return '"' + value + '"';

data/app/views/listings/_filters.html.haml

@@ -1,11 +1,11 @@
 .filters
-  - listing.filter_values.each do |k,v|
+  - listing.filters.each do |filter_view|
     %ul.nav.nav-list.well
       %li.nav-header
-        = "Filter by #{k}"
-      - v.each do |x|
+        = "Filter by #{filter_view.human_name}"
+      - filter_view.values.each do |value|
         %li.filter
-          %a{:href => '#', :'data-key' => k, :'data-value' => x}
-            = x
+          %a{:href => '#', :'data-key' => filter_view.key, :'data-value' => value}
+            = filter_view.value_for(value)
             %i.icon-remove
 

data/app/views/listings/_table_content.html.haml

@@ -9,7 +9,7 @@
         - listing.columns.each do |col|
           %th{'class' => "#{'sortable ' + (col.sort || '') if col.sortable?}" }
             - if col.sortable?
-              = link_to col.human_name, listing.url_for_sort(col.name, col.next_sort_direction), remote: true
+              = link_to col.human_name, listing.url_for_sort(col.key, col.next_sort_direction), remote: true
             - else
               = col.human_name
 

data/lib/listings.rb

@@ -1,5 +1,6 @@
 require 'kaminari'
 require 'bootstrap-kaminari-views'
+require 'listings/sources'
 require 'listings/configuration'
 require 'listings/kaminari_helpers_tag_patch'
 require 'listings/base'

data/lib/listings/base.rb

@@ -15,6 +15,9 @@ module Listings
     attr_accessor :search_criteria
     attr_accessor :search_filters
 
+    attr_reader :data_source
+    delegate :items, to: :data_source
+
     def initialize
       @page_size = self.class.page_size
     end
@@ -36,7 +39,7 @@ module Listings
         self.search_filters = {}
       else
         # otherwise parse the search stripping out allowed filterable fields
-        self.search_filters, self.search_criteria = parse_filter(self.search, self.filters)
+        self.search_filters, self.search_criteria = parse_filter(self.search, self.filters.map(&:key))
       end
     end
 
@@ -63,67 +66,55 @@ module Listings
       return text
     end
 
-    def filter_items(params, items)
+    def filter_items(params)
+      columns # prepare columns
+      filters # prepare filters
+
       self.page = params[param_page] || 1
       self.scope = scope_by_name(params[param_scope])
       self.search = params[param_search]
       parse_search
 
-      items = paginatable(scope.apply(self, items)) unless scope.nil?
+      unless scope.nil?
+        data_source.scope do |items|
+          scope.apply(self, items)
+        end
+      end
 
       if search_criteria.present? && self.searchable?
-        criteria = []
-        values = []
-        self.columns.select(&:searchable?).each do |col|
-          criteria << "#{model_class.table_name}.#{col.name} like ?"
-          values << "%#{search_criteria}%"
-        end
-        items = items.where(criteria.join(' or '), *values)
+        search_fields = self.columns.select(&:searchable?).map &:field
+        data_source.search(search_fields, search_criteria)
       end
 
       if filterable?
-        # pluck filters values before applying filters/pagination/sorting
-        self.filter_values = {}
-        filters.each do |v|
-          self.filter_values[v] = items.pluck("distinct #{v}").reject(&:nil?)
+        filters.each do |filter_view|
+          filter_view.values # prepare values
         end
 
         self.search_filters.each do |key, filter_value|
-          items = items.where("#{model_class.table_name}.#{key} = ?", filter_value)
+          data_source.filter(filter_with_key(key).field, filter_value)
         end
       end
 
       if params.include?(param_sort_by)
-        sort_col = column_with_name(params[param_sort_by])
+        sort_col = column_with_key(params[param_sort_by])
         sort_col.sort = params[param_sort_direction]
-        items = items.reorder("#{sort_col.sort_by} #{params[param_sort_direction]}")
+        data_source.sort(sort_col.field, params[param_sort_direction])
       end
 
       if paginated?
-        items = items.page(page).per(page_size)
-      end
-
-      if items.is_a?(Class)
-        items = items.all
+        data_source.paginate(page, page_size)
       end
 
-      items
+      self.items
     end
 
     def query_items(params)
       @params = params
-      items = self.model_class
+      @data_source = Sources::DataSource.for(self.model_class)
       @has_active_model_source = items.respond_to? :human_attribute_name
 
-      self.items = filter_items(self.scoped_params, paginatable(items))
-    end
-
-    def paginatable(array_or_model)
-      if array_or_model.is_a?(Array) && paginated? && !array_or_model.respond_to?(:page)
-        Kaminari.paginate_array(array_or_model)
-      else
-        array_or_model
-      end
+      filter_items(self.scoped_params)
     end
 
     def has_active_model_source?
@@ -152,8 +143,16 @@ module Listings
       column.value_for(self, item)
     end
 
-    def column_with_name(name)
-      self.columns.find { |c| c.name.to_s == name.to_s }
+    def column_with_key(key)
+      self.columns.find { |c| c.key == key }
+    end
+
+    def filter_with_key(key)
+      self.filters.find { |c| c.key == key }
+    end
+
+    def human_name(field)
+      field.human_name
     end
 
     def searchable?

data/lib/listings/base_field_descriptor.rb

@@ -0,0 +1,21 @@
+module Listings
+  class BaseFieldDescriptor
+    attr_reader :path
+    attr_reader :props
+    attr_reader :proc
+
+    def initialize(path, props, proc)
+      @path = path
+      @props = props
+      @proc = proc
+    end
+
+    def build_field(listing)
+      listing.data_source.build_field(path)
+    end
+
+    def is_field?
+      !path.nil? && !path.is_a?(String)
+    end
+  end
+end

data/lib/listings/base_field_view.rb

@@ -0,0 +1,39 @@
+module Listings
+  class BaseFieldView
+    attr_reader :field
+    attr_reader :listing
+
+    def initialize(listing, field_description)
+      @listing = listing
+      @field_description = field_description
+      @field = if @field_description.is_field?
+        @field_description.build_field(listing)
+      else
+        nil
+      end
+    end
+
+    def path
+      @field_description.path
+    end
+
+    def human_name
+      return @field_description.props[:title] if @field_description.props[:title]
+      return path if path.is_a?(String)
+
+      I18n.t("listings.headers.#{listing.name}.#{key}", default: listing.human_name(field))
+    end
+
+    def key
+      if @field
+        @field.key
+      else
+        path
+      end
+    end
+
+    def is_field?
+      @field_description.is_field?
+    end
+  end
+end

data/lib/listings/column_descriptor.rb

@@ -1,56 +1,16 @@
 module Listings
-  class ColumnDescriptor
-    attr_reader :name
-    attr_reader :props
-
-    def initialize(listing_class, name, props = {}, proc)
-      @listing_class = listing_class
-      @name = name
-      @props = props.reverse_merge! searchable: false, sortable: true
-      @proc = proc
-    end
-
-    def value_for(listing, model)
-      if @proc
-        listing.instance_exec model, &@proc
-      elsif model.is_a?(Hash)
-        model[name]
-      else
-        model.send(name)
-      end
-    end
-
-    def human_name(listing)
-      return '' if name.blank?
-
-      fallback = if is_model_column?(listing)
-        listing.model_class.human_attribute_name(name)
-      else
-        name
-      end
-      I18n.t("listings.headers.#{listing.name}.#{name}", default: fallback)
+  class ColumnDescriptor < BaseFieldDescriptor
+    def initialize(path, props, proc)
+      props = props.reverse_merge! searchable: false, sortable: true
+      super(path, props, proc)
     end
 
-    def searchable?(listing)
-      @props[:searchable] && is_model_column?(listing)
+    def searchable?
+      @props[:searchable] && is_field?
     end
 
     def sortable?
-      s = @props[:sortable]
-      if sortable_property_is_expression?
-        true # s is the expression that should be used for sorting
-      else
-        s # s is Boolean
-      end
-    end
-
-    def sortable_property_is_expression?
-      s = @props[:sortable]
-      !(!!s == s)
-    end
-
-    def is_model_column?(listing)
-      name.is_a?(Symbol) && listing.has_active_model_source?
+      @props[:sortable] && is_field?
     end
   end
 end

data/lib/listings/column_view.rb

@@ -1,50 +1,41 @@
 module Listings
-  class ColumnView
+  class ColumnView < BaseFieldView
     def initialize(listing, column_description)
-      @listing = listing
-      @column_description = column_description
+      super
     end
 
-    def value_for(model)
-      @column_description.value_for(@listing, model)
+    def column_description
+      @field_description
     end
 
-    def human_name
-      @column_description.human_name(@listing)
+    def value_for(model)
+      if @field_description.proc
+        if is_field?
+          listing.instance_exec model, field.value_for(model), &@field_description.proc
+        else
+          listing.instance_exec model, &@field_description.proc
+        end
+      else
+        field.value_for(model)
+      end
     end
 
     def searchable?
-      @column_description.searchable?(@listing)
-    end
-
-    def is_model_column?
-      @column_description.is_model_column?(@listing)
-    end
-
-    def name
-      @column_description.name
+      column_description.searchable?
     end
 
     def sortable?
-      @listing.is_sortable? && @column_description.sortable? && (self.is_model_column? || @column_description.sortable_property_is_expression?)
-    end
-
-    def sort_by
-      if @column_description.sortable_property_is_expression?
-        @column_description.props[:sortable]
-      else
-        name
-      end
+      listing.sortable? && column_description.sortable?
     end
 
     def cell_css_class
-      @column_description.props[:class]
+      column_description.props[:class]
     end
 
     attr_accessor :sort
 
     def next_sort_direction
-      sort == 'asc' ? 'desc' : 'asc'
+      self.sort == Sources::DataSource::ASC ? Sources::DataSource::DESC : Sources::DataSource::ASC
     end
   end
 end

data/lib/listings/configuration_methods.rb

@@ -1,6 +1,10 @@
 require 'listings/scope_descriptor'
+require 'listings/base_field_descriptor'
+require 'listings/base_field_view'
 require 'listings/column_descriptor'
 require 'listings/column_view'
+require 'listings/filter_descriptor'
+require 'listings/filter_view'
 
 module Listings
   module ConfigurationMethods
@@ -9,10 +13,8 @@ module Listings
     included do
       attr_accessor :page
       attr_accessor :scope
-      attr_accessor :items
       attr_accessor :search
       attr_accessor :page_size
-      attr_accessor :filter_values
 
       def scopes
         @scopes ||= self.class.process_scopes
@@ -28,12 +30,12 @@ module Listings
         self.class.export_formats
       end
 
-      def is_sortable?
+      def sortable?
         opt = self.class.sortable_options
         if opt.nil?
           true
         else
-          if opt.length == 1 && !!opt.first == opt.first
+          if opt.length == 1
             opt.first
           else
             true
@@ -50,7 +52,9 @@ module Listings
       end
 
       def filters
-        self.class.filters
+        @filters ||= self.class.filters.map do |fd|
+          FilterView.new(self, fd)
+        end
       end
     end
 
@@ -83,7 +87,6 @@ module Listings
         @scopes = scopes.select{ |s| !s.deferred? }
       end
 
-
       def model(model_class = nil, &proc)
         if !model_class.nil?
           self.send(:define_method, 'model_class') do
@@ -98,8 +101,19 @@ module Listings
         @columns ||= []
       end
 
-      def column(name = '', props = {}, &proc)
-        columns << ColumnDescriptor.new(self, name, props, proc)
+      def column(path = '', props = {}, &proc)
+        path, props = fix_path_props(path, props)
+        columns << ColumnDescriptor.new(path, props, proc)
+      end
+
+      def fix_path_props(path, props)
+        if path.is_a?(Hash) && path.size > 1
+          props = props.merge(path)
+          path = Hash[[path.first]]
+          props.except!(path.first.first)
+        end
+
+        [path, props]
       end
 
       def selectable #(column = :id)
@@ -121,6 +135,8 @@ module Listings
         end
       end
 
+      # call `sortable false` make listing non sorted
+      # default is `sortable true`
       def sortable(*options)
         @sortable_options = options
       end
@@ -137,8 +153,9 @@ module Listings
         @filters ||= []
       end
 
-      def filter name
-        filters << name
+      def filter(path = '', props = {}, &proc)
+        path, props = fix_path_props(path, props)
+        filters << FilterDescriptor.new(path, props, proc)
       end
     end
   end