index_view 0.1.0

data/lib/index_view.rb

@@ -0,0 +1,54 @@
+require File.dirname(__FILE__) + "/index_view/column"
+require File.dirname(__FILE__) + "/index_view/sql_generator"
+require File.dirname(__FILE__) + "/index_view/sql_conditions"
+require File.dirname(__FILE__) + "/index_view/implementation"
+require File.dirname(__FILE__) + "/index_view/customization_defaults"
+
+module IndexView
+  module Version
+    MAJOR = 0
+    MINOR = 1
+    TINY  = 0
+
+    STRING = "#{MAJOR}.#{MINOR}.#{TINY}"
+  end
+
+  class InvalidSort < StandardError; end
+
+  class Base
+    include Implementation
+    include CustomizationDefaults
+
+    class << self
+      def find(*args)
+        new({}).find(*args)
+      end
+
+      def all(*args)
+        new({}).all(*args)
+      end
+
+      def first(*args)
+        new({}).first(*args)
+      end
+
+      # used to define columns you want to render in the view,
+      # and gives you a way to customize _how_ they render
+      # See IndexView::Column to get an idea of the options you can pass in.
+      def column(*args, &block)
+        columns << Column.new(*args, &block)
+      end
+
+      # returns a collection of the IndexView::Column objects that were
+      # added through the +column+ method
+      def columns
+        @columns ||= []
+      end
+
+      def fields_for_search
+        searchable_columns = columns.select { |c| c.searchable? }
+        searchable_columns.map { |col| col.column_name }
+      end
+    end
+  end
+end

data/lib/index_view/column.rb

@@ -0,0 +1,64 @@
+module IndexView
+  class Column
+    class InvalidKeyError < StandardError; end
+
+    OPTION_KEYS = [:link, :sortable, :title, :searchable]
+
+    def initialize(column_name, options={ }, &link)
+      @column_name = column_name.to_sym
+
+      check_and_assign_values_from_keys(options, link)
+    end
+
+    attr_reader :column_name, :link
+
+    def column_value(context, object)
+      context.instance_exec(object, &link)
+    end
+
+    def column_value?
+      link ? true : false
+    end
+
+    def sortable?
+      @sortable ? true : false
+    end
+
+    def human_name
+      column_name.to_s.humanize
+    end
+
+    def title
+      @title ? @title : human_name
+    end
+
+    def searchable?
+      @searchable ? true : false
+    end
+
+  private
+
+    def check_and_assign_values_from_keys(hash, link)
+      hash.each do |key, value|
+        key = key.to_sym
+
+        if key == :link
+          Kernel.warn ":link is no longer a valid key.  Pass a block directly to the column method (from #{caller[5]})"
+        end
+
+        if OPTION_KEYS.include?(key)
+          assign_if_present(key, value)
+        else
+          key_names = "[#{OPTION_KEYS.map { |k| ":#{k}" }.join(", ")}]"
+          raise InvalidKeyError, "#{key} is not a valid key.  Valid keys are #{key_names}"
+        end
+      end
+
+      assign_if_present(:link, link)
+    end
+
+    def assign_if_present(key, value)
+      instance_variable_set("@#{key}", value) if value
+    end
+  end
+end

data/lib/index_view/customization_defaults.rb

@@ -0,0 +1,28 @@
+module IndexView
+  # The following methods are safe to override in descendent classes
+  module CustomizationDefaults
+    DEFAULT_PAGINATION_NUMBER = 30
+
+    def target_class
+      raise NotImplementedError
+    end
+
+    def per_page
+      target_class.respond_to?(:per_page) ?
+        target_class.per_page :
+        DEFAULT_PAGINATION_NUMBER
+    end
+
+    def default_sort_term
+      raise NotImplementedError, "default_sort_term must be defined"
+    end
+
+    def secondary_sort_term
+      nil
+    end
+
+    def default_sort_direction
+      Implementation::DESC
+    end
+  end
+end

data/lib/index_view/implementation.rb

