with_filters 0.1.0

data/lib/with_filters/models/filter/choice.rb

@@ -0,0 +1,23 @@
+module WithFilters
+  module Filter
+    # @private
+    class Choice
+      attr_reader :field_name, :label, :value, :attrs
+
+      def initialize(field_name, label, value, options = {})
+        @field_name = "#{field_name}[]"
+        @label      = label
+        @value      = value
+
+        options[:id] ||= "#{field_name}_#{value}".gsub(']', '').gsub(/[^-a-zA-Z0-9:.]/, '_')
+
+        @selected = !!options.delete(:selected)
+        @attrs    = options
+      end
+
+      def selected?
+        @selected
+      end
+    end
+  end
+end

data/lib/with_filters/models/filter/collection.rb

@@ -0,0 +1,28 @@
+module WithFilters
+  module Filter
+    # @private
+    class Collection < Array
+      def initialize(field_name, choices, options = {})
+        choices = choices.to_a if choices.is_a?(Range)
+
+        selected = Array.wrap(options[:selected]).map(&:to_s)
+
+        choices.map do |element|
+          text, value, choice_options = if element.is_a?(Array)
+                                          html_attrs = element.detect {|e| Hash === e} || {}
+                                          element = element.reject {|e| Hash === e}  
+                                          [element.first.to_s, element.last, html_attrs]
+                                        elsif !element.is_a?(String) && element.respond_to?(:first) && element.respond_to?(:last)
+                                          [element.first.to_s, element.last, {}] 
+                                        else
+                                          [element.to_s, element, {}] 
+                                        end
+
+          choice_options[:selected] = 'selected' if selected.include?(value.to_s)
+
+          self.push(Choice.new(field_name, text, value, choice_options))
+        end
+      end
+    end
+  end
+end

data/lib/with_filters/models/filter/filter.rb

@@ -0,0 +1,59 @@
+module WithFilters
+  # @private
+  module Filter
+    TYPES = {
+      :'datetime-local' => Text,
+      text:     Text,
+      email:    Text,
+      url:      Text,
+      tel:      Text,
+      number:   Text,
+      range:    Text,
+      date:     Text,
+      month:    Text,
+      week:     Text,
+      time:     Text,
+      datetime: Text,
+      search:   Text,
+      color:    Text,
+      hidden:   Text,
+      checkbox: CheckBox,
+      radio:    Radio,
+      select:   Select
+    }
+
+    RANGED_TYPES = {
+      :'datetime-local' => TextRange,
+      text:     TextRange,
+      email:    TextRange,
+      url:      TextRange,
+      tel:      TextRange,
+      number:   TextRange,
+      range:    TextRange,
+      date:     TextRange,
+      month:    TextRange,
+      week:     TextRange,
+      time:     TextRange,
+      datetime: TextRange,
+      search:   TextRange,
+      color:    TextRange,
+      select:   SelectRange
+    }
+
+    def self.create(name, namespace, value, options = {})
+      as = options.delete(:as)
+
+      options[:type] = as.to_s
+
+      TYPES[as].new(name, namespace, value, options)
+    end
+
+    def self.create_range(name, namespace, value, options = {})
+      as = options.delete(:as)
+
+      options[:type] = as.to_s
+
+      RANGED_TYPES[as].new(name, namespace, value, options)
+    end
+  end
+end

data/lib/with_filters/models/filter/radio.rb

@@ -0,0 +1,7 @@
+module WithFilters
+  module Filter
+    # @private
+    class Radio < Base
+    end
+  end
+end

data/lib/with_filters/models/filter/select.rb

