filch 0.1.0

data/app/controllers/filch_controller.rb

@@ -0,0 +1,13 @@
+# The filch controller.
+class FilchController < ::ApplicationController
+  # Datalist returns data for the datalist.
+  def datalist
+    model, column, pq = params[:column].split('.')
+    ransack_q = Filch.datalist(model, column, params[pq])
+    render(
+      partial: 'filch/quick',
+      layout: false,
+      locals: { q: ransack_q }
+    )
+  end
+end

data/app/views/filch/_associations.html.haml

@@ -0,0 +1,25 @@
+-template_config.associations_keys.each do |assoc|
+  -template_config.associations[assoc].each do |attr, preds|
+    -model_name = model.name
+    -id = "#{template}_#{model_name}_#{assoc}_#{attr}"
+    - datalist_id = "#{id}_datalist"
+    -assoc_attrs = {shId: "#{id}_column", datalist: datalist_id, id: id + '_head'}.merge(html_attrs[:assocs])
+    %p.js{assoc_attrs}
+      ="#{assoc} #{attr}"
+    %table{id: "#{id}_column", class: attr}
+      %tr
+        %td
+
+          -datalist_attrs = {id: datalist_id, updateInner_addvars: "#{model_name}.#{attr}.#{f.options[:as]}"}.merge(html_attrs[:datalist])
+          %datalist{datalist_attrs}
+            %option
+
+      -preds.each do |pred|
+        %tr{class: pred}
+          -if lookup_context.find_all("filch/_#{pred}").any?
+            =render("filch/#{pred}", f: f, datalist_id: datalist_id, attr: "#{assoc}_#{attr}", model: model, html_attrs: html_attrs)
+          -else
+            %td.label{html_attrs[:label]}=pred
+            %td.no_partial
+              -field_hash = {list: datalist_id, placeholder:"#{attr} #{pred}"}.merge(html_attrs[:field])
+              =f.text_field("#{assoc}_#{attr}_#{pred}", field_hash)

data/app/views/filch/_attributes.html.haml

@@ -0,0 +1,30 @@
+-template_config.attributes_keys.each do |attr|
+  -model_name = model.name
+  -id = "#{template}_#{model_name}_#{attr}"
+  -datalist_id = "#{id}_datalist"
+  -attrs_attrs = {shId: "#{id}_column", datalist: datalist_id, id: id + '_head'}.merge(html_attrs[:attrs])
+  %p.js{attrs_attrs}
+    =attr
+  %table.js{id: "#{id}_column", class: attr}
+    %tr
+      %td
+        -# TODO: have results from before
+        -# load options now?
+        -# TODO: why not load all datalists at the same time!
+        -datalist_attrs = {id: datalist_id, updateInner_addvars: "#{model_name}.#{attr}.#{f.options[:as]}"}.merge(html_attrs[:datalist])
+        %datalist{datalist_attrs}
+          %option
+
+    -template_config.attributes[attr].each do |pred|
+      %tr{class: pred}
+        -if lookup_context.find_all("filch/_#{attr}_#{pred}").any?
+          =render("filch/#{attr}_#{pred}", f: f, datalist_id: datalist_id, attr: attr, pred: pred, model: model, default_value: template_config.default_values["#{attr}_#{pred}"] || '', html_attrs: html_attrs)
+        -elsif lookup_context.find_all("filch/_#{pred}").any?
+          =render("filch/#{pred}", f: f, datalist_id: datalist_id, attr: attr, model: model, default_value: template_config.default_values["#{attr}_#{pred}"] || '', html_attrs: html_attrs)
+        -else
+          %td{html_attrs[:label]}
+            = pred
+          %td.no_partial
+            -field_hash = {list: datalist_id, placeholder:"#{attr} #{pred}"}.merge(html_attrs[:field])
+            -field_hash[:value]= template_config.default_values["#{attr}_#{pred}"]
+            =f.text_field("#{attr}_#{pred}", field_hash)

data/app/views/filch/_distinct.html.haml

@@ -0,0 +1,4 @@
+%td{html_attrs[:label]}
+  distinct for:
+%td
+  =f.collection_check_boxes(:uniq, model.columns.map(&:name), :to_s, :to_s)

data/app/views/filch/_eq.html.haml

@@ -0,0 +1,7 @@
+%td.label{html_attrs[:label]} equals
+%td
+  -# dont update datalist with _eq
+  - default_value ||= ''
+  - field_hash = {list: datalist_id, class: 'form-control', placeholder: "#{attr} equals"}
+  - field_hash[:value] = default_value
+  =f.search_field("#{attr}_eq", html_attrs[:field].merge(field_hash))

