ruby-ext-js 0.0.1 → 0.1.0

data/README.markdown

@@ -4,8 +4,22 @@ Provides ultra-basic classes for translating Ext.js GET params to Postgres (via
 
 Examples:
 
+## MongoDB
+
+    class PullRequests < ExtJs::Mongo
+      def self.allowed_filters
+        ["state"]
+      end
+    end
+    
+    mongo = PullRequests.new( params )
+    mongo.conditions # search conditions
+    mongo.options # pagination and sorting options
+
 ## Postgres
 
+(Implementation and API will change significantly in the future, don't use this yet.)
+
     module ExtJs
       class PullRequests < Postgres
         # Converts Ext.js' wacky params structure into a Postgres db query opts
@@ -33,18 +47,6 @@ Examples:
       end
     end
 
-## MongoDB
-
-Mongo's a lot easier to work with:
-
-    module ExtJs
-      class PullRequests < Mongo
-        def self.allowed_filters
-          ["state"]
-        end
-      end
-    end
-
 # Specs
 
 `ExtJs` was extracted from private code. Existing specs rely on private models, so there are no specs here yet. Specs will require DataMapper.

data/VERSION

@@ -1 +1 @@
-0.0.1
+0.1.0

data/lib/ruby-ext-js.rb

@@ -65,68 +65,81 @@ module ExtJs
   end
   
   class Mongo
-    MAX_PER_PAGE = 1000
-    DEFAULT_PAGE = 1
-    DEFAULT_PER_PAGE = 30
+    DEFAULT_SKIP = 0
+    MAX_LIMIT = 500
+    DEFAULT_LIMIT = 50
     
-    def self.db_opts( params )
+    def initialize( params )
+      @params = params
+    end
+    
+    # @return [Hash] `find()` conditions for `Mongo::Collection.find( conditions, opts )`
+    def conditions
+      self.class.search_param( @params )
+    end
+    
+    # @return [Hash] `find()` options for `Mongo::Collection.find( conditions, opts )`
+    def options
       opts = {}
       
-      opts.merge! page_param( params )
-      opts.merge! per_page_param( params )
-      opts.merge! sort_param( params )
-      opts.merge! search_param( params )
+      opts.merge! self.class.skip_param( @params )
+      opts.merge! self.class.limit_param( @params )
+      opts.merge! self.class.sort_param( @params )
       
       opts
     end
     
-    protected
-    
+    # @return [Array] Array of string values representing keys that are filterable.
     def self.allowed_filters
       []
     end
     
-    def self.page_param( params )
-      return { :page => DEFAULT_PAGE } unless params.key?( "start" ) && params.key?( "limit" )
-      
-      start = params["start"].to_i
-      limit = per_page_param( params )[:per_page]
-      
-      { :page => ( start / limit ) + 1 }
+    protected
+    
+    def self.skip_param( params )
+      return { :skip => DEFAULT_SKIP } unless params.key?( "start" ) && params.key?( "limit" )
+      { :skip => [params["start"].to_i, 0].max }
     end
     
-    def self.per_page_param( params )
-      unless params.key?( "limit" ) && params["limit"].to_i > 0
-        return { :per_page => DEFAULT_PER_PAGE }
-      end
-      { :per_page => [params["limit"].to_i, MAX_PER_PAGE].min }
+    def self.limit_param( params )
+      return { :limit => DEFAULT_LIMIT } unless params.key?( "limit" ) && params["limit"].to_i > 0
+      { :limit => [params["limit"].to_i, MAX_LIMIT].min }
     end
     
     def self.sort_param( params )
       return {} unless params.key?( "sort" )
       
       sort = params["sort"] ? params["sort"].to_sym : :id
-      sort = params["dir"] =~ /desc/i ? sort.desc : sort.asc
+      dir = params["dir"] =~ /desc/i ? :desc : :asc
       
-      { :sort => sort }
+      { :sort => [sort, dir] }
     end
     
     def self.search_param( params )
-      if params["filter"] && params["filter"]["0"]
-        field = params["filter"]["0"]["field"].gsub(/[^\.\w\d_-]/, "").strip
-        values = Array( params["filter"]["0"]["data"]["value"] )
-        
-        if values.size == 1
-          values = values[0]
-        else
-          values = { "$in" => values }
-        end
-        
-        unless field.blank? || !allowed_filters.include?( field ) || values.blank?
-          return { field => values }
+      conds = {}
+      
+      if params["filter"] && params["filter"].size > 0
+        0.upto( params["filter"].size - 1 ).each do |i|
+          i = i.to_s
+          
+          next unless params["filter"][i]
+          
+          field = (params["filter"][i]["field"] || "").gsub(/[^\.\w\d_-]/, "").strip
+          values = Array( params["filter"][i]["data"] ? params["filter"][i]["data"]["value"] : nil )
+          
+          if values.size == 1
+            values = values[0]
+          elsif values.size > 1
+            values = { "$in" => values }
+          end
+          
+          unless field.empty? || !allowed_filters.include?( field ) || values.empty?
+            conds.merge! field => values
+          end
         end
       end
-      {}
+      
+      conds
     end
   end
 end

data/ruby-ext-js.gemspec

@@ -5,7 +5,7 @@
 
 Gem::Specification.new do |s|
   s.name = %q{ruby-ext-js}
-  s.version = "0.0.1"
+  s.version = "0.1.0"
 
   s.required_rubygems_version = Gem::Requirement.new(">= 0") if s.respond_to? :required_rubygems_version=
   s.authors = ["Tyson Tate"]

data/spec/ruby-ext-js_spec.rb

@@ -1,22 +1,116 @@
 require File.expand_path(File.dirname(__FILE__) + '/spec_helper')
 
 describe "ExtJs" do
-  describe "Postgres" do
-    it "sorts on id when you ask it to sort on created_at" do
-      ExtJs::Postgres.pagination_opts({
-        :sort => "created_at",
-        :order => "desc"
-      })[:order].should == [:id.asc]
-    end
-    
-    it "specs the rest of the class or it gets the hose" do
-      pending "The current spec suite is currently rigidly tied to private models. Someday we'll write a generic spec suite here."
-    end
-  end
+  # describe "Postgres" do
+  #   it "sorts on id when you ask it to sort on created_at" do
+  #     ExtJs::Postgres.pagination_opts({
+  #       :sort => "created_at",
+  #       :order => "desc"
+  #     })[:order].should == [:id.asc]
+  #   end
+  #   
+  #   it "specs the rest of the class or it gets the hose" do
+  #     pending "The current spec suite is currently rigidly tied to private models. Someday we'll write a generic spec suite here."
+  #   end
+  # end
   
   describe "Mongo" do
-    it "specs the rest of the class or it gets the hose" do
-      pending "The current spec suite is currently rigidly tied to private models. Someday we'll write a generic spec suite here."
+    describe "conditions" do
+      class TestMongoNoFilters < ExtJs::Mongo; end
+      
+      class TestMongoWithFilters < ExtJs::Mongo
+        def self.allowed_filters
+          ["state", "score"]
+        end
+      end
+      
+      it "handles empty params" do
+        mongo = TestMongoNoFilters.new( {} )
+        mongo.conditions.should == {}
+        
+        mongo = TestMongoWithFilters.new( {} )
+        mongo.conditions.should == {}
+      end
+      
+      it "handles filter params" do
+        params = {
+          "filter" => {
+            "0" => {
+              "field" => "state",
+              "data" => {
+                "value" => "open"
+              }
+            }
+          }
+        }
+        mongo = TestMongoNoFilters.new( params )
+        mongo.conditions.should == {}
+        
+        mongo = TestMongoWithFilters.new( params )
+        mongo.conditions.should == { "state" => "open" }
+      end
+      
+      it "handles complex filter params" do
+        params = {
+          "filter" => {
+            "0" => {
+              "field" => "state",
+              "data" => {
+                "value" => "open"
+              }
+            },
+            "1" => {
+              "field" => "score",
+              "data" => {
+                "value" => ["5", "4"]
+              }
+            },
+            "2" => {
+              "field" => "score"
+            },
+            "3" => {
+              "data" => {
+                "value" => ["5", "4"]
+              }
+            },
+            "4" => {
+              "field" => "score",
+              "data" => {
+                "value" => []
+              }
+            }
+          }
+        }
+        
+        mongo = TestMongoWithFilters.new( params )
+        mongo.conditions.should == { "state" => "open", "score" => { "$in" => ["5", "4"] } }
+      end
+    end
+    
+    describe "opts" do
+      class TestMongo < ExtJs::Mongo; end
+      
+      it "handles empty params with sensible defaults" do
+        TestMongo.new( {} ).options.should == { :limit => 50, :skip => 0 }
+      end
+      
+      it "handles pagination" do
+        TestMongo.new( "start" => "50", "limit" => "10" ).options.should == { :limit => 10, :skip => 50 }
+        TestMongo.new( "start" => "10" ).options.should == { :limit => 50, :skip => 0 }
+        TestMongo.new( "limit" => "10" ).options.should == { :limit => 10, :skip => 0 }
+      end
+      
+      it "handles sorting" do
+        TestMongo.new( "sort" => "foo" ).options.should == { :limit => 50, :skip => 0, :sort => [:foo, :asc] }
+        TestMongo.new( "sort" => "foo", "dir" => "desc" ).options.should == { :limit => 50, :skip => 0, :sort => [:foo, :desc] }
+        TestMongo.new( "sort" => "foo", "dir" => "no idea" ).options.should == { :limit => 50, :skip => 0, :sort => [:foo, :asc] }
+        TestMongo.new( "dir" => "asc" ).options.should == { :limit => 50, :skip => 0 }
+      end
+      
+      it "prevents dumb queries" do
+        TestMongo.new( "start" => "9999999", "limit" => "9999999" ).options.should == { :limit => 500, :skip => 9999999 }
+        TestMongo.new( "start" => "-200", "limit" => "-200" ).options.should == { :limit => 50, :skip => 0 }
+      end
     end
   end
 end

metadata

@@ -1,13 +1,13 @@
 --- !ruby/object:Gem::Specification 
 name: ruby-ext-js
 version: !ruby/object:Gem::Version 
-  hash: 29
+  hash: 27
   prerelease: false
   segments: 
   - 0
-  - 0
   - 1
-  version: 0.0.1
+  - 0
+  version: 0.1.0
 platform: ruby
 authors: 
 - Tyson Tate