fancygrid 1.1.0 → 2.0.0

data/lib/fancygrid/object_wrapper.rb

@@ -0,0 +1,24 @@
+module Fancygrid
+  class ObjectWrapper      
+    
+    # Initializes the object wrapper
+    #
+    def initialize obj
+      @wrapped = obj
+    end
+    
+    # Gets the wrapped object
+    #
+    def object
+      @wrapped
+    end
+    
+    # Sends the missing method to the wrapped object
+    # and stores the result as the new wrapped object
+    #
+    def method_missing(method, *args, &block)
+      @wrapped = @wrapped.send(method, *args)
+      return self
+    end
+  end
+end

data/lib/fancygrid/orm/active_record.rb

@@ -0,0 +1,39 @@
+module Fancygrid
+  module Orm
+    class ActiveRecord
+      include Fancygrid::Orm::SqlGenerator
+
+      def execute resource_class, &block
+        query = resource_class.where({})
+
+        if self.query_options[:select].present?
+          query = query.select(self.query_options[:select])
+        end
+        
+        if self.query_options[:conditions].present?
+          query = query.where(self.query_options[:conditions])
+        end
+        
+        if self.query_options[:order].present?
+          query = query.order(self.query_options[:order])
+        end
+        
+        if block_given?
+          wrapper = Fancygrid::ObjectWrapper.new(query)
+          yield wrapper 
+          query = wrapper.object
+        end
+        
+        count = query.count
+        
+        if !self.query_options[:offset].nil? && !self.query_options[:limit].nil?
+          query = query.offset(self.query_options[:offset])
+          query = query.limit(self.query_options[:limit])
+        end
+
+        return query.to_a, count
+      end
+            
+    end
+  end
+end

data/lib/fancygrid/orm/sql_generator.rb

@@ -0,0 +1,127 @@
+module Fancygrid
+  module Orm
+    module SqlGenerator#:nodoc:
+      
+      OPERATOR_NAMES = [
+        :equal, :not_equal, :less, :less_equal, :greater, :greater_equal, :starts_with, :ends_with, 
+        :like, :is_null, :is_not_null, :is_true, :is_not_true, :is_false, :is_not_false, :in, :not_in
+      ]
+      
+      attr_accessor :query_options
+    
+      def initialize(options)
+
+        self.query_options = {}
+        
+        if grid = options[:grid]
+          self.query_options[:order] = grid.view_state.sql_order
+        end
+        
+        if select = options[:select]
+          self.query_options[:select] = select
+        end
+        
+        if pagination = options[:pagination]
+          self.query_options[:limit] = pagination[:per_page].to_i
+          self.query_options[:offset] = (pagination[:page].to_i - 1) * pagination[:per_page].to_i
+        end
+        
+        if conditions = self.build_conditions(options[:operator], options[:conditions])
+          self.query_options[:conditions] = conditions
+        end
+      end
+      
+      def execute resource_class
+        raise "called execute on abstract class"
+      end
+      
+      protected
+      
+      def build_conditions(operator, search_conditions)
+        return nil if Array(search_conditions).empty?
+        
+        operator = logical_operator(operator)
+        conditions = []
+        arguments = []
+        
+        Array(search_conditions).each do |options|
+          sql, value = comparison_operator(options[:identifier], options[:operator], options[:value])
+          conditions << sql
+          arguments << value unless value.nil?
+        end
+        
+        return [conditions.join(operator)] + arguments
+      end
+
+      def comparison_operator(column, operator, value)
+        operator = case operator.to_s
+        when "equal"
+          "="
+        when "not_equal"
+          "!="
+        when "less"
+          "<"
+        when "less_equal"
+          "<="
+        when "greater"
+          ">"
+        when "greater_equal"
+          ">="
+        when "starts_with"
+          value = "#{value.to_param}%"
+          "LIKE"
+        when "ends_with"
+          value = "%#{value.to_param}"
+          "LIKE"
+        when "like"
+          value = "%#{value.to_param}%"
+          "LIKE"
+        when "is_null"
+          value = nil
+          "IS NULL"
+        when "is_not_null"
+          value = nil
+          "IS NOT NULL"
+        when "is_true"
+          value = nil
+          "IS TRUE"
+        when "is_not_true"
+          value = nil
+          "IS NOT TRUE"
+        when "is_false"
+          value = nil
+          "IS FALSE"
+        when "is_not_false"
+          value = nil
+          "IS NOT FALSE"
+        when "in"
+          value = value.split(",")
+          "IN"
+        when "not_in"
+          value = value.split(",")
+          "NOT IN"
+        else
+          "="
+        end
+        
+        if value.nil?
+          return "( #{column} #{operator} )", value
+        else
+          return "( #{column} #{operator} (?) )", value
+        end
+        
+      end
+      
+      def logical_operator(name)
+        case name.to_s
+        when "all", "and"
+          " AND "
+        else
+          " OR "
+        end
+      end
+     
+       
+    end
+  end
+end

