datagrid 0.0.3

data/lib/datagrid/columns.rb

@@ -0,0 +1,105 @@
+module Datagrid
+  
+  class OrderUnsupported < StandardError
+  end
+  
+  module Columns
+    require "datagrid/columns/column"
+
+    def self.included(base)
+      base.extend         ClassMethods
+      base.class_eval do
+
+        include Datagrid::Core
+
+        datagrid_attribute :order
+        datagrid_attribute :reverse
+
+
+      end
+      base.send :include, InstanceMethods
+    end # self.included
+
+    module ClassMethods
+
+      def columns
+        @columns ||= []
+      end
+
+      def column(name, options = {}, &block)
+        block ||= lambda do
+          self.send(name)
+        end
+        self.columns << Datagrid::Columns::Column.new(self, name, options, &block)
+      end
+
+
+    end # ClassMethods
+
+    module InstanceMethods
+
+      def header
+        self.class.columns.map(&:header)
+      end
+
+      def row_for(asset)
+        self.class.columns.map do |column|
+          column.value(asset)
+        end
+      end
+
+      def hash_for(asset)
+        result = {}
+        self.class.columns.each do |column|
+          result[column.name] = column.value(asset)
+        end
+        result
+      end
+
+      def data
+        self.assets.map do |asset|
+          self.row_for(asset)
+        end
+      end
+
+      def data_hash
+        self.assets.map do |asset|
+          hash_for(asset)
+        end
+      end
+
+      def assets
+        result = super
+        if self.order
+          column = column_by_name(self.order)
+          raise Datagrid::OrderUnsupported, "Can not sort #{self.inspect} by #{name.inspect}" unless column
+          result = result.order(self.reverse ? column.order : column.desc_order)
+        end
+        result
+      end
+
+      def to_csv(options = {})
+        require "fastercsv"
+        FasterCSV.generate(
+          {:headers => self.header, :write_headers => true}.merge(options)
+        ) do |csv|
+          self.data.each do |row|
+            csv << row
+          end
+        end
+      end
+
+      def columns
+        self.class.columns
+      end
+
+      def column_by_name(name)
+        self.columns.find do |col|
+          col.name.to_sym == name.to_sym
+        end
+      end
+
+    end # InstanceMethods
+
+  end
+end

data/lib/datagrid/columns/column.rb

@@ -0,0 +1,46 @@
+
+class Datagrid::Columns::Column
+
+  attr_accessor :grid, :options, :block, :name
+
+  def initialize(grid, name, options = {}, &block)
+    self.grid = grid
+    self.name = name
+    self.options = options
+    self.block = block
+  end
+
+  def value(object)
+    value_for(object)
+  end
+
+  def value_for(object)
+    object.instance_eval(&self.block)
+  end
+
+  def format
+    self.options[:format]
+  end
+
+  def label
+    self.options[:label]
+  end
+
+  def header
+    self.options[:header] || 
+      I18n.translate(self.name, :scope => "reports.#{self.grid}.columns", :default => self.name.to_s.humanize )
+  end
+
+  def order
+    if options.has_key?(:order)
+      self.options[:order]
+    else
+      grid.scope.column_names.include?(name.to_s) ? [grid.scope.table_name, name].join(".") : nil
+    end
+  end
+
+  def desc_order
+    order ? order.to_s + " DESC" : nil
+  end
+
+end

data/lib/datagrid/core.rb

