fancygrid 1.1.0 → 2.0.0

data/app/views/fancygrid/base/table_frame.html.haml

@@ -1,45 +0,0 @@
-.fg-fancygrid{ :class => fancygrid.name }
-  - if fancygrid.has_complex_search?
-    = render(:template => Fancygrid.search_template, :locals => { :fancygrid => fancygrid })
-  - if fancygrid.has_top_control?
-    = render(:template => Fancygrid.controls_template, :locals => { :fancygrid => fancygrid, :css_class => :"controls top" })
-  
-  .fg-tablewrapper
-    %table
-      %tr.fg-header
-        - fancygrid.each_visible_leaf do |leaf|
-          %th{ :class => leaf.css_class, :table => leaf.record_table_name, :column => leaf.name, :order => leaf.applied_sort_order }
-            .fg-head-wrapper.fg-order-tag
-              = leaf.human_name
-      
-      - if fancygrid.has_simple_search?
-        %tr.fg-search
-          - fancygrid.each_visible_leaf do |leaf|
-            %td{ :class => leaf.css_class }
-              - next unless leaf.searchable
-              - case leaf.search_input_kind
-              - when :none
-                = text_field_tag( leaf.tag_name, leaf.search_value, :class => :"fg-attribute" )
-              - when :select
-                = select_tag( leaf.tag_name, options_for_select(leaf.search_select_collection, :selected => leaf.search_value),  :class => :"fg-attribute" )
-                
-      - fancygrid.each_record do |record|
-        %tr.fg-row{ :class => fancygrid.css_proc_evaluate(record) }
-          - fancygrid.each_visible_leaf do |leaf|
-            %td{ :class => leaf.css_class }
-              = render_fancygrid_leaf(record, leaf, &format_block)
-                
-  - if fancygrid.has_bottom_control?
-    = render(:template => Fancygrid.controls_template, :locals => { :fancygrid => fancygrid, :css_class => :"controls bottom" })
-  - if fancygrid.has_sort_window?
-    = render(:template => Fancygrid.sort_template, :locals => { :fancygrid => fancygrid })
-    
-- unless fancygrid.is_static?
-  :javascript
-    $(function(){
-      var fancyOptions = #{fancygrid.js_options};
-      $(".fg-fancygrid.#{fancygrid.name}").fancygrid(fancyOptions);
-      if(!fancyOptions.isStatic){
-        $(".fg-fancygrid.#{fancygrid.name}").fancygrid("reloadPage");
-      }
-    });

data/config/initializers/fancygrid.rb

@@ -1,67 +0,0 @@
-Fancygrid.setup do |config|
-  
-  # The path to the table template which is rendered when the grid type is set
-  # to :table
-  #
-  # config.table_template = "fancygrid/base/table_frame"
-  
-  # The path to the list template which is rendered when the grid type is set 
-  # to :list
-  #
-  # config.list_template = "fancygrid/base/list_frame"
-  
-  # The path to the controls template which is rendered at the top and the 
-  # bottom of a grid
-  #
-  # config.controls_template = "fancygrid/base/controls"
-
-  # The path to the sort template which defines the view of the column sorting window
-  #
-  # config.sort_template = "fancygrid/base/sort"
-  
-  # The path to the search template which defines the view of the complex search
-  #
-  # config.search_template = "fancygrid/base/search"
-  
-  # The prefix that is used for every cells template. Default value is 
-  # "fancygrid" so every template is expected in the "/app/views/fancygrid"
-  # directory
-  #
-  # config.cells_template_directory = "fancygrid"
-  
-  # The default cells template name. This is combined with the 
-  # 'default_cells_template_directory' to get the full template name
-  #
-  # config.cells_template = "_cells"
-  
-  # Specifies the the internationalization namespace where the plugin will 
-  # lookup for translations.
-  #
-  # config.i18n_scope = "fancygrid"
-  
-  # Value specifying whether the grid name is automatily used as template name
-  # to render a grids cells
-  #
-  # config.use_grid_name_as_cells_template = false
-  
-  # Value specifying whether the search is visible or not when the grid is 
-  # rendered for the first time.
-  #
-  # config.search_visible = false
-  
-  # Specifies the default grid type. Available values are :table and :list
-  # :table will render the data inside a table. Each record will get its own
-  # table row and each attribute its own cell.
-  # :list will render each record inside an unordered list as an li element.
-  # you must provide a rendering block or a template to render each record.
-  #
-  # config.default_grid_type = :table
-  
-  # Default options for number of pages selection
-  #
-  # config.default_per_page_options = [5, 10, 15, 20, 25, 30, 40, 50]
-  
-  # Default value for number of pagers selection
-  #
-  # config.default_per_page_selection = 20
-end

data/lib/fancygrid/helper.rb