data/lib/fancygrid/view/helper.rb

@@ -0,0 +1,44 @@
+module Fancygrid  
+  module View
+    module Helper
+      # Renders an existing fancygrid for the given name. A rendering block
+      # may be passed to format column values.
+      #
+      def fancygrid(name, options={}, &block)#:yields: column, record, value
+        instance = @fancygrid_collection && @fancygrid_collection[name]
+        raise "Unknown fancygrid name: '#{name}'" if instance.nil?
+        render :template => instance.options[:base_template], :locals => { :fancygrid => instance, :format_block => block }
+      end
+      
+      # Fetches a value from given record and applies a formatter on it.
+      # 
+      def render_fancygrid_cell(record, column, &format_block)
+        value = column.fetch_value_and_format(record)
+        format_fancygrid_value(record, column, value, &format_block)
+      end
+      
+      # Renders the given <tt>record</tt>, <tt>column</tt> and <tt>value</tt> 
+      # with the formatter block.
+      #
+      def format_fancygrid_value(record, column, value=nil, &format_block)
+        if block_given?
+          if defined?(Haml::Helpers) && is_haml?
+            capture_haml(column, record, value, &format_block)
+          else
+            capture(column, record, value, &format_block)
+          end
+        #elsif !column.root.cell_template.nil?
+        #  render( :template => column.root.cell_template, :inline => true, :locals => { 
+        #    :grid => column.root,
+        #    :record => record, 
+        #    :column => column, 
+        #    :value => value 
+        #  })
+        else
+          value
+        end
+      end
+    end
+  end
+end
+

data/lib/fancygrid/view_state.rb

@@ -0,0 +1,161 @@
+module Fancygrid#:nodoc:
+
+  #{
+  #  :columns => [
+  #    { :identifier => <string>, :visible => <bool>, :position => <number> }
+  #  ]
+  #  :conditions => [
+  #    { :identifier => <string>, :operator => <string>, :value => <string> }
+  #  ], 
+  #  :operator => ["all"|"any"],
+  #  :order => { :identifier => <string>, :direction => ["asc"|"desc"|""] },
+  #  :pagination => { :page => <number>, :per_page => <number> }
+  #}  
+  class ViewState
+    
+    attr_accessor :dump
+      
+    def initialize(dump = {})
+      raise ArgumentError, "'dump' must be a Hash" unless dump.is_a? Hash
+      self.dump = dump.with_indifferent_access
+      self.fix_columns
+      self.fix_conditions
+      self.fix_order
+      self.fix_pagination
+    end
+    
+    def column_options(node)
+      self.dump[:columns].select { |hash| 
+        node.identifier == hash[:identifier] 
+      }.first || {}
+    end
+    
+    def column_option(node, option, default)
+      self.column_options(node).fetch(option, default)
+    end
+    
+    def column_conditions(node)
+      self.dump[:conditions].select { |hash| 
+        node.identifier == hash[:identifier] 
+      }.first || {}
+    end
+    
+    def column_condition(node, option, default)
+      self.column_conditions(node).fetch(option.to_s, default)
+    end
+
+    def conditions
+      self.dump[:conditions]
+    end
+        
+    def operator
+      self.dump[:operator]
+    end
+    
+    def conditions_match_all?
+      self.dump.fetch(:conditions_match, :any).to_s == "all"
+    end
+    
+    def order
+      self.dump.fetch(:order, {})
+    end
+    
+    def order_table
+      self.order[:identifier].to_s.split(".").first
+    end
+    
+    def order_column
+      self.order[:identifier].to_s.split(".").last
+    end
+
+    def order_direction
+      self.order[:direction]
+    end
+
+    def column_order(node)
+      if node.identifier.to_s == self.order[:identifier].to_s
+        self.order_direction
+      end
+    end
+    
+    def ordered?
+      !(order_table.blank? || order_column.blank? || order_direction.blank?)
+    end
+    
+    def sql_order
+      return nil unless ordered?
+      return "#{order_table}.#{order_column} #{order_direction}"
+    end
+    
+    def pagination
+      self.dump.fetch(:pagination, {})
+    end
+
+    def pagination_page default=1
+      result = self.pagination.fetch(:page, default)
+      return default if result <= 0
+      return result
+    end
+
+    def pagination_per_page default=20
+      result = self.pagination.fetch(:per_page, default)
+      return default if result <= 0
+      return result
+    end
+    
+    def pagination_options(default_page, default_per_page)
+      {
+        :page => self.pagination_page(default_page).to_i,
+        :per_page => self.pagination_per_page(default_per_page).to_i
+      }
+    end
+    
+    def search_visible
+      self.dump.fetch(:search_visible, false)
+    end
+
+    protected
+    # converts the columns option into an array of hashes 
+    # 
+    def fix_columns
+      h = self.dump
+      # conditions may be passed as a hash like { "0" => {}, "1" => {}}
+      h[:columns] = h[:columns].values if h[:columns].is_a? Hash
+      # ensure that columns is an array
+      h[:columns] = [] unless h[:columns].is_a? Array
+      # filter out invalid entries.
+      h[:columns] = h[:columns].select { |entry| entry.is_a?(Hash) }
+    end
+    
+    # converts the conditions options in to an array of hashes 
+    # with at least an :identifier and :operator
+    #
+    #    { :identifier => <string>, :operator => [all|any] }
+    def fix_conditions
+      h = self.dump
+
+      # conditions may be passed as a hash like { "0" => {}, "1" => {}}
+      h[:conditions] = h[:conditions].values if h[:conditions].is_a? Hash
+      # ensure that conditions is an array
+      h[:conditions] = [] unless h[:conditions].is_a? Array
+      # filter out invalid entries.
+      h[:conditions] = h[:conditions].select { |entry| entry.is_a?(Hash) && entry[:identifier].present? && entry[:operator].present? }
+      h[:operator] = "all" unless %w(all any).include? h[:operator]
+    end
+    
+    def fix_order
+      self.dump[:order] = {} unless self.dump[:order].is_a? Hash
+      hash = self.dump[:order]
+      hash.delete(:identifier)unless hash[:identifier].is_a? String
+      hash.delete(:direction) unless %w(asc desc).include? hash[:direction]
+    end
+    
+    def fix_pagination
+      self.dump[:pagination] = {} unless self.dump[:pagination].is_a? Hash
+      hash = self.dump[:pagination]
+      hash[:page]     = hash[:page].to_i     if hash.has_key? :page
+      hash[:per_page] = hash[:per_page].to_i if hash.has_key? :per_page
+    end
+
+  end
+end