@@ -0,0 +1,99 @@
+module Datagrid
+  module Core
+
+    def self.included(base)
+      base.extend         ClassMethods
+      base.class_eval do
+
+      end
+      base.send :include, InstanceMethods
+    end # self.included
+
+    module ClassMethods
+
+      def datagrid_attribute(name, &block)
+        unless datagrid_attributes.include?(name)
+          block ||= lambda do |value|
+            value
+          end
+          datagrid_attributes << name
+          define_method name do
+            instance_variable_get("@#{name}")
+          end
+
+          define_method :"#{name}=" do |value|
+            instance_variable_set("@#{name}", block.call(value))
+          end
+        end
+      end
+
+      def datagrid_attributes
+        @datagrid_attributes ||= []
+      end
+
+      def scope(&block)
+        if block
+          @scope = block
+        else
+          raise(Datagrid::ConfigurationError, "Scope not defined") unless @scope
+          @scope.call
+        end
+      end
+
+      def param_name
+        self.to_s.underscore.split('/').last
+      end
+
+    end # ClassMethods
+
+    module InstanceMethods
+
+      def initialize(attributes = nil)
+        super()
+
+        if attributes
+          self.attributes = attributes
+        end
+      end
+
+      def attributes
+        result = {}
+        self.class.datagrid_attributes.each do |name|
+          result[name] = self[name]
+        end
+        result
+      end
+
+      def [](attribute)
+        self.send(attribute)
+      end
+
+      def []=(attribute, value)
+        self.send(:"#{attribute}=", value)
+      end
+
+      def assets
+        scope.scoped({})
+      end
+
+      def attributes=(attributes)
+        attributes.each do |name, value|
+          self[name] = value
+        end
+      end
+
+      def paginate(*args, &block)
+        self.assets.paginate(*args, &block)
+      end
+
+      def scope
+        self.class.scope
+      end
+
+      def param_name
+        self.class.param_name
+      end
+      
+    end # InstanceMethods
+  end
+end

data/lib/datagrid/filters.rb

@@ -0,0 +1,150 @@
+module Datagrid
+  module Filters
+
+    require "datagrid/filters/base_filter"
+    require "datagrid/filters/enum_filter"
+    require "datagrid/filters/boolean_enum_filter"
+    require "datagrid/filters/boolean_filter"
+    require "datagrid/filters/date_filter"
+    require "datagrid/filters/default_filter"
+    require "datagrid/filters/filter_eval"
+    require "datagrid/filters/integer_filter"
+    require "datagrid/filters/composite_filters"
+
+    FILTER_TYPES = {
+      :date => Filters::DateFilter,
+      :string => Filters::DefaultFilter,
+      :default => Filters::DefaultFilter,
+      :eboolean => Filters::BooleanEnumFilter ,
+      :boolean => Filters::BooleanFilter ,
+      :integer => Filters::IntegerFilter,
+      :enum => Filters::EnumFilter,
+    }
+
+    def self.included(base)
+      base.extend         ClassMethods
+      base.class_eval do
+
+        include Datagrid::Core
+        include Datagrid::Filters::CompositeFilters
+
+      end
+      base.send :include, InstanceMethods
+    end # self.included
+
+    module ClassMethods
+
+      def filters
+        @filters ||= []
+      end
+
+      def filter_by_name(attribute)
+        self.filters.find do |filter|
+          filter.name.to_sym == attribute.to_sym
+        end
+      end
+
+
+      # Defines the accessible attribute that is used to filter
+      # scope by the specified value with specified code.
+      # 
+      # Example:
+      #     
+      #   class UserGrid 
+      #     include Datagrid
+      #
+      #     filter(:name)
+      #     filter(:posts_count, :integer) do |value|
+      #       self.where(["posts_count >= ?", value])
+      #     end
+      #
+      #     scope do
+      #       User.order("users.created_at desc")
+      #     end
+      #   end
+      #
+      # Each filter becomes grid atttribute.
+      # In order to create grid that display all users with name 'John' that have more than zero posts:
+      #
+      #   grid = UserGrid.new(:posts_count => 1, :name => "John")
+      #   grid.assets # SELECT * FROM users WHERE users.posts_count > 1 AND name = 'John'
+      #
+      # Important! Take care about non-breaking the filter chain and force objects loading in filter.
+      # The filter block should always return a <tt>ActiveRecord::Scope</tt> rather than <tt>Array</tt>
+      #
+      # = Default filter block
+      #
+      # If no block given filter is generated automatically as simple select by filter name from scope.
+      #
+      # = Filter types
+      #
+      # Filter does types conversion automatically.
+      # The following filter types are supported:
+      #
+      # * <tt>:string</tt> (default) - converts value to string
+      # * <tt>:date</tt> - converts value to date using date parser
+      # * <tt>:enum</tt> - designed to be collection select. Additional options for easy form generation:
+      #   * <tt>:select</tt> (required) - collection of values to match agains.
+      #   * <tt>:multiple</tt> - if true multiple values can be assigned to this filter. Default: false.
+      # * <tt>:eboolean</tt> - subtype of enum filter that provides select of "Yes", "No" and "Any". Could be useful.
+      # * <tt>:integer</tt> - converts given value to integer.
+      #   
+      #
+      def filter(attribute, type = :string, options = {}, &block)
+
+        klass = type.is_a?(Class) ? type : FILTER_TYPES[type]
+        raise ConfigurationError, "filter class not found" unless klass
+
+        block ||= default_filter(attribute)
+
+        filter = klass.new(self, attribute, options, &block)
+        self.filters << filter
+
+        datagrid_attribute(attribute) do |value|
+          filter.format(value)
+        end
+
+      end
+
+      protected
+      def default_filter(attribute)
+        if self.scope.column_names.include?(attribute.to_s)
+          lambda do |value|
+            self.scoped(:conditions => {attribute => value})
+          end
+        else
+          raise ConfigurationError, "Not able to generate default filter. No column '#{attribute}' in #{self.scope.table_name}."
+        end
+      end
+
+    end # ClassMethods
+
+    module InstanceMethods
+
+      def initialize(*args, &block)
+        self.filters.each do |filter|
+          self[filter.name] = filter.default
+        end
+        super(*args, &block)
+      end
+
+      def assets
+        result = super
+        self.class.filters.each do |filter|
+          result = filter.apply(result, filter_value(filter))
+        end
+        result
+      end
+
+      def filters
+        self.class.filters
+      end
+
+      def filter_value(filter)
+        self[filter.name]
+      end
+
+    end # InstanceMethods
+
+  end
+end

