deli 0.5.0

data/lib/deli/adapters/neo4j.rb

@@ -0,0 +1,54 @@
+module Deli
+  module Adapters
+    # @todo
+    # IceCream.find(:all, :condition => {:flavour => 'chocolate'}, :sort => {:name => :asc})
+    # http://neo4j.rubyforge.org/guides/rails3.html
+    module Neo4j
+      class Query < ::Deli::Query
+        def render(params)
+          
+        end
+      end
+      
+      class Param < ::Deli::Param
+        def render(value)
+          
+        end
+        
+        def render_value(value, operator = nil)
+          value
+        end
+      end
+      
+      class Time < Param
+        include Deli::Param::Time
+      end
+      
+      class Date < Time
+        include Deli::Param::Date
+      end
+      
+      class String < Param
+        include Deli::Param::String
+      end
+      
+      class Number < Param
+        include Deli::Param::Number
+      end
+      
+      class Limit < Param
+        include Deli::Param::Limit
+      end
+      
+      class Order < Param
+        include Deli::Param::Order
+        
+        def render(value)
+          parse(value).map do |item|
+            [render_name(item[:namespace], item[:key]), item[:operators][0] == "+" ? :asc : :desc]
+          end
+        end
+      end
+    end
+  end
+end

data/lib/deli/adapters/simple.rb

@@ -0,0 +1,39 @@
+module Deli
+  module Adapters
+    module Simple
+      class Query < ::Deli::Query
+      end
+      
+      class Param < ::Deli::Param
+      end
+      
+      class Time < Param
+        include Deli::Param::Time
+      end
+      
+      class Date < Time
+        include Deli::Param::Date
+      end
+      
+      class String < Param
+        include Deli::Param::String
+      end
+      
+      class Number < Param
+        include Deli::Param::Number
+      end
+      
+      class Limit < Param
+        include Deli::Param::Limit
+      end
+      
+      class Order < Param
+        include Deli::Param::Order
+      end
+      
+      class Offset < Param
+        include Deli::Param::Offset
+      end
+    end
+  end
+end

data/lib/deli/configuration.rb

@@ -0,0 +1,47 @@
+module Deli  
+  class << self
+    def configuration
+      @configuration ||= Deli::Configuration.new
+    end
+    
+    def configure(&block)
+      yield configuration
+    end
+  end
+  
+  class Configuration
+    attr_accessor :per_page, :sort_direction, :sort_key, :limit_key, :page_key, :default_adapter, :query_operators
+    
+    def initialize
+      @per_page          = 20
+      @sort_direction    = "ASC"
+      @sort_key          = "sort"                 # or "order", etc.
+      @limit_key         = "limit"                # or "per_page", etc.
+      @page_key          = "page"
+      @separator         = "_"                    # or "-"
+      
+      # this is not used, just thinking...
+      # nested relationships as user[location][city]=san+diego
+      @operators         = {                      
+        :gte             => ":value..t",          
+        :gt              => ":value...t",         
+        :lte             => "t..:value",          
+        :lte             => "t...:value",         
+        :range_inclusive => ":i..:f",             # count=0..4
+        :range_exclusive => ":i...:f",            # date=2011-08-10...2011-10-03
+        :in              => [",", "+OR+"],        # tags=ruby,javascript and tags=ruby+OR+javascript
+        :nin             => "-",                  # tags=-ruby,-javascript and tags=ruby+OR+javascript
+        :all             => "[:value]",           # tags=[ruby,javascript] and tags=ruby+AND+javascript
+        :nil             => "[-]",                # tags=[-]
+        :not_nil         => "[+]",                # tags=ruby,[+]
+        :asc             => ["+", ""],
+        :desc            => "-",
+        :geo             => ":lat,:lng,:radius"   # geo=20,-50,7
+      }
+    end
+    
+    def default_adapter
+      @default_adapter ||= :active_record
+    end
+  end
+end

data/lib/deli/controller.rb