data/spec/column_spec.rb

@@ -0,0 +1,29 @@
+require "spec_helper"
+
+describe Fancygrid::Column do
+  
+  class DummyClass
+    def self.table_name; "dummy_table"; end;
+  end
+  
+  before :each do
+    @node = Fancygrid::Node.new(nil, :project, {})
+  end
+  
+  it "#identifier should combine table_name and column name" do
+    @node.column :description
+    @node.children.last.identifier.should == "projects.description"
+  end
+  
+  it "#select_name should combine table_name and column name" do
+    @node.column :description
+    @node.children.last.identifier.should == "projects.description"
+  end
+  
+  it "#tag_class should contain table_name and name" do
+    @node.column :description
+    @node.children.last.tag_class.include?("projects").should be true
+    @node.children.last.tag_class.include?("description").should be true
+  end
+
+end

data/spec/dummy/app/controllers/application_controller.rb

@@ -1,3 +1,51 @@
 class ApplicationController < ActionController::Base
+
   protect_from_forgery
+    
+  def index
+    #Project.destroy_all
+    if Project.count < 10
+      10.times do |i|
+        proj = Project.create :title => "Project #{i}"
+        3.times do
+          proj.tickets.create!
+        end
+      end
+    end
+    
+    projects_grid = fancygrid_for :projects, :builder => MyGrid, :persist => true do |grid|
+      grid.ajax_url = "/index.html"
+      grid.paginate = request.format.html?
+      grid.select = true
+      grid.find do |q|
+        q.includes :tickets
+      end
+    end
+    
+    respond_to do |format|
+      format.html { render }
+      format.json { render :json => projects_grid.records }
+      format.xml { render :xml => projects_grid.dump_records }
+    end
+  end
+end
+
+class MyGrid < Fancygrid::Grid
+  
+  def apply_options(options)
+    super
+    
+    self.attributes :id, :title
+    self.columns :hash, :object_id
+    self.columns_for :tickets do |t|
+      t.columns :id
+    end
+    #self.components -= [:search_bar]
+    self.components += [:sort_window]
+    #self.ajax_url = "/"
+    self.ajax_type = :get
+    
+    self.search_filter "projects.title", [["-- choose --", ""], [:foo, :foo], [:bar, :bar]]
+  end
+
 end