@@ -0,0 +1,22 @@
+module WithFilters
+  module Filter
+    # @private
+    class Select < Base
+      def initialize(name, namespace, value, options = {})
+        collection = options.delete(:collection) if options[:collection].is_a?(String)
+        if collection
+          Array.wrap(value).each do |v|
+            matched = collection.sub!(/(<option[^>]*value\s*=\s*['"]?#{v}[^>]*)/, '\1 selected="selected"')
+            unless matched
+              collection.sub!(/>#{v}</, " selected=\"selected\">#{v}<")
+            end 
+          end
+        end
+
+        super
+
+        @collection = collection if collection
+      end
+    end
+  end
+end

data/lib/with_filters/models/filter/select_range.rb

@@ -0,0 +1,15 @@
+module WithFilters
+  module Filter
+    # @private
+    class SelectStart < BaseStart
+    end
+
+    # @private
+    class SelectStop < BaseStop
+    end
+
+    # @private
+    class SelectRange < BaseRange
+    end
+  end
+end

data/lib/with_filters/models/filter/text.rb

@@ -0,0 +1,30 @@
+module WithFilters
+  module Filter
+    # @private
+    class Text < Base
+      def initialize(name, namespace, value, options = {})
+        super
+
+        if @attrs[:type] != :text
+          new_partial = @to_partial_path.split(File::SEPARATOR)
+          new_partial[-1] = "_#{new_partial[-1]}_as_#{@attrs[:type]}.*"
+
+          @to_partial_path << "_as_#{@attrs[:type]}" if Dir.glob(File.join(Rails.root, 'app', 'views', *new_partial)).any?
+        end
+      end
+
+      def create_partial_path
+        partial_path = nil
+        if @theme and @attrs[:type] != :text
+          themed_partial_path = self.class.name.underscore.split(File::SEPARATOR).insert(1, @theme)
+          themed_partial_path[themed_partial_path.length - 1] << "_as_#{@attrs[:type]}"
+          if Dir.glob(File.join(Rails.root, 'app', 'views', *themed_partial_path).sub(/([^#{File::SEPARATOR}]+?)$/, '_\1.*')).any?
+            partial_path = themed_partial_path.join(File::SEPARATOR)
+          end
+        end
+
+        partial_path || super
+      end
+    end
+  end
+end

data/lib/with_filters/models/filter/text_range.rb

@@ -0,0 +1,15 @@
+module WithFilters
+  module Filter
+    # @private
+    class TextStart < BaseStart
+    end
+
+    # @private
+    class TextStop < BaseStop
+    end
+
+    # @private
+    class TextRange < BaseRange
+    end
+  end
+end

data/lib/with_filters/models/filter_form.rb

@@ -0,0 +1,93 @@
+module WithFilters
+  class FilterForm
+    attr_reader :attrs, :to_partial_path, :filters, :param_namespace, :hidden_filters, :actions
+
+    # @see ActionViewExtension#filter_form_for
+    #
+    # @since 0.1.0
+    def initialize(records, values = {}, options = {})
+      @records = records
+      @values  = values
+
+      @theme = options.delete(:theme)
+      @attrs = options.reverse_merge(novalidate: 'novalidate', method: 'get')
+
+      @to_partial_path = self.class.name.underscore
+      @param_namespace = @records.with_filters_data[:param_namespace]
+      @hidden_filters  = []
+      @filters         = []
+      @actions         = []
+    end
+
+    # @see input
+    #
+    # @since 0.1.0
+    def hidden(name, options = {})
+      options.merge!(as: :hidden)
+
+      input(name, options)
+    end
+
+    # @param [Symbol] name
+    # @param [Hash] options
+    #
+    # @since 0.1.0
+    def input(name, options = {})
+      options[:as] = find_as(name, options[:collection]) unless options[:as]
+      options.merge!(theme: @theme)
+      as = options[:as]
+
+      filter = WithFilters::Filter.create(name, self.param_namespace, @values[name], options)
+
+      (as == :hidden ? @hidden_filters : @filters).push(filter)
+    end
+
+    # @param [Symbol] name
+    # @param [Hash] options
+    #
+    # @since 0.1.0
+    def input_range(name, options = {})
+      options[:as] = find_as(name, options[:collection]) unless options[:as]
+      options.merge!(theme: @theme)
+
+      @filters.push(WithFilters::Filter.create_range(name, self.param_namespace, @values[name] || {}, options))
+    end
+
+    # @param [Symbol] type
+    # @param [Hash] options
+    #
+    # @since 0.1.0
+    def action(type, options = {})
+      @actions.push(WithFilters::Action.new(type, options))
+    end
+
+    private
+
+    # Converts a database column type to an input type.
+    #
+    # @param [Symbol] name
+    # @param [Boolean] has_collection Indicates whether or not there is a collection
+    #   associated with the input data.
+    #
+    # @since 0.1.0
+    def find_as(name, has_collection)
+      return :select if has_collection
+
+      case @records.with_filters_data[:column_types][name]
+      when :integer, :float, :decimal then :number
+      when :date then :date
+      when :time then :time
+      when :datetime, :timestamp then :datetime
+      when :boolean then :checkbox
+      when :string
+        case name
+        when /email/ then :email
+        when /url/ then :url
+        when /phone/ then :tel
+        else :text
+        end
+      else :text
+      end
+    end
+  end
+end

data/lib/with_filters/value_prep/boolean_prep.rb

@@ -0,0 +1,10 @@
+module WithFilters
+  module ValuePrep
+    # @private
+    class BooleanPrep < DefaultPrep
+      def prepare_value(value)
+        (super == 'on')
+      end
+    end
+  end
+end

data/lib/with_filters/value_prep/date_prep.rb

@@ -0,0 +1,10 @@
+module WithFilters
+  module ValuePrep
+    # @private
+    class DatePrep < DefaultPrep
+      def prepare_value(value)
+        super.to_date
+      end
+    end
+  end
+end

data/lib/with_filters/value_prep/date_time_prep.rb

@@ -0,0 +1,51 @@
+module WithFilters
+  module ValuePrep
+    # @private
+    class DateTimePrep < DefaultPrep
+      def prepare_value(value)
+        value = super
+        date_info = Date._parse(value)
+
+        if date_info[:sec_fraction]
+          to_parsed_s(value, {}, date_info[:sec_fraction].to_f)
+        else
+          {start: prepare_start_value(value), stop: prepare_stop_value(value)}
+        end
+      end
+
+      def prepare_start_value(value)
+        date_info = Date._parse(value)
+
+        if date_info[:sec_fraction]
+          to_parsed_s(value, {}, date_info[:sec_fraction])
+        else
+          to_parsed_s(value)
+        end
+      end
+
+      def prepare_stop_value(value)
+        date_info = Date._parse(value)
+
+        if date_info[:sec_fraction]
+          to_parsed_s(value, {}, date_info[:sec_fraction])
+        elsif date_info[:sec]
+          to_parsed_s(value, seconds: 1)
+        elsif date_info[:min]
+          to_parsed_s(value, minutes: 1)
+        elsif date_info[:hour]
+          to_parsed_s(value, hours: 1)
+        elsif date_info[:mday]
+          to_parsed_s(value, days: 1)
+        end
+      end
+
+      private
+
+      def to_parsed_s(value, advance_options = {}, sec_decimal = nil)
+        parsed_s = Time.zone.parse(value).advance(advance_options).to_s(:db)
+        parsed_s << ('%.6f' % sec_decimal)[1..-1] if sec_decimal
+        parsed_s
+      end
+    end
+  end
+end

data/lib/with_filters/value_prep/default_prep.rb

@@ -0,0 +1,88 @@
+module WithFilters
+  module ValuePrep
+    # @private
+    class DefaultPrep
+      # @param [Array, Hash, String] value The value to filter on.
+      # @param [Hash] options
+      # @option options [Symbol] :match Determines the way the filter is matched.
+      #   Accepts `:exact`, `:contains`, `:begins_with` and `:ends_with`.
+      # 
+      # @since 0.1.0
+      def initialize(value, options = {})
+        @value   = value
+        @options = options
+      end
+
+      # Returns the value so that it is ready to be filtered with.
+      #
+      # @return [Array, Hash, String]
+      #
+      # @since 0.1.0
+      def value
+        @prepared_value ||= if @value.is_a?(Hash)
+          {start: prepare_start_value(@value[:start]), stop: prepare_stop_value(@value[:stop])}
+        else
+          temp = Array.wrap(@value).map do |value|
+            add_match(prepare_value(value))
+          end
+          temp.length == 1 ? temp.first : temp
+        end
+      end
+
+      private
+
+      # Prepares a value for use in the filter.
+      #
+      # @param [String] value The value to filter on.
+      #
+      # @return [String]
+      #
+      # @since 0.1.0
+      def prepare_value(value)
+        value.respond_to?(:strip) ? value.strip : value
+      end
+
+      # Prepares the start value for a ranged filter.
+      #
+      # @param [String] value The value to filter on.
+      #
+      # @return [String]
+      #
+      # @since 0.1.0
+      def prepare_start_value(value)
+        prepare_value(value)
+      end
+
+      # Prepares the stop value for a ranged filter.
+      #
+      # @param [String] value The value to filter on.
+      #
+      # @return [String]
+      #
+      # @since 0.1.0
+      def prepare_stop_value(value)
+        prepare_value(value)
+      end
+
+      # Add string matchers based on the `:match` option passed to #initialize.
+      #
+      # @param [String] value The value to filter on.
+      #
+      # @return [String]
+      #
+      # @since 0.1.0
+      def add_match(value)
+        case @options[:match]
+        when :contains
+          "%#{value}%"
+        when :begins_with
+          "#{value}%"
+        when :ends_with
+          "%#{value}"
+        else
+          value
+        end
+      end
+    end
+  end
+end

data/lib/with_filters/value_prep/value_prep.rb

@@ -0,0 +1,28 @@
+module WithFilters
+  # @private
+  module ValuePrep
+    # A mapping of Rails column types to value preparation class.
+    #
+    # since 0.1.0
+    TYPE_MAP = {
+      boolean:   BooleanPrep,
+      date:      DatePrep,
+      datetime:  DateTimePrep,
+      timestamp: DateTimePrep
+    }
+
+    # A factory returning a class that prepares filter values based on a Rails
+    # column type.
+    #
+    # @param [Symbol] column_type A Rails column type.
+    # @param [String] value Value to be passed to the value preparation class.
+    # @param [Hash] options Options to be passed to the value preparation class.
+    #
+    # @return [WithFilters::DefaultPrep, Inherited from WithFilters::DefaultPrep]
+    #
+    # since 0.1.0
+    def self.prepare(column_type, value, options = {})
+      (TYPE_MAP[column_type].try(:new, value, options) || DefaultPrep.new(value, options)).value
+    end
+  end
+end

data/lib/with_filters/version.rb

@@ -0,0 +1,3 @@
+module WithFilters
+  VERSION = '0.1.0'
+end

data/lib/with_filters.rb

@@ -0,0 +1,32 @@
+require 'with_filters/engine'
+require 'with_filters/hash_extraction'
+require 'with_filters/active_record_extension'
+require 'with_filters/active_record_model_extension'
+require 'with_filters/value_prep/default_prep'
+require 'with_filters/value_prep/boolean_prep'
+require 'with_filters/value_prep/date_prep'
+require 'with_filters/value_prep/date_time_prep'
+require 'with_filters/value_prep/value_prep'
+require 'with_filters/action_view_extension'
+require 'with_filters/models/action'
+require 'with_filters/models/filter/choice'
+require 'with_filters/models/filter/collection'
+require 'with_filters/models/filter/base'
+require 'with_filters/models/filter/base_range'
+require 'with_filters/models/filter/text'
+require 'with_filters/models/filter/text_range'
+require 'with_filters/models/filter/radio'
+require 'with_filters/models/filter/select'
+require 'with_filters/models/filter/select_range'
+require 'with_filters/models/filter/check_box'
+require 'with_filters/models/filter/filter'
+require 'with_filters/models/filter_form'
+require 'with_filters/version'
+
+ActiveSupport.on_load(:active_record) do
+  include WithFilters::ActiveRecordExtension
+end
+
+ActiveSupport.on_load(:action_view) do
+  include WithFilters::ActionViewExtension
+end