gauze 0.0.3 → 0.0.4

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA1:
-  metadata.gz: e2e3f518dd71ce727fe94b67cd76d74c949c5e8a
-  data.tar.gz: 9e308e8bea3e14e4c750c01eaea2a9a5a28cedbe
+  metadata.gz: 527dae15f5adffa62ef1b3325a193b704a8894c2
+  data.tar.gz: 96b137d7878a66b32b8a52abddfd9ffb4bc178ab
 SHA512:
-  metadata.gz: ab9ea811399e221c4cbd38e5cbceed77d6cee6e6a5bf4756289441a1d1a213d80c0b144512fb60199e4a8636f5517b119cabe5a89ee08b0f90283f1c8f419abd
-  data.tar.gz: 93d44f6f4c34e350f995b76b9f89638ef53c8b920aa222426e96ca5adc13b0256dfd4770d65c3efcb0a7a6a18424467d83ebe9465fc722e076f66a45f708fe08
+  metadata.gz: 78c419437f8fa15ca7f28fbc26c690b26fac850841d26f8ee19a49f1f5c31cc1d4ad400e53b044294f871210dd7704061075a30821ea0f52c2200ee0c375e51b
+  data.tar.gz: 4257f394a2244ef6a9ef140aa9f7a275b018572fedbb055b91ed512b3e11554849d6ab6809edee3b050908aadf17bb2903813f06af8ed8cc9b8d1f926a3840e6

data/README.md

@@ -28,7 +28,7 @@ Or install it yourself as:
 ## Usage
 
 Create a class that your controller can find.
-Define filters using the Gauze DSL.
+Define filters & sorters using the Gauze DSL.
 
 The filter method accepts 4 arguments.
 
@@ -56,6 +56,17 @@ Then in your controller:
   end
 ```
 
+The sorter method accepts 2 arguments.
+
+`sorter :param_key, :column_name`
+
+
+```ruby
+  class EventFilters < Gauze::Base
+    sorter :event_name, :name
+  end
+```
+
 Because **Gauze** uses AREL to construct queries, you can use `.build` just like any other scope. You can pass relational objects & chain more relations as you need.
 ```ruby
 def index
@@ -64,6 +75,44 @@ def index
 end
 ```
 
+### Using Joins
+
+It is possible to filter & sort across joined tables.
+
+To start, you need to let **Gauze** know that you are going to make use of a join.
+Simply add the `needs` method to your gauze classes.
+
+```ruby
+  class CustomerFilters < Gauze::Base
+    needs :person
+  end
+```
+
+This can also be a hash or array, a-la activerecord:
+```ruby
+  needs person: :location, orders: {transaction: :charge}
+```
+
+```ruby
+  needs :person, :location
+```
+
+After you have all of your gauze needs met, you simply use a hash style syntax to filter across the join.
+```ruby
+  class CustomerFilters < Gauze::Base
+    needs :person
+    filter :name, {person: :last_name}, :matches, -> val {"%#{val}%"}
+    sorter :last_name, {person: :last_name}
+  end
+```
+
+
+## TO-DO
+- [ ] Write tests.
+- [ ] Add controller hooks.
+ 
+
+
 ## Contributing
 
 1. Fork it ( https://github.com/TheKidCoder/gauze/fork )

data/lib/gauze/base.rb

@@ -17,8 +17,13 @@ module Gauze
       @filters.push param_key: param_key, column: column_name, method: arel_method, preprocessor: preprocessor
     end
 
+    def self.sorter(param_key, column)
+      @sorters ||= []
+      @sorters.push param_key: param_key, column: column
+    end
+
     def self.build(resource, params = {})
-      new(resource, params).build_nodes
+      new(resource, params).build
     end
 
     def initialize(resource, params = {})
@@ -26,13 +31,17 @@ module Gauze
       @params = params.symbolize_keys
     end
 
-    def build_nodes
+    def build
       wheres = applied_filters.map {|obj| build_arel_filter(obj)}
       _query = @resource
       wheres.each {|node| _query = _query.where(node)}
 
-      if self.class.instance_variable_get(:@join_stanza).present?
-        _query = _query.joins(self.class.instance_variable_get(:@join_stanza))
+      if get_klass_var(:@join_stanza).present?
+        _query = _query.joins(get_klass_var(:@join_stanza))
+      end
+
+      if get_klass_var(:@sorters).present?
+        _query = build_order_query(_query)
       end
 
       return _query
@@ -42,18 +51,41 @@ module Gauze
       filter_val = @params[filter_hash[:param_key]]
       filter_val = filter_hash[:preprocessor].call(filter_val) if filter_hash[:preprocessor]
 
-      @resource.arel_table[filter_hash[:column]].method(filter_hash[:method]).call(filter_val)
+      if filter_hash[:column].is_a?(Hash)
+        arel_column_from_hash(filter_hash[:column]).method(filter_hash[:method]).call(filter_val)
+      else
+        @resource.arel_table[filter_hash[:column]].method(filter_hash[:method]).call(filter_val)
+      end
+    end
+
+    def build_order_query(query)
+      return query unless @params[:sort].present?
+      sort_column = get_klass_var(:@sorters).find {|h| h[:param_key].to_s == @params[:sort].underscore}
+      return query unless sort_column.present?
+
+      if sort_column[:column].is_a?(Hash)
+        query.order(arel_column_from_hash(sort_column[:column]))
+      else
+        query.order(sort_column[:column])
+      end
     end
 
     private
-    def arel_column(hash_param)
+    def get_klass_var(var)
+      self.class.instance_variable_get(var)
+    end
+
+    def arel_column_from_hash(hash_param)
+      raise ArgumentError, "Hash can only have one key." if hash_param.length > 1
+      _resource = hash_param.keys.first.to_s.classify.constantize
+      _resource.arel_table[hash_param.values.first]
     end
 
     def applied_filters
       _filters = []
       @params.each do |k,v|
         next unless v.present?
-        next unless filter = self.class.instance_variable_get(:@filters).find {|obj| obj[:param_key] == k}
+        next unless filter = get_klass_var(:@filters).find {|obj| obj[:param_key] == k}
         _filters.push filter
       end
 

data/lib/gauze/version.rb

@@ -1,3 +1,3 @@
 module Gauze
-  VERSION = "0.0.3"
+  VERSION = "0.0.4"
 end

metadata

@@ -1,14 +1,14 @@
 --- !ruby/object:Gem::Specification
 name: gauze
 version: !ruby/object:Gem::Version
-  version: 0.0.3
+  version: 0.0.4
 platform: ruby
 authors:
 - Chris Ostrowski
 autorequire: 
 bindir: bin
 cert_chain: []
-date: 2015-01-14 00:00:00.000000000 Z
+date: 2015-02-07 00:00:00.000000000 Z
 dependencies:
 - !ruby/object:Gem::Dependency
   name: rails