@@ -0,0 +1,75 @@
+module Deli
+  class Controller
+    attr_accessor :params, :model_name
+    # not clean at all, couples the classes, but just added quickly to accomplish it.  needs refactoring.
+    
+    def initialize(*args, &block)
+      self.model_name = args.shift
+      options         = args.extract_options!
+      @params         = []
+      @params << param!(:page, :type => :offset) unless options[:page] == false
+      @params << param!(:sort, :type => :order, :default => options[:sort]) unless options[:sort] == false
+      @params << param!(:limit, :type => :limit, :default => options[:limit] || config.per_page) unless options[:limit] == false
+      instance_eval(&block)
+      self
+    end
+    
+    def config
+      Deli.configuration
+    end
+    
+    # handles the following:
+    # 
+    #   match :created_at # figures out attribute from table definition
+    #   match :created_by # figures out that it's on the 'users' table, and to add the join
+    #   match :name, :to => {:vendor => :name} # maps to 'vendors.name' column.
+    #     if 'vendor' is polymorphic, it will figure it out from the association reflection.
+    #     can only handle one level deep for now, no {:vendor => {:role => :name}}
+    #   match :name, :to => :by_vendor_name # maps to named scope
+    # you can also write your own join:
+    #
+    #   match :name, :joins => "INNER JOIN products ON products.id = bookmarks.id"
+    def match(key, options = {})
+      @params << param!(key, options)
+    end
+    
+    def render(params)
+      query.render(params)
+    end
+    
+    def find(key)
+      query.find(key)
+    end
+    
+    def query
+      @query ||= query_class.new(self)
+    end
+    
+    def keys
+      params.map(&:key)
+    end
+    
+    def find_type(key, options = {})
+      model.model_type(key, options)
+    end
+    
+    def model
+      @model ||= "::Deli::Adapters::#{config.default_adapter.to_s.camelize}::Model".constantize.new(model_name)
+    end
+    
+    def query_class
+      @query_class ||= "::Deli::Adapters::#{config.default_adapter.to_s.camelize}::Query".constantize
+    end
+    
+    def find_adapter(options = {})
+      (options[:adapter] || config.default_adapter).to_s.camelize
+    end
+    
+    def param!(key, options = {})
+      "::Deli::Adapters::#{find_adapter(options)}::#{find_type(key.to_s, options).to_s.camelize}".constantize.new(
+        key,
+        options.reverse_merge(:model_name => self.model_name, :parser => self)
+      )
+    end
+  end
+end

data/lib/deli/helper.rb

@@ -0,0 +1,61 @@
+module Deli  
+  module Helper
+    extend ActiveSupport::Concern
+    
+    included do
+      class_attribute :query_controller
+    end
+    
+    module ClassMethods
+      def queries(*args, &block)
+        options               = args.extract_options!
+        name                  = args.shift || self.class.name.underscore.gsub("_controller", "").singularize
+        self.query_controller = ::Deli::Controller.new(name, options, &block)
+        
+        self.send :before_filter, :deli, :only => :index
+      end
+    end
+    
+    module InstanceMethods
+      def deli_controller
+        @deli_controller ||= self.is_a?(::ActionController::Base) ? self.class.query_controller : self.controller.class.query_controller
+      end
+      
+      # The query hash you want to use to paginate.
+      def deli
+        @deli ||= deli_controller.render(query_params) if deli_controller.present?
+        @deli
+      end
+      
+      # Simple method to give you the query parameters we're interested in.
+      def query_params
+        @query_params ||= ::Deli::Query.parse_query(request.query_string)
+      end
+      
+      # with_params(admin_user_membership_path(@user, @membership), :sort => "name")
+      # merges url with existing params
+      def with_params(path, new_params = {})
+        params = query_params.merge(new_params.stringify_keys)
+        return path if params.blank?
+        query_string = ::Deli::Query.build_query(params)
+        "#{path}?#{query_string}"
+      end
+      
+      def param_operators(key)
+        deli_controller.find(key).operators
+      end
+
+      def deli_keys
+        deli_controller.keys
+      end
+      
+      def queryable_keys
+        deli_controller.keys - [:sort, :page, :limit]
+      end
+
+      def queryable_options
+        queryable_keys.map {|i| [i.titleize, i.to_s]}
+      end
+    end
+  end
+end

data/lib/deli/model.rb

@@ -0,0 +1,13 @@
+module Deli
+  class Model
+    attr_reader :name
+    
+    def initialize(name)
+      @name = name
+    end
+    
+    def model_class
+      @model_class ||= name.to_s.camelize.constantize
+    end
+  end
+end

data/lib/deli/pagination.rb