@@ -1,129 +0,0 @@
-require "active_support/hash_with_indifferent_access"
-
-module Fancygrid
-  
-  module Helper    
-    
-    def fancygrid_params(name)
-      opts = params[:fancygrid] || HashWithIndifferentAccess.new({})
-      opts[name]
-    end
-    
-    def fancygrid_remote_call?(name)
-      !fancygrid_params(name).nil?
-    end
-    
-    # Creates a fancygrid instance for the given model name, its class and
-    # its table name.
-    # === Example
-    #    fancygrid_for :users do |grid|
-    #      
-    #      # specify attributes to display  
-    #      grid.attributes( :id, :username, :email )
-    #   
-    #      # specify the callback url for ajax loading
-    #      grid.url = users_path
-    #      
-    #      # finally call find with some customized find options
-    #      grid.find( :order => "users.created_at DESC" )
-    #      
-    #    end
-    def fancygrid_for(name, klass = nil, table_name = nil)#:yields: grid
-      raise "block missing" unless block_given?
-      
-      @fancygrid ||= HashWithIndifferentAccess.new({})
-      @fancygrid[name] ||= Grid.new(name, klass, table_name, params)
-      
-      fancygrid_instance = @fancygrid[name]
-      
-      yield fancygrid_instance
-      
-      view_opts = fancygrid_params(name)
-      view_opts ||= fancygrid_instance.load_view_proc_evaluate
-      
-      # load the fancygrid view
-      fancygrid_instance.load_view(view_opts || {})
-      
-      # store the view right back
-      fancygrid_instance.store_view_proc_evaluate
-
-      # now the fancygrid setup is complete and the view is loaded
-      # run the database query when we are in the remote state
-      if !fancygrid_instance.is_static? && fancygrid_remote_call?(name)
-        fancygrid_instance.query_for_data
-      end
-      
-      fancygrid_instance.sort_leafs!
-    end
-    
-    # Renders an existing fancygrid for the given name. You can append a rendering block
-    # or pass a template name as an option for custom rendering.
-    # === Options
-    # * <tt>data</tt> - The data to render
-    # * <tt>template</tt> - The template to use for custom rendering columns
-    # * <tt>url</tt> - The callback url for ajax
-    # * <tt>search_visible</tt> - If true, the search will be visible
-    # * <tt>hide_top_control</tt> - If true, the top control bar will be hidden
-    # * <tt>hide_bottom_control</tt> - If true, the bottom control bar will be hidden
-    # * <tt>grid_type</tt> - may be one of <tt>:list</tt> table <tt>:table</tt> to render a list or a table
-    def fancygrid(name, options=nil, &block)#:yields: column, record, value
-      store_name = name.to_s
-      raise "Missing fancygrid for name '#{store_name}'" if(@fancygrid.nil? || @fancygrid[store_name].nil?)
-      fancygrid_instance = @fancygrid[store_name]
-      
-      options ||= {}
-      [:data, :template, :url, :search_visible, :hide_top_control, 
-       :hide_bottom_control, :grid_type, :search_formats
-      ].each do |option|
-        fancygrid_instance.send(option.to_s + "=", options[option]) if options[option]
-      end
-      
-      format_block = block_given? ? block : nil
-      template = Fancygrid.table_template
-      template = Fancygrid.list_template if(fancygrid_instance.grid_type.to_s == "list")
-      
-      render(:template => template, :locals => { 
-        :fancygrid => fancygrid_instance, 
-        :cells_block => format_block, :format_block => format_block
-      })
-    end
-    
-    # Renders the given <tt>record</tt>, <tt>leaf</tt> and <tt>value</tt> with the
-    # leafs template or the passed rendering block. The result is a column cell content.
-    def format_fancygrid_value(record, leaf, value=nil, &format_block)
-      if block_given?
-        if defined?(Haml::Helpers) && is_haml?
-          capture_haml(leaf, record, value, &format_block)
-        else
-          capture(leaf, record, value, &format_block)
-        end
-      else
-        render( :template => leaf.root.template, :locals => { 
-          :grid => leaf.root, :table => leaf.root,
-          :record => record, 
-          :cell => leaf, :column => leaf, 
-          :value => value 
-        })
-      end
-    end
-    alias :fancy_rendering_for :format_fancygrid_value # backward compatibility
-    
-    # Returns the <tt>value</tt> of the given <tt>leaf</tt> if it is not <tt>:formatable</tt>.
-    # Otherwie the <tt>leaf</tt> ist <tt>value</tt> and the <tt>record</tt> will
-    # be passed to the <tt>format_fancygrid_value</tt> method to render and format
-    # the value. The result is a column cell content.
-    def render_fancygrid_leaf(record, leaf, &format_block)
-      value = leaf.value_from(record)
-      return value if(!leaf.formatable && leaf.root.grid_type == :table)
-      format_fancygrid_value(record, leaf, value, &format_block)
-    end
-    alias :fancyvalue_for :render_fancygrid_leaf # backward compatibility
-
-    def fancygrid_button name, translate_scope, default, alt=nil
-      title = I18n.t(translate_scope, :default => default, :scope => Fancygrid.i18n_scope)
-      alt ||= title
-      image_tag('/images/fancygrid/spacer.gif', :size => '16x16', :class => "#{name} fg-button", :title => title, :alt => title ).html_safe
-    end
-  end
-
-end