data/app/views/filch/_form.html.haml

@@ -0,0 +1,26 @@
+-sattrs_class = "#{template} js"
+-sattrs={id: "#{model.name}_#{template}_form", class: sattrs_class, method: :post}.merge(html_attrs[:search_form])
+=search_form_for @q, url: results_p, html: sattrs do |f|
+  %p.btn.btn-sm.js{click: 'clearAll' }
+    Clear All
+  %table{id: model.name + '_table'}
+    %tr
+      %td.attributes
+        =render('filch/attributes', model: model, f: f, template: template, template_config: template_config, html_attrs: html_attrs)
+    %tr
+      %td.associations
+        =render('filch/associations', model: model, f: f, template: template, template_config: template_config, html_attrs: html_attrs)
+    %tr
+      %td.scopes
+        %h4 
+        =render('filch/scopes', model: model, f: f, template: template, template_config: template_config)
+    %tr
+      %td.options
+        =render('filch/options', model: model, template_config: template_config)
+    %tr
+      %td
+        =hidden_field_tag 'template', template
+        =hidden_field_tag 'model', model
+        - fattrs = {class: 'js submit',
+          attr: 'action', elem: 'word_search', attr_val: '/search'}
+        =f.submit("search", fattrs)

data/app/views/filch/_group.html.haml

@@ -0,0 +1,4 @@
+%td
+  group:
+%td
+  =f.collection_check_boxes(:group, model.columns.map(&:name), :to_s, :to_s)

data/app/views/filch/_gt.html.haml

@@ -0,0 +1,2 @@
+%td greater than
+%td= f.number_field attr + '_gt'

data/app/views/filch/_limit.html.haml

@@ -0,0 +1,5 @@
+%td limit
+%td
+  -v = params[:q] ? params[:q][scope_name].to_s : default_value
+  -v ||= '50'
+  =f.number_field(scope_name, value: v)

data/app/views/filch/_lt.html.haml

@@ -0,0 +1,2 @@
+%td less than
+%td= f.number_field attr + '_lt'

data/app/views/filch/_null.html.haml

@@ -0,0 +1,5 @@
+%td.lable{html_attrs[:label]} is null?
+%td
+  -v = params[:q] ? params[:q]["#{attr}_null"] : ''
+  -v = default_value || v
+  =f.select("#{attr}_null", {'is not null': '0', 'is null': '1'}, {include_blank: true, selected: v})

data/app/views/filch/_options.html.haml

@@ -0,0 +1,11 @@
+%table
+  -template_config.options.each do |option|
+    %tr{class: option}
+      -if lookup_context.find_all("filch/_#{option}").any?
+        =render("filch/#{option}", f: f, option: option, model: model, default_value: template_config.default_values[option] || [])
+      -else
+        %td
+          =option
+        %td.nopartial
+          =check_box_tag("o[#{option}]", 1, template_config.default_values[option] || false)
+

data/app/views/filch/_order.html.haml

@@ -0,0 +1,4 @@
+%td
+  Order By
+%td
+  =f.select(scope_name, model.columns.map(&:name), {selected: default_value}, {class: 'q_s'})

data/app/views/filch/_pg_group.html.haml

@@ -0,0 +1,6 @@
+%td
+  group for:
+%td
+  -default_value ||= []
+  =f.collection_check_boxes(:pg_group, model.columns, :name, :name, {include_hidden: false}) do |box|
+    = box.label {default_value.include?(box.value) ? box.check_box( checked: true ) + box.text : box.check_box(checked: false) + box.text}

data/app/views/filch/_pluck.html.haml

@@ -0,0 +1,4 @@
+%td
+  pluck:
+%td
+  =f.collection_check_boxes(:pluck, model.columns, :name, :name, {include_hidden: false})

data/app/views/filch/_quick.html.haml

@@ -0,0 +1,3 @@
+-q.each do |word|
+  %option
+    =word

data/app/views/filch/_scopes.html.haml

@@ -0,0 +1,11 @@
+%table
+  -template_config.scopes.each do |scope_name|
+    %tr{class: scope_name}
+      -if lookup_context.find_all("filch/_#{scope_name}").any?
+        =render("filch/#{scope_name}", f: f, model: model, scope_name: scope_name, default_value: template_config.default_values[scope_name] || nil)
+      -else
+        %td
+          =scope_name
+        %td.nopartial
+          =check_box_tag("q[#{scope_name}", 1, template_config.default_values[scope_name] || false)
+