@@ -0,0 +1,117 @@
+module Deli
+  module Pagination
+    def paginate(options)
+      options  = options.dup
+      options[:page] = ((options[:offset] || 0) / options[:limit]).ceil if !options[:page] && options[:limit]
+      options[:per_page] ||= options[:limit]
+      
+      pagenum  = options.fetch(:page) { raise ArgumentError, ":page parameter required" }
+      per_page = options.delete(:per_page) || self.per_page
+      total    = options.delete(:total_entries)
+      
+      count_options = options.delete(:count)
+      options.delete(:page)
+      
+      rel = limit(per_page.to_i).page(pagenum)
+      
+      rel = rel.apply_finder_options(options) if options.any?
+      rel.total_entries = total.to_i          unless total.blank?
+      rel
+    end
+    
+    def page(num)
+      rel              = scoped.extending(::Deli::Pagination::Collection)
+      pagenum          = [num.nil? ? 1 : num, 1].max
+      per_page         = rel.limit_value || ::Deli.configuration.per_page
+      rel              = rel.offset((pagenum.to_i - 1) * per_page.to_i)
+      rel              = rel.limit(per_page) unless rel.limit_value
+      rel
+    end
+    
+    module Collection
+      def total_count
+        @total_count ||= proxy_scope.count(proxy_options.except(:limit, :offset, :order))
+      end
+      
+      def has_next?
+        last_page > current_page
+      end
+      
+      def has_prev?
+        current_page > first_page
+      end
+      
+      def start_count
+        @start_count ||= (((current_page || 1) - 1) * page_size)
+      end
+      
+      def end_count
+        @end_count ||= start_count + size
+      end
+      
+      def current_page
+        unless @current_page
+          if offset_value.blank? || offset_value.zero?
+            @current_page = 1
+          else
+            @current_page = (offset_value.to_f / limit_value).to_i + 1
+          end
+        end
+        
+        @current_page
+      end
+      
+      def next_page
+        unless @next_page
+          @next_page = current_page + 1 > last_page ? last_page : current_page + 1
+        end
+
+        @next_page
+      end
+      
+      def prev_page
+        unless @prev_page
+          @prev_page = current_page - 1 < first_page ? first_page : current_page - 1
+        end
+
+        @prev_page
+      end
+      
+      def first_page
+        1
+      end
+      
+      def last_page
+        page_count
+      end
+      
+      def page_size
+        @page_size ||= limit_value
+      end
+      
+      def page_count
+        @page_count ||= (total_count.to_f / page_size).ceil
+      end
+      
+      # a workaround for AR 3.0.x that returns 0 for #count when page > 1
+      # if +limit_value+ is specified, load all the records and count them
+      if defined?(::ActiveRecord) && ::ActiveRecord::VERSION::STRING < '3.1'
+        def count #:nodoc:
+          limit_value ? length : super
+        end
+      end
+      
+      def total_count #:nodoc:
+        # #count overrides the #select which could include generated columns referenced in #order, so skip #order here, where it's irrelevant to the result anyway
+        c = except(:offset, :limit, :order)
+        # a workaround for 3.1.beta1 bug. see: https://github.com/rails/rails/issues/406
+        c = c.reorder nil
+        # Remove includes only if they are irrelevant
+        c = c.except(:includes) unless references_eager_loaded_tables?
+        # .group returns an OrderdHash that responds to #count
+        c = c.count
+        c.respond_to?(:count) ? c.count : c
+      end
+    end
+  end
+end

data/lib/deli/param.rb

