deli 0.5.0

data/Rakefile

@@ -0,0 +1,77 @@
+require 'rake'
+require "rake/rdoctask"
+require 'rake/gempackagetask'
+
+spec = Gem::Specification.new do |s|
+  s.name              = "deli"
+  s.authors           = ["Lance Pollard"]
+  s.version           = "0.5.0"
+  s.summary           = "Tasty URL Parameters for Rails"
+  s.homepage          = "http://github.com/viatropos/deli"
+  s.email             = "lancejpollard@gmail.com"
+  s.description       = "Tasty URL Parameters for Rails"
+  s.has_rdoc          = false
+  s.rubyforge_project = "deli"
+  s.platform          = Gem::Platform::RUBY
+  s.files             = %w(Rakefile) + Dir["{lib,rails,spec,app}/**/*"] - Dir["spec/tmp"]
+  s.require_path      = "lib"
+end
+
+Rake::GemPackageTask.new(spec) do |pkg|
+  pkg.gem_spec    = spec
+end
+
+desc 'run unit tests'
+task :test do
+  Dir["test/**/*"].each do |file|
+    next unless File.basename(file) =~ /test_/
+    next unless File.extname(file) == ".rb"
+    system "ruby #{file}"
+  end
+end
+
+desc "Create .gemspec file (useful for github)"
+task :gemspec do
+  File.open("#{spec.name}.gemspec", "w") do |f|
+    f.puts spec.to_ruby
+  end
+end
+
+desc "Build the gem into the current directory"
+task :gem => :gemspec do
+  `gem build #{spec.name}.gemspec`
+end
+
+desc "Publish gem to rubygems"
+task :publish => [:package] do
+  %x[gem push #{spec.name}-#{spec.version}.gem]
+end
+
+desc "Print a list of the files to be put into the gem"
+task :manifest do
+  File.open("Manifest", "w") do |f|
+    spec.files.each do |file|
+      f.puts file
+    end
+  end
+end
+
+desc "Install the gem locally"
+task :install => [:package] do
+  File.mkdir("pkg") unless File.exists?("pkg")
+  command = "gem install pkg/#{spec.name}-#{spec.version} --no-ri --no-rdoc"
+  command = "sudo #{command}" if ENV["SUDO"] == true
+  sh %{#{command}}
+end
+
+desc "Generate the rdoc"
+Rake::RDocTask.new do |rdoc|
+  files = ["README.markdown", "lib/**/*.rb"]
+  rdoc.rdoc_files.add(files)
+  rdoc.main = "README.markdown"
+  rdoc.title = spec.summary
+end
+
+task :yank do
+  `gem yank #{spec.name} -v #{spec.version}`
+end

data/lib/deli.rb

@@ -0,0 +1,18 @@
+require 'rubygems'
+require 'time'
+require 'date'
+require 'active_support'
+require 'active_support/core_ext'
+require 'uri'
+
+$:.unshift File.dirname(__FILE__)
+
+require "deli/configuration"
+require "deli/railtie" if defined?(::Rails)
+require "deli/query"
+require "deli/model"
+require "deli/controller"
+require "deli/helper"
+require "deli/pagination"
+require "deli/param"
+require "deli/adapters"

data/lib/deli/adapters.rb

@@ -0,0 +1,9 @@
+module Deli
+  module Adapters
+    autoload :ActiveRecord, "deli/adapters/active_record"
+    autoload :Cassandra, "deli/adapters/cassandra"
+    autoload :Mongoid, "deli/adapters/mongoid"
+    autoload :Neo4j, "deli/adapters/neo4j"
+    autoload :Simple, "deli/adapters/simple"
+  end
+end

data/lib/deli/adapters/active_record.rb

@@ -0,0 +1,251 @@
+module Deli
+  module Adapters
+    module ActiveRecord
+      class Model < Deli::Model
+        def model_type(key, options = {})
+          default = options[:type]
+          
+          if default.present?
+            value = default.to_sym
+          else
+            value = model_class.columns.detect { |i| i.name == key }
+            value = value.present? ? value.type : nil
+          end
+          
+          raise ::ArgumentError.new("Must specify type, such as: `match :#{key}, :type => :string`") if value.blank?
+
+          case value
+          when :datetime, :time
+            :time
+          when :date
+            :date
+          when :integer, :float, :decimal, :count
+            :number
+          when :sort, :order
+            :order
+          when :string, :text
+            :string
+          else
+            value
+          end
+        end
+      end
+      
+      class Query < ::Deli::Query
+        # Converts request parameters into an options Hash for ActiveRecord finder methods.# Outputs a query hash for Mongoid.
+        # 
+        # @example Declare the queries you want to make in your controller.
+        # 
+        #   queries :order => "created_at desc" do
+        #     match :full_name
+        #     match :created, :field => :created_at, :strict => true
+        #     match :status, :operators => [:in] # should ultimately have full-on validations
+        #     match :product, :type => :string, :scope => :with_bookmarked_products
+        #   end
+        # 
+        # @example Request with all possible parameters
+        # 
+        #   "/users?full_name=^lance&created=2011-08-01..t&status=active&product=laptop"
+        # 
+        # @param [Hash] params ({}) The query params hash from the controller.
+        #   
+        # @option params [::Symbol] :type Defaults to the database field type.  If you use named scopes
+        #   to reference assiated models, as of now you must specify the type manually.  Haven't looked
+        #   through the Rails 3 scoping code to figure out how use reflection to get join keys.
+        # @option params [::String, ::Symbol] :field If a ::Symbol, the table/collection attribute
+        #   to query, if a ::String, the fully qualified table/collection + attribute string.
+        # @option params [::Array] :operators Optional, refines the allowable query value formats.
+        # @option params [::Boolean] :strict (+false) If true, it will raise an error if the 
+        #   URL parameter is not properly formatted (e.g. "2011.." vs. "2011..t")
+        # @option params [::Symbol] :scope Optional, a class method on the model for the controller,
+        #   used as a named scope.  In here place your +joins(:x).where(:y)+ code.
+        # 
+        # @return [Hash]
+        def render(params)
+          hash                = super
+          
+          hash["sort"]        = default_sort if hash["sort"].blank? && default_sort.present?
+          
+          sort                = hash.delete("sort")
+          limit               = hash.delete("limit") || 20
+          page                = hash.delete("page") || 1
+          
+          offset              = limit.present? && page.present? ? ((page - 1) * limit).to_i : 0
+                    
+          keys                = []
+          values              = []
+          
+          hash.values.collect do |array|
+            keys << array[0]
+            values << array[1..-1]
+          end
+          
+          keys.map! {|i| "(#{i})"} if keys.length > 1
+          keys                = keys.join(" AND ")
+          values.flatten!
+          conditions          = [keys, *values]
+          
+          result              = {}
+          result[:conditions] = conditions if conditions.present?
+          result[:limit]      = limit if limit.present? && limit > 0
+          result[:offset]     = offset if offset.present? && offset > 0
+          result[:order]      = sort if sort.present?
+          
+          result
+        end
+      end
+      
+      class Param < ::Deli::Param
+        attr_accessor :table_key
+        
+        def initialize(key, options = {})
+          super(key, options)
+          configure_clauses(options)
+        end
+        
+        def parse(value)
+          [value]
+        end
+        
+        def configure_clauses(options)
+          case options[:to]
+          when ::String
+            self.table_key     = options[:to]
+          when ::Hash
+            join_key           = options[:as] || options[:to].keys.first
+            join_class         = join_key.to_s.singularize.camelize.constantize
+            attribute          = options[:to].values.first.to_sym
+            self.table_key     = "#{join_class.table_name}.#{attribute}"
+          else
+            if model_class.respond_to?(:table_name)
+              if association   = find_association
+                self.table_key = "#{model_class.table_name}.#{key}_id"
+              else
+                self.table_key = "#{model_class.table_name}.#{key}"
+              end
+            else
+              self.table_key   = key
+            end
+          end
+        end
+        
+        # what this responds to
+        def operators
+          [:equals, :contains, :start, :end]
+        end
+        
+        def find_association
+          key = self.key.to_sym
+          model_class.reflect_on_all_associations.detect do |association|
+            association.name == key
+          end
+        end
+        
+        def render(value)
+          keys, values = [], []
+          
+          parse(value).each do |and_collection|
+            and_keys = []
+            
+            and_collection.each do |item|
+              and_keys  << "#{table_key} #{render_operator(item[:operators][0])} ?"
+              values    << render_value(item[:value], item[:operators][1] || item[:operators][0])
+            end
+            
+            keys << and_keys
+          end
+          
+          keys.map! { |and_keys| and_keys.join(" AND ") }
+          
+          if keys.length > 1
+            [parenthesize!(keys).join(" OR "), *values]
+          else
+            [keys.join(" OR "), *values]
+          end
+        end
+        
+        def render_name(*names)
+          names.flatten.compact.join(".")
+        end
+        
+        def render_value(value, operator = nil)
+          value
+        end
+        
+        def render_operator(value)
+          case value
+          when "=~"
+            match_operator
+          when "!~"
+            "NOT #{match_operator}"
+          else
+            value
+          end
+        end
+        
+        def match_operator
+          postgres? ? "ILIKE" : "LIKE"
+        end
+        
+        def parenthesize!(items)
+          items.map! { |i| "(#{i})" } if items.length > 1
+          items
+        end
+        
+        def postgres?
+          if @postgres.nil?
+            @postgres = defined?(::ActiveRecord::ConnectionAdapters::PostgreSQLAdapter) && ::ActiveRecord::Base.connection.is_a?(::ActiveRecord::ConnectionAdapters::PostgreSQLAdapter)
+          end
+          @postgres
+        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
+        
+        def render_value(value, operator = nil)
+          case operator
+          when "=", "!="
+            value
+          when "^"
+            "%#{value}"
+          when "$"
+            "#{value}%"
+          else
+            "%#{value}%"
+          end
+        end
+      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.join(", ")
+        end
+      end
+      
+      class Offset < Param
+        include Deli::Param::Offset
+      end
+    end
+  end
+end

data/lib/deli/adapters/cassandra.rb

@@ -0,0 +1,52 @@
+module Deli
+  module Adapters
+    # @todo
+    module Cassandra
+      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/mongoid.rb

@@ -0,0 +1,180 @@
+module Deli
+  module Adapters
+    # http://mongoid.org/docs/querying/criteria.html
+    module Mongoid
+      class Model < Deli::Model
+        def model_type(key, options = {})
+          default = options[:type]
+          
+          if default.present?
+            value = default.to_sym
+          else
+            value = model_class.fields[key.to_s]
+            value = value.present? ? value.type.to_s.underscore.to_sym : nil
+          end
+          
+          raise ::ArgumentError.new("Must specify type, such as: `match :#{key}, :type => :string`") if value.blank?
+          
+          case value
+          when :datetime, :time
+            :time
+          when :date
+            :date
+          when :integer, :float, :decimal, :count
+            :number
+          when :sort, :order
+            :order
+          when :string, :text
+            :string
+          else
+            value
+          end
+        end
+      end
+      
+      # Outputs a query hash for Mongoid.
+      # 
+      # @example Declare the queries you want to make in your controller.
+      # 
+      #   queries :order => "created_at desc" do
+      #     match :full_name
+      #     match :created, :field => :created_at
+      #     match :status, :type => :array
+      #     match :product, :type => :string, :field => "products.title"
+      #     match :favorites, :type => :string, :scope => :favorite_products # does the joins / default conditions work
+      #   end
+      # 
+      # @example Query for +"title=Hello+World"+
+      #   
+      #   {:full_name => {"$in" => "John"}}
+      class Query < ::Deli::Query
+        def render(params)
+          params = super
+        end
+      end
+      
+      class Param < ::Deli::Param
+        def render_value(value, operator = nil)
+          value
+        end
+      end
+      
+      class Time < Param
+        include ::Mongoid::Fields::Serializable::Timekeeping
+        include Deli::Param::Time
+        
+        def render(value)
+          result = {}
+          
+          parse(value).flatten.each do |item|
+            case item[:operators][0]
+            when ">="
+              result["$gte"]  = serialize(item[:value]) #time.to_mongo
+            when ">"
+              result["$gt"]   = serialize(item[:value])
+            when "<="
+              result["$lte"]  = serialize(item[:value]) #time.to_mongo
+            when "<"
+              result["$lt"]   = serialize(item[:value])
+            when
+              result = serialize(item[:value])
+            end
+          end
+          
+          result
+        end
+      end
+      
+      class Date < Time
+        include Deli::Param::Date
+      end
+      
+      class String < Param
+        include Deli::Param::String
+        
+        def render(value)
+          result = parse(value).map do |children|
+            regex          = []
+            includes       = []
+            excludes       = []
+            hash           = {}
+            
+            children.each do |item|
+              start_operator = item[:operators][1] == "^" ? "^" : ""
+              end_operator   = item[:operators][1] == "$" ? "$" : ""
+              
+              case item[:operators][0]
+              #when "="
+              #  includes << item[:value]
+              #when "!="
+              #  excludes << item[:value]
+              when "!~", "!="
+                regex << Regexp.new("(?!#{start_operator}#{item[:value]}#{end_operator})", "i")
+              when "=~", "="
+                regex << Regexp.new("#{start_operator}#{item[:value]}#{end_operator}", "i")
+              end
+            end
+            
+            #hash["$in"]    = includes if includes.present?
+            #hash["$nin"]   = excludes if excludes.present?
+            hash["$regex"] = Regexp.union(*regex) if regex.present?
+            hash
+          end
+          
+          result.length > 1 ? {"$or" => result} : result[0]
+        end
+      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|
+            [item[:key].to_sym, item[:operators][0] == "+" ? :asc : :desc]
+          end
+        end
+      end
+      
+      class Offset < Param
+        include Deli::Param::Offset
+      end
+      
+      # # Match all people with first name Emmanuel using Javascript.
+      # { "$where" : "this.first_name == 'Emmanuel'" }
+      # 
+      # # Match all people who live in Berlin, where address is embedded.
+      # { "addresses.city" : "Berlin" }
+      # 
+      # # Example queries using symbol h4s to perform more complex criteria.
+      # { "title" : { "$all" : [ "Sir" ] } }
+      # { "age" : { "$exists" : true } }
+      # { "age" : { "$gt" : 18 } }
+      # { "age" : { "$gte" : 18 } }
+      # { "title" : { "$in" : [ "Sir", "Madam" ] } }
+      # { "age" : { "$lt" : 55 } }
+      # { "age" : { "$lte" : 55 } }
+      # { "title" : { "$ne" : "Mr" } }
+      # { "title" : { "$nin" : [ "Esquire" ] } }
+      # { "aliases" : { "$size" : 2 } }
+      # { "location" : { "$near" : [ 22.50, -21.33 ] } }
+      # { "location" : { "$within" : { "$center" => [ [ 50, -40 ], 1 ] } } }
+      # 3rd number can be a radius: "22.50,-21.33,7"
+      # - if not null, if null
+      class Geo < Param
+        include Deli::Param::Geo
+        
+        def render(value)
+          {"$near" => parse(value).reverse}
+        end
+      end
+    end
+  end
+end