data/app/views/filch/_search.html.haml

@@ -0,0 +1,12 @@
+= javascript_include_tag 'js_weber'
+= javascript_include_tag 'filch'
+-button_attrs= filch.html_attrs[:button]
+%button#filch_button.js.btn.btn-sm.collapsed{button_attrs}
+  =button_name
+%span#filch
+  -select_h =  {class: 'js', change: 'showSelected', load: 'showSelected'}
+  -t_keys = filch.template_keys
+  -if t_keys.length > 1
+    =select_tag 'template', options_for_select(t_keys, params[:template]), select_h
+  -t_keys.each do |template|
+    =render('filch/form', model: filch.model, template: template, template_config: filch.templates[template], results_p: results_p, html_attrs: filch.html_attrs)

data/bin/console

@@ -0,0 +1,14 @@
+#!/usr/bin/env ruby
+
+require 'bundler/setup'
+require 'filch'
+
+# You can add fixtures and/or initialization code here to make experimenting
+# with your gem easier. You can also use a different console, if you like.
+
+# (If you use this, don't forget to add pry to your Gemfile!)
+# require "pry"
+# Pry.start
+
+require 'irb'
+IRB.start(__FILE__)

data/bin/setup

@@ -0,0 +1,8 @@
+#!/usr/bin/env bash
+set -euo pipefail
+IFS=$'\n\t'
+set -vx
+
+bundle install
+
+# Do any other automated setup that you need to do here

data/config/initializers/assets.rb

@@ -0,0 +1 @@
+Rails.application.config.assets.precompile += %w[filch.js]

data/config/initializers/ransack.rb

@@ -0,0 +1,100 @@
+# all this was necessary to give me a case sensitive predicate!!!
+# stolen from https://github.com/activerecord-hackery/ransack/issues/699
+# {{
+Ransack.configure do |config|
+  config.add_predicate(
+    'like',
+    arel_predicate: 's_matches',
+    formatter: proc { |v| "%#{v}%" },
+    type: :string
+  )
+end
+
+module Arel
+  module Nodes
+    # creates an arel predicate for case sensitive searching in postgres
+    class Matches < Binary
+      attr_reader :escape
+      attr_accessor :case_sensitive
+
+      def initialize(left, right, escape = nil, case_sensitive = false)
+        super(left, right)
+        @escape = escape && Nodes.build_quoted(escape)
+        @case_sensitive = case_sensitive
+      end
+    end
+
+    # DoesNotMatch will inherit from matches
+    class DoesNotMatch < Matches; end
+  end
+end
+
+module Arel
+  # adding s_metches to Arel::Predications
+  module Predications
+    # creates an arel predicate for case sensitive searching in postgres
+    def s_matches(other, escape = nil)
+      Nodes::Matches.new self, quoted_node(other), escape, true
+    end
+  end
+end
+
+module Arel
+  module Visitors
+    # changes postgres query to casesensitive
+    class PostgreSQL < Arel::Visitors::ToSql
+      private
+
+      # arel doesnt use snakecase??
+      def visit_Arel_Nodes_Matches(oth, col)
+        col = infix_value oth, col, oth.case_sensitive ? ' LIKE ' : ' ILIKE '
+        escape = oth.escape
+        return col unless escape
+        visit escape, col << ' ESCAPE '
+      end
+    end
+  end
+end
+# }}
+
+# Array Contains
+#  {{{
+# https://github.com/activerecord-hackery/ransack/issues/321
+module Arel
+  # create arel predicate for array
+  module Predications
+    def array_cont(other)
+      Nodes::Equality.new(
+        Nodes.build_quoted(other, self), Nodes::NamedFunction.new('ANY', [self])
+      )
+    end
+  end
+end
+
+Ransack.configure do |config|
+  config.add_predicate :array_cont, arel_predicate: :array_cont
+end
+# }}}
+
+# Array Not Contains
+#  {{{
+# https://github.com/activerecord-hackery/ransack/issues/321
+module Arel
+  # create arel predicate for not array not contains
+  module Predications
+    def array_not_cont(other)
+      Nodes::DoesNotMatch.new(
+        Nodes.build_quoted(other, self),
+        Nodes::NamedFunction.new('ALL', [self])
+      )
+    end
+  end
+end
+
+Ransack.configure do |config|
+  config.add_predicate :array_not_cont, arel_predicate: :array_not_cont
+end
+# }}}
+
+#
+# vim:foldmethod=marker