@@ -0,0 +1,189 @@
+module Deli
+  class Param
+    module Time
+      def parse(value, as = :time)
+        values  = []
+        
+        value.to_s.split(/[\s,\+]/).each do |string|
+          if string =~ /([^\.]+)?(\.\.)([^\.]+)?/
+            starts_on, operator, ends_on = $1, $2, $3
+            range   = []
+            range   << parse_value(starts_on, [">="]) if !!(starts_on.present? && starts_on =~ /^\d/)
+            range   << parse_value(ends_on, ["<="])   if !!(ends_on.present? && ends_on =~ /^\d/)
+            values  << range
+          else
+            values  << [parse_value(string, ["="])]
+          end
+        end
+        
+        values
+      end
+      
+      def parse_value(value, operators)
+        super(::Time.zone.parse(value), operators)
+      end
+    end
+    
+    module Date
+      include Time
+      
+      def parse(value)
+        super(value, :date)
+      end
+    end
+    
+    module String
+      def parse(value)
+        arrays = value.split(/(?:[\s|\+]OR[\s|\+]|\||,)/).map do |node|
+          values = []
+          
+          # ([\+\-\^]?[\w@\-_\s\d\.\$]+|-?\'[\w@-_\s\d\+\.\$]+\')
+          node.scan(/([\+\-\^]?[\w@_\s\d\.\$]+|-?\'[\w@-_\s\d\+\.\$]+\')/).flatten.each do |token|
+            token.gsub!(/^\+?-+/, "")
+            negation = $& && $&.length > 0
+            token.gsub!(/^\'(.+)\'$/, "\\1")
+            exact    = $& && $&.length > 0
+            
+            if negation
+              operators = [exact ? "!=" : "!~"]
+            else
+              operators = [exact ? "=" : "=~"]
+            end
+            
+            operators << "^" if token =~ /^\+?\-?\^/
+            operators << "$" if token =~ /\$$/
+            
+            values    << parse_value(clean(token), operators)
+          end
+          
+          values
+        end
+      end
+    end
+    
+    module Number
+      def parse(value)
+        values  = []
+        
+        value.to_s.split(/[,\|]/).each do |string|
+          if string =~ /([^\.]+)?(\.{2})([^\.]+)?/
+            starts_on, operator, ends_on = $1, $2, $3
+            range   = []
+            range   << parse_value(starts_on, [">="]) if starts_on.present? && starts_on =~ /^\d/
+            range   << parse_value(ends_on, ["<="])   if ends_on.present? && ends_on =~ /^\d/
+            values  << range
+          else
+            values  << [parse_value(string, ["="])]
+          end
+        end
+        
+        values
+      end
+      
+      def parse_value(value, operators)
+        super(value.to_i, operators) # or to_f ?
+      end
+    end
+    
+    module Limit
+      def parse(value)
+        result = value.to_s.scan(/(\d+)/).flatten[0]
+        result.present? ? result.to_i : self.default
+      end
+      
+      def render(value)
+        parse(value)
+      end
+    end
+    
+    module Order
+      def parse(value)
+        value.split(",").map do |string|
+          string.scan(/([\w-]+[^\-\+])([\+\-])?/).map do |token, operator|
+            operator = operator == "-" ? "-" : "+"
+            token    = clean(token)
+            
+            if controller.present?
+              param = controller.find(token)
+              token = param.table_key
+            end
+
+            {:namespace => namespace, :key => token, :operators => [operator]}
+          end
+        end.flatten
+      end
+      
+      def order_hash(value)
+        value.split(",").inject(ActiveSupport::OrderedHash.new) do |hash, string|
+          string.scan(/([\w-]+[^\-\+])([\+\-])?/).each do |token, operator|
+            hash[clean(token)] = operator == "-" ? "-" : "+"
+          end
+          hash
+        end
+      end
+    end
+    
+    module Offset
+      def parse(value)
+        result = value.to_s.scan(/(\d+)/).flatten[0]
+        result.present? ? result.to_i : self.default
+      end
+      
+      def render(value)
+        parse(value)
+      end
+    end
+    
+    # Todo
+    module Geo
+      def parse(value)
+        value.to_s.split(/,\s*/).map(&:to_f) # [41.31419, -88.1847]
+      end
+      
+      def render(value)
+        parse(value)
+      end
+    end
+    
+    attr_accessor :controller, :key, :model_name, :namespace, :exact, :default
+    
+    def initialize(key, options = {})
+      self.controller = options[:controller]
+      self.key        = key.to_s
+      self.model_name = options[:model_name]
+      self.namespace  = self.model_name.to_s.pluralize.to_sym if model_name.present?
+      self.exact      = options[:exact] || false
+      self.default    = options[:default]
+    end
+    
+    def parse(value)
+      value
+    end
+    
+    def render(value)
+      value
+    end
+    
+    def parse_value(value, operators)
+      {
+        :namespace => namespace,
+        :key       => key, 
+        :operators => operators,
+        :value     => value
+      }
+    end
+    
+    def inspect
+      "#<#{self.class.name} @key=#{key.inspect} @model_name=#{model_name.inspect}>"
+    end
+    
+    protected
+    def clean(string)
+      string.gsub(/^-/, "").gsub(/^\+-/, "").gsub(/^'|'$/, "").gsub("+", " ").gsub(/^\^/, "").gsub(/\$$/, "").strip
+    end
+
+    def model_class
+      @model_class ||= model_name.to_s.camelize.constantize
+    end
+  end
+end