@@ -0,0 +1,174 @@
+module IndexView
+  module Implementation
+    include SQLConditions
+
+    ASC                       = :ASC
+    DESC                      = :DESC
+    SORT_DIRECTIONS           = [ASC, DESC]
+
+    attr_reader :params
+
+    # IndexView objects are initialized with the params of a request.
+    # See README.rdoc
+    def initialize(params = { })
+      @params = params
+    end
+
+    # returns a paginated set of the IndexView's +target_class+
+    # To customize how the objects are paginated -
+    # redefine +pagination_options+ in your class
+    def paginate
+      target_class.paginate(pagination_options)
+    end
+
+    def find(selector, options={})
+      case selector
+      when :first, :last, :all
+        target_class.find(selector, find_options.merge(options))
+      else
+        target_class.find(selector)
+      end
+    end
+
+    def all(*args)
+      find(:all, *args)
+    end
+
+    def first(*args)
+      find(:first, *args)
+    end
+
+    def find_options
+      {
+        :from       => table_name.to_s,
+        :order      => sort,
+        :conditions => conditions_sql
+      }
+    end
+
+    # Returns a hash of options used to paginate your IndexView's +target_class+.
+    # You can overwrite this in your class to customize pagination.
+    def pagination_options
+      {
+        :from       => table_name.to_s,
+        :conditions => conditions_sql,
+        :order      => sort,
+        :page       => @params[:page],
+        :per_page   => per_page
+      }
+    end
+
+    def search_term
+      @params[:search]
+    end
+
+    def search_term?
+      search_term && !search_term.blank? ? true : false
+    end
+
+    def sort
+      "#{sort_term} #{sort_direction}" + (!secondary_sort_term.blank? ? ", #{secondary_sort_term} #{sort_direction}" : '')
+    end
+
+    def sort_term
+      if sort = @params[:sort]
+        sort
+      else
+        default_sort_term.is_a?(Array) ? default_sort_term.join(", ") : default_sort_term
+      end
+    end
+
+    def sort_direction
+      if SORT_DIRECTIONS.include?(given_sort_direction)
+        given_sort_direction
+      else
+        raise IndexView::InvalidSort, "#{given_sort_direction} is not a valid sort direction"
+      end
+    end
+
+    def opposite_sort_direction
+      ascending? ? DESC : ASC
+    end
+
+    # returns a collection of the IndexView::Column objects that were
+    # added through the +column+ method
+    def columns
+      self.class.columns
+    end
+
+    # Takes a column name and returns whether or not your index is currently sorted on that column.
+    def sorting?(column_name)
+      sort_term.to_s == column_name.to_s
+    end
+
+    # Returns whether or not your index is currently sorted ascended.
+    def ascending?
+      sort_direction == ASC
+    end
+
+    # Returns whether or not your index is currently sorted descended.
+    def descending?
+      !ascending?
+    end
+
+    def state?
+      state && !state.blank? ? true : false
+    end
+
+    def state
+      @params[:state]
+    end
+
+    def fields_for_search
+      self.class.fields_for_search
+    end
+
+    def table_name
+      target_class.table_name.to_sym
+    end
+
+  private
+
+    def conditions_sql
+      present_conditions.join(" AND ")
+    end
+
+    def present_conditions
+      parenthesize(remove_empties(sanitize(conditions)))
+    end
+
+    def conditions
+      [search_conditions, state_conditions, *index_parameter_conditions]
+    end
+
+    def index_parameter_conditions
+      if index_params = params[:index]
+        index_params.reject { |k,v| v.blank? }.map { |k, v| ["#{k} = ?", v] }
+      end
+    end
+
+    def parenthesize(collection)
+      collection.map { |element| "(#{element})" }
+    end
+
+    def remove_empties(collection)
+      collection.reject { |element| element.blank? }
+    end
+
+    def sanitize(collection)
+      collection.map { |element| sanitize_sql(element) }
+    end
+
+    def sanitize_sql(sql)
+      target_class.send(:sanitize_sql, sql)
+    end
+
+    def given_sort_direction
+      if direction = @params[:direction]
+        direction.upcase.to_sym
+      else
+        default_sort_direction
+      end
+    end
+  end
+end

data/lib/index_view/sql_conditions.rb

@@ -0,0 +1,19 @@
+module IndexView
+  module SQLConditions
+    include SQLGenerator
+
+  private
+
+    def state_conditions
+      if state?
+        ["state = ?", state]
+      end
+    end
+
+    def search_conditions
+      if search_term?
+        like_for_many_columns(search_term, *fields_for_search)
+      end
+    end
+  end
+end

data/lib/index_view/sql_generator.rb

@@ -0,0 +1,20 @@
+module IndexView
+  module SQLGenerator
+    def like_for_many_columns(value, *fields)
+      [
+        condition_fields_for_like_with_many_columns(value, fields),
+        *value_fields_for_like_with_many_columns(value, fields)
+      ]
+    end
+
+  private
+
+    def condition_fields_for_like_with_many_columns(value, fields)
+      fields.map { |field| "#{field} LIKE ?" }.join(" OR ")
+    end
+
+    def value_fields_for_like_with_many_columns(value, fields)
+      fields.map { "%#{value.gsub(" ", "%")}%" }
+    end
+  end
+end

metadata

@@ -0,0 +1,50 @@
+--- !ruby/object:Gem::Specification
+name: index_view
+version: !ruby/object:Gem::Version
+  version: 0.1.0
+  prerelease: 
+platform: ruby
+authors:
+- Scott Taylor
+autorequire: 
+bindir: bin
+cert_chain: []
+date: 2012-09-06 00:00:00.000000000 Z
+dependencies: []
+description: A simple way to use mysql indexes in a rails app
+email: scott@railsnewbie.com
+executables: []
+extensions: []
+extra_rdoc_files: []
+files:
+- lib/index_view/column.rb
+- lib/index_view/customization_defaults.rb
+- lib/index_view/implementation.rb
+- lib/index_view/sql_conditions.rb
+- lib/index_view/sql_generator.rb
+- lib/index_view.rb
+homepage: https://github.com/smtlaissezfaire/index_view
+licenses: []
+post_install_message: 
+rdoc_options: []
+require_paths:
+- lib
+required_ruby_version: !ruby/object:Gem::Requirement
+  none: false
+  requirements:
+  - - ! '>='
+    - !ruby/object:Gem::Version
+      version: '0'
+required_rubygems_version: !ruby/object:Gem::Requirement
+  none: false
+  requirements:
+  - - ! '>='
+    - !ruby/object:Gem::Version
+      version: '0'
+requirements: []
+rubyforge_project: 
+rubygems_version: 1.8.24
+signing_key: 
+specification_version: 3
+summary: index_view rails plugin
+test_files: []