data/config/routes.rb

@@ -0,0 +1,3 @@
+Rails.application.routes.draw do
+  get 'filch/datalist' => 'filch#datalist', :as => :filch_datalist
+end

data/filch.gemspec

@@ -0,0 +1,40 @@
+lib = File.expand_path('lib', __dir__)
+$LOAD_PATH.unshift(lib) unless $LOAD_PATH.include?(lib)
+require 'filch/version'
+
+Gem::Specification.new do |spec|
+  spec.name          = 'filch'
+  spec.version       = Filch::VERSION
+  spec.authors       = ['ynweber']
+  spec.email         = ['foo']
+
+  spec.summary       = %(a search form builder.)
+  spec.description   = %(Creates search forms based on templates configurable in
+  model. Using Ransack.)
+  spec.homepage      = 'https://bitbucket.org/ynweber/filch/'
+  spec.license       = 'MIT'
+
+  spec.metadata['homepage_uri'] = spec.homepage
+  spec.metadata['source_code_uri'] = 'https://bitbucket.org/ynweber/filch/src'
+  spec.metadata['changelog_uri'] = 'https://bitbucket.org/ynweber/filch/commits/'
+
+  # Specify which files should be added to the gem when it is released.
+  # The `git ls-files -z` loads the files in the RubyGem that have been
+  # added into git.
+  spec.files = Dir.chdir(File.expand_path(__dir__)) do
+    `git ls-files -z`.split("\x0")
+                     .reject { |f| f.match(%r{^(test|spec|features)/}) }
+  end
+  spec.bindir        = 'exe'
+  spec.executables   = spec.files.grep(%r{^exe/}) { |f| File.basename(f) }
+  spec.require_paths = ['lib']
+
+  spec.add_dependency 'haml'
+  spec.add_dependency 'js_weber'
+  spec.add_dependency 'ransack'
+  spec.add_development_dependency 'bundler', '~> 2.0'
+  spec.add_development_dependency 'minitest', '~> 5.0'
+  spec.add_development_dependency 'minitest-rails'
+  spec.add_development_dependency 'minitest-reporters', '>= 1.1'
+  spec.add_development_dependency 'rake', '~> 10.0'
+end

data/lib/filch.rb