data/lib/fancygrid/query_generator.rb

@@ -1,340 +0,0 @@
-require "active_support/hash_with_indifferent_access"
-
-module Fancygrid
-  class QueryGenerator#: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, :fancygrid
-
-    def initialize(options=nil, grid=nil)
-      options ||= {}
-      options = ActiveSupport::HashWithIndifferentAccess.new(options)
-      
-      self.query = {}
-      self.fancygrid = grid
-      
-      self.select(options[:select])
-      self.apply_pagination(options[:pagination])
-      self.apply_search_conditions(options[:operator] || :and, options[:conditions])
-      self.apply_sort_order(options[:order])
-    end
-    
-    def parse_options(options=nil)#:nodoc:
-      options ||= {}
-      [:conditions, :order, :group, :having, :limit, :offset, :joins, :include, :select, :from, :readonly, :lock].each do |option|
-        self.send(option, options[option]) unless options[option].nil?
-      end
-    end
-    
-    # Takes a hash like { :page => 2, :per_page => 20 } and translates it into :limit and :offset options which are
-    # then applied to the final query
-    #
-    def apply_pagination(options=nil)
-      options ||= {}
-      options = ActiveSupport::HashWithIndifferentAccess.new(options)
-      self.limit(options[:per_page].to_i)
-      self.offset(options[:page].to_i * self.limit())
-    end
-    
-    # Takes a hash like { :column => "users.name", :order => "asc" } and translates it into the :order option and
-    # then applies it to the final query
-    #
-    def apply_sort_order(options=nil)
-      self.order("#{options[:column]} #{options[:order].to_s.upcase}") if options
-    end
-    
-    # Takes an operator and an conditions hash like { :<table> => { :<column> => [{ :oparator => <op>, :value => <value> }] } }
-    # and converts them into a query joined by the given operator
-    #
-    def apply_search_conditions(operator, search_conditions)
-      return unless search_conditions
-      
-      operator = logical_operator(operator)
-      
-      conditions = []
-      arguments = []
-      
-      # backward compatibility
-      search_conditions = search_conditions.map do |table, columns|
-        columns.map do |column, value|
-          if value.is_a?(Hash)
-            if value.keys.all? { |key| key.to_s.match(/^\d+$/) }
-              # for hashes like this
-              # :<table> => { 
-              #   :<column> => {
-              #     "0" => { :oparator => <op>, :value => <value> },
-              #     "1" => { :oparator => <op>, :value => <value> },
-              #     "2" => { :oparator => <op>, :value => <value> }
-              #   } 
-              # }
-              #
-              value.map{ |key, opts|
-                { :column => "#{table}.#{column}", :operator => opts[:operator], :value => opts[:value] } 
-              }
-            else
-              # for hashes like this
-              # :<table> => { 
-              #   :<column> => {
-              #     :oparator => <op>, :value => <value>
-              #   } 
-              # }
-              #
-              { :column => "#{table}.#{column}", :operator => value[:operator], :value => value[:value] } 
-            end
-          elsif value.is_a?(Array)
-              # for hashes like this
-              # :<table> => { 
-              #   :<column> => {
-              #     [{ :oparator => <op>, :value => <value> },
-              #      { :oparator => <op>, :value => <value> },
-              #      { :oparator => <op>, :value => <value> }]
-              #   } 
-              # }
-              #
-            value.map{ |opts|
-              { :column => "#{table}.#{column}", :operator => opts[:operator], :value => opts[:value] } 
-            }
-          else
-              # for hashes like this
-              # :<table> => { 
-              #   :<column> => <value>
-              # }
-              #
-            unless value.blank?
-              op = (fancygrid and fancygrid.simple_search_operator(table, column) or :like).to_s
-              { :column => "#{table}.#{column}", :operator => op, :value => value } 
-            else 
-              nil
-            end
-          end
-        end
-      end
-      search_conditions = search_conditions.flatten
-      
-      search_conditions.each do |options|
-        next unless options
-        sql_query, value = comparison_operator(options[:column], options[:operator], options[:value])
-        conditions << sql_query
-        arguments << value if (value)
-      end
-      
-      conditions = [conditions.join(operator)] + arguments
-      append_conditions(:and, conditions)
-    end
-    
-    # Joins two conditions arrays or strings with the given operator
-    #
-    # === Example
-    #
-    #    condition1 = ["first_name = ?", first_name]
-    #    condition2 = ["last_name = ?", last_name]
-    #
-    #    join_conditions(:and, condition1, condition2)
-    #    # => ["(first_name = ?) AND (last_name = ?)", first_name, last_name]
-    #
-    def join_conditions(operator, conditions1, conditions2)
-      conditions1 = Array(conditions1)
-      conditions2 = Array(conditions2)
-      operator = logical_operator(operator).gsub(" ", "")
-      
-      if conditions1.empty?
-        return [] if conditions2.empty?
-        return conditions2
-      elsif conditions2.empty?
-        return conditions1
-      end
-      
-      left_sql = conditions1.shift
-      right_sql = conditions2.shift
-      
-      if left_sql.blank?
-        return [] if right_sql.blank?
-        return [right_sql] + conditions2
-      elsif right_sql.blank?
-        return [left_sql] + conditions1
-      end
-      
-      conditions = "(#{left_sql}) #{operator} (#{right_sql})"
-      return [conditions] + conditions1 + conditions2
-    end
-    
-    def append_conditions(operator, conditions)
-      self.query[:conditions] = join_conditions(operator, self.query[:conditions], conditions)
-    end
-    
-    # An SQL fragment like “administrator = 1”, ["user_name = ?", username], or ["user_name = :user_name", { :user_name => user_name }]
-    #
-    def conditions(conditions=nil)
-      if conditions
-        append_conditions(:and, conditions)
-      end
-      self.query[:conditions]
-    end
-    
-    # An SQL fragment like “created_at DESC, name”. 
-    #
-    def order(order_by=nil)
-      self.query[:order] = order_by if order_by
-      self.query[:order]
-    end
-    
-    # An SQL fragment like “created_at DESC, name”.
-    #
-    def group(group_by=nil)
-      self.query[:group] = group_by if group_by
-      self.query[:group]
-    end
-    
-    # An attribute name by which the result should be grouped. Uses the GROUP BY SQL-clause.
-    #
-    def having(having_sql=nil)
-      self.query[:having] = having_sql if having_sql
-      self.query[:having]
-    end
-    
-    # An integer determining the limit on the number of rows that should be returned.
-    #
-    def limit(num=nil)
-      self.query[:limit] = num if num
-      self.query[:limit]
-    end
-    
-    # An integer determining the offset from where the rows should be fetched. So at 5, it would skip rows 0 through 4.
-    #
-    def offset(num=nil)
-      self.query[:offset] = num if num
-      self.query[:offset]
-    end
-    
-    # Either an SQL fragment for additional joins like “LEFT JOIN comments ON comments.post_id = id” (rarely needed), 
-    # named associations in the same form used for the :include option, which will perform an INNER JOIN on the 
-    # associated table(s), or an array containing a mixture of both strings and named associations. If the value is a 
-    # string, then the records will be returned read-only since they will have attributes that do not correspond to the 
-    # table’s columns. Pass :readonly => false to override.
-    #
-    def joins(to_join_with=nil)
-      self.query[:joins] = to_join_with if to_join_with
-      self.query[:joins]      
-    end
-    
-    # Names associations that should be loaded alongside. The symbols named refer to already defined associations. 
-    # See eager loading under Associations.
-    #
-    def include(to_include=nil)
-      self.query[:include] = to_include if to_include
-      self.query[:include]
-    end
-    
-    # By default, this is “*” as in “SELECT * FROM”, but can be changed if you, for example, want to do a join but not 
-    # include the joined columns. Takes a string with the SELECT SQL fragment (e.g. “id, name”).
-    #
-    def select(select = nil)
-      if select
-        self.query[:select] = Array(self.query[:select])
-        self.query[:select] |= Array(select)
-        
-        if self.query[:select].include?("*")
-          self.query[:select] = ["*"]
-        end
-      end
-      self.query[:select]
-    end
-    
-    # By default, this is the table name of the class, but can be changed to an alternate table name 
-    # (or even the name of a database view).
-    #
-    def from(table_name=nil)
-      self.query[:from] = table_name if table_name
-      self.query[:from]
-    end
-    
-    # Mark the returned records read-only so they cannot be saved or updated.
-    #
-    def readonly(value=nil)
-      self.query[:readonly] = value unless value.nil?
-      self.query[:readonly]
-    end
-    
-    # An SQL fragment like “FOR UPDATE” or “LOCK IN SHARE MODE”. :lock => true gives connection’s default exclusive 
-    # lock, usually “FOR UPDATE”.
-    #
-    def lock(value=nil)
-      self.query[:lock] = value unless value.nil?
-      self.query[:lock]
-    end
-    
-    private
-    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