data/lib/datagrid/filters/base_filter.rb

@@ -0,0 +1,33 @@
+require "datagrid/filters/filter_eval"
+
+class Datagrid::Filters::BaseFilter
+
+  attr_accessor :grid, :options, :block, :name
+
+  def initialize(grid, name, options = {}, &block)
+    self.grid = grid
+    self.name = name
+    self.options = options
+    self.block = block
+  end
+
+  def apply(scope, value)
+    return scope if value.nil? && !options[:allow_nil]
+    return scope if value.blank? && !options[:allow_blank]
+    ::Datagrid::Filters::FilterEval.new(self, scope, value).run
+  end
+
+  def format(value)
+    raise NotImplementedError, "#format(value) suppose to be overwritten"
+  end
+
+  def header
+    I18n.translate(self.name, :scope => "datagrid.#{grid.class.to_s.underscore.split("/").last}.filters", :default => self.name.to_s.humanize)
+  end
+
+  def default
+    self.options[:default]
+  end
+
+end
+

data/lib/datagrid/filters/boolean_enum_filter.rb

@@ -0,0 +1,21 @@
+class Datagrid::Filters::BooleanEnumFilter < Datagrid::Filters::EnumFilter
+
+  YES = "YES"
+  NO = "NO"
+  VALUES = {YES => true, NO => false}
+
+  def initialize(report, attribute, options = {}, &block)
+    options[:allow_blank] = true unless options.has_key?(:allow_blank)
+    options[:select] = VALUES.keys
+    super(report, attribute, options, &block)
+  end
+
+  def apply(scope, value)
+    super(scope, to_boolean(value))
+  end
+
+  def to_boolean(value)
+    VALUES[value]
+  end
+
+end