@@ -0,0 +1,375 @@
+require 'filch/version'
+require 'filch/engine'
+require 'filch/error'
+require 'filch/datalist'
+require 'filch/ransack_plus'
+require 'filch/model_find'
+
+# = The Filch Gem
+# the Filch Gem is entirely based on the
+# ransack[https://github.com/activerecord-hackery/ransack] gem
+# Filch allows for easy advanced form building.
+#
+# ==Features
+# Filch::Templates:: The Filch::Templates object is used when generating
+#                    the form(s).
+# Filch::Datalist:: Text fields are linked to a <datalist>.
+#                   Uses javascript to update the list with
+#                   Filch::Datalist.quick
+# Filch::RansackPlus:: Certain methods I couldn't do with Ransack/Arel.
+module Filch
+  def self.templates(model)
+    Templates.new(model)
+  end
+
+  # calls the Filch::Datalist.quick method.
+  # <i>model_name</i> is a String representing the name of the model.
+  # <i>attr</i> is a String representing the attribute to query.
+  # <i>params</i> is the form's params.
+  #
+  # returns an Array 'plucked' from the results
+  #
+  # this method is usually called internally, from javascript
+  def self.datalist(model_name, attr, params)
+    Datalist.quick(model(model_name), attr, params)
+  end
+
+  # Filch::RansackPlus.
+  # recieves the form <i>params<i>, for the 'plus' methods
+  # <i>q</i> is the form object.
+  # returns an array of ransacked results
+  def self.ransack_plus(params, query)
+    RansackPlus.new(params, query)
+  end
+
+  # model_find should be a String representing the name of a model.
+  # returns a model.
+  # If model_find is nil, or the model is not found, return the first model.
+  def self.model(model_find = nil)
+    ModelFind.find(model_find)
+  end
+
+  # = Templates
+  # Builds a hash. keys ares are an array template_keys
+  # , values are Filch::Template.
+  #   @templates[template_key] = Filch::Template.new(@model, template_key)
+  # template_keys can be defined in the model
+  #   class Foo < ApplicationRecord
+  #     def self.filch_template_keys
+  #       %i[all basic]
+  #     end
+  #   end
+  class Templates
+    def initialize(model)
+      @model = model
+      @templates = build_templates
+    end
+    attr_reader :templates, :model
+
+    def html_attrs_values
+      {
+        assocs: { click: 'filchColClick', load: 'toggleShowHide' },
+        attrs: { click: 'filchColClick', load: 'toggleShowHide' },
+        button: {
+          click: 'toggleShowHide', shId: 'filch', load: 'toggleShowHide'
+        },
+        datalist: {
+          updateInner_path: '/filch/datalist', class: 'js', update: 'dlUpdate'
+        },
+        field: { class: 'js form-control', input: 'filchDataList' },
+        label: { class: 'cheese'}
+      }
+    end
+
+    def model_html_attrs
+      model_attrs = if @model.methods.include?(:filch_html_attrs)
+                      @model.filch_html_attrs
+                    else
+                      {}
+                    end
+      model_attrs.default = {}
+      model_attrs
+    end
+
+    def html_attrs
+      attrs = html_attrs_values
+      attrs.default = {}
+      attrs.each_key do |key|
+        attrs[key] = attrs[key].merge(model_html_attrs[key])
+      end
+      attrs
+    end
+
+
+    # def button_attrs
+    #   attrs = {
+    #   }
+    #   if @model.methods.include?(:button_attrs)
+    #     attrs = attrs.merge(@model.button_attrs) || attrs
+    #   end
+    #   attrs
+    # end
+
+    def build_templates
+      templates = {}
+      templates.default = Template.new(@model, 'default')
+      template_keys.each do |template|
+        templates[template] = Template.new(@model, template)
+      end
+      templates
+    end
+
+    # will generate forms based on the list of templates in the Array
+    # <i>YourModel.template_keys</i>.
+    # defaults to ['all']
+    def template_keys
+      if @model.methods.include?(:template_keys)
+        @model.template_keys || ['all']
+      else
+        ['all']
+      end
+    end
+  end
+
+  # The Template Object
+  # defines a template
+  # recieves a model Object, and a String representing the name of the template.
+  # returns a new object with the following attributes:
+  # [associations_keys] an Array of Strings representing the names of the
+  #                     the Filch::Associations to be queryed.
+  # [associations] a Hash of Strings representing the predicates to be queryed.
+  # [attribute_keys] same as association_keys, for the the Filch::Attributes
+  # [attributes] same as associations, for the Filch::Attributes.
+  # [scope_keys] same as association_keys, for the Filch::Scopes
+  # [scopes] same as associations, for the Filch::Scopes
+  class Template
+    def initialize(model, template)
+      @model = model
+      @template = template
+      @assocs = Associations.new(model)
+      @attrs = Attributes.new(model)
+    end
+    attr_reader :model
+
+    def attributes
+      @attrs.attributes[@template]
+    end
+
+    def attributes_keys
+      @attrs.attributes_keys[@template]
+    end
+
+    def associations
+      @assocs.associations[@template]
+    end
+
+    def associations_keys
+      @assocs.associations_keys[@template]
+    end
+
+    def df_vals
+      {}
+    end
+
+    def default_values
+      if @model.methods.include?(:filch_defaults)
+        df_vals.merge(@model.filch_defaults[@template])
+      else
+        df_vals
+      end
+    end
+
+    def options
+      if @model.methods.include?(:filch_options)
+        @model.filch_options[@template] || {}
+      else
+        {}
+      end
+    end
+
+    def scopes
+      Scopes.new(@model).scopes[@template]
+    end
+  end
+
+  # associations_keys, to determine which associations to query &
+  # #associations, to determine which predicates to query on those associations.
+  class Associations
+    def initialize(model)
+      @model = model
+      @ransackable_associations = @model ? @model.ransackable_associations : []
+    end
+
+    # the associated models to be queryed.
+    # associations_keys can be defined in the model
+    #   class Foo < ApplicationRecord
+    #     has_many :employees
+    #     has_many :pay_stubs
+    #     def self.filch_assoc_keys
+    #       %i[employess pay_stubs]
+    #     end
+    #   end
+    #
+    # defaults to all ransackable_associtations
+    def associations_keys
+      assoc_keys =
+        if @model.methods.include?(:filch_assoc_keys)
+          @model.filch_assoc_keys
+        else
+          {}
+        end
+      assoc_keys.default = @ransackable_associations
+      assoc_keys[:all] = @ransackable_associations
+      assoc_keys
+    end
+
+    # a hash representing all the predicates to be queryed for a given
+    # association.
+    # #associations can be defined in the model
+    #   class Foo < ApplicationRecord
+    #     has_many :employees
+    #     has_many :pay_stubs
+    #     def self.filch_associations
+    #       {
+    #         basic_template: {
+    #           employee: {
+    #             name: %w[eq cont]
+    #           },
+    #           pay_stub: {
+    #             year: %w[eq gt]
+    #           }
+    #         }
+    #       }
+    #     end
+    #   end
+    #
+    # defaults to all ransackable_attributes for a given association with a
+    # value of ['eq']
+    def associations
+      assoc_hash =
+        if @model.methods.include?(:filch_associations)
+          @model.filch_associations
+        else
+          {}
+        end
+      assoc_hash.default = all
+      assoc_hash[:all] = all
+      assoc_hash
+    end
+
+    # TODO: specialize defaults to class types
+    # using class_eval(assoc.capitalize).columns
+    # doesnt work if belongs_to is not the same name as class
+    def all
+      @ransackable_associations.each_with_object({}) do |assoc, all_hash|
+        all_hash[assoc] = Hash.new(['eq'])
+        next unless Object.const_defined?(assoc.capitalize)
+        all_hash_assoc(all_hash, assoc)
+        # assoc_class_name = assoc.capitalize
+      end
+    end
+
+    def all_hash_assoc(all_hash, assoc)
+      Object.const_get(assoc.capitalize).ransackable_attributes
+            .each { |attr| all_hash[assoc][attr] = ['eq'] }
+      all_hash
+    end
+  end
+
+  # similar to Filch::Associations, except doesn't use predicates, and
+  # ransackable_scopes <b>must be</b> defined.
+  #   class Foo < ApplicationRecord
+  #     scope :managers, -> { where(position: 'Manager') }
+  #     scope :store_managers, -> { where(position: 'StoreManager') }
+  #     def self.ransackable_scopes
+  #       %w[managers, store_managers]
+  #     end
+  #   end
+  #
+  # defaults to <i>ransackable_scopes</i>
+  class Scopes
+    def initialize(model)
+      @model = model
+    end
+
+    # can be defined on the model
+    #   class Foo < ApplicationRecord
+    #   def self.filch_scopes
+    #     %w[managers, store_managers]
+    def scopes
+      scopes_hash = Hash.new(default)
+      if @model.methods.include?(:filch_scopes)
+        scopes_hash = scopes_hash.merge(@model.filch_scopes)
+      end
+      scopes_hash[:all] = @model ? @model.ransackable_scopes : []
+      scopes_hash
+    end
+
+    def default
+      default_hash = {}
+      default_hash
+    end
+  end
+
+  # similar to Filch::Associations
+  class Attributes
+    def initialize(model)
+      @model = model
+      @ransackable_attributes = @model ? @model.ransackable_attributes : []
+    end
+
+    # defaults to <i>Foo.ransackable_attributes</i>
+    def attributes_keys
+      attributes_keys =
+        @model.methods.include?(:filch_attrs) ? @model.filch_attrs : {}
+      attributes_keys.default = @ransackable_attributes
+      attributes_keys[:all] = @ransackable_attributes
+      attributes_keys
+    end
+
+    def attributes
+      attributes_hash = Hash.new(default)
+      if @model.methods.include?(:filch_attributes)
+        # attributes_hash.merge(@model.filch_attributes)
+        attributes_hash = attributes_hash.merge(@model.filch_attributes)
+      end
+      # attributes_hash = default_values(attributes_hash)
+      attributes_hash.each_value { |template_h| template_h.default = ['eq'] }
+      attributes_hash
+    end
+
+    def all
+      all_hash = {}
+      @ransackable_attributes.each do |attr|
+        all_hash[attr] = types[attr_columns(attr)]
+      end
+      all_hash
+    end
+
+    def attr_columns(attr)
+      @model.columns.select { |col| col.name == attr }.first.type
+    end
+
+    def default
+      def_hash = Hash.new(['eq'])
+      def_hash[:all] = all
+      def_hash
+    end
+
+    # TODO: setup defaults based on column_type
+    def types
+      {
+        integer: %w[eq lt gt],
+        string: %w[null eq start matches],
+        text: types_hash['string'],
+        boolean: %w[null]
+      }
+    end
+
+    def types_hash
+      {
+        string: ['eq']
+      }
+    end
+  end
+end