queryfy 0.2.2 → 0.3.0

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA1:
-  metadata.gz: b8245801e6c8695ed9ac50a84d9aeb6f7179a946
-  data.tar.gz: de1e2a5ff538749f4d6b27e632015048ccd5a7db
+  metadata.gz: 2fc1d0e6915ee945c426a61ee049a041382a974c
+  data.tar.gz: 4d9f896e6af4697c878667732959ae6075ec25aa
 SHA512:
-  metadata.gz: 0ad2bda81f8b531a0ebcc7163becbed28c5817561b96236d5e7e543b518e000679d73f32d1c47b2abaa7b46c83f404838d9339475caa6dd344fad9f187d1188e
-  data.tar.gz: e39d222be50aae99827b6b0020776099ccea9f9dc9bd069f681df2a2eec06f90dc28fe4214fa96f18a45e9055c730350532183ebfc202314f27d067d4e9592fd
+  metadata.gz: fc91b3768dc4fae24b95854a1c5f0183df525a593d615a2b74d37cd2f5fdbeaa84174d2f0639adb3d8cb09676ce1b9503bbc010bab3590277bf550d7253ff3f3
+  data.tar.gz: 4a0de0c99bee227edda239c6047b072e18956c9835496c665e3e7f268cf37880e8e13240ab853c539cc70f65fd132e07abf572bb812db2d1537f1a580dfc7465

data/README.md

@@ -54,9 +54,9 @@ SomeModel.queryfy(queryparams)
 The gem adds makes a `queryfy` method available to ActiveRecord::Base when included.
 The queryfy method takes a hash in the following format:
 ```
-{'filter': 'name=="name", 'offset': 50, 'limit': 10}
+{'filter': 'name=="name", 'order': 'id-', 'offset': 50, 'limit': 10}
 ```
-All three are optional, and any extra values are ignored.
+All four are optional, and any extra values are ignored.
 
 Defaults:
 ```
@@ -71,6 +71,28 @@ After calling `queryfy` you will get back the following:
 {data: [your data], count: total results, offset: the offset used, limit: the limit used}
 ```
 
+### Pagination
+
+Queryfy supports pagination by passing offset and limit queryparams. offset
+skips the first x records, while limit only selects y records
+
+```
+# Returns the second page of results since we skip the first 25 and want 25 records a page
+offset=25&limit=25
+```
+
+### Ordering
+
+Ordering is also supported by queryfy. To add a certain order you use the order
+queryparam. To order on multiple fields you should pass the fields comma
+seperated. By default fields are ordered ascending, to order them descending
+you postfix the field with a minus, i.e `id-,name+,email-`
+
+```
+# Would order the results by name, and within that by the records that were created the farthest back.
+name-,created_at+
+```
+
 ### Exceptions
 
 All exceptions queryfy can raise inherit from `QueryfyError`

data/lib/queryfy/filter_lexer/formatter.rb

@@ -8,17 +8,8 @@ module FilterLexer
 			operator_method = elements[1].to_arel
 			val = elements[2].text_value
 
-			# Check if the field we want to filter on exists
-			field_index = arel_table.engine.column_names.index(field)
+			field = Queryfy.get_arel_field(arel_table, field)
 
-			# Field does not exist, fail
-			if field_index.nil?
-				raise NoSuchFieldError.new("Unknown field #{ field }", field)
-			else
-				# Get the arel field name from our input, just to make sure
-				# there is nothing weird is in the input
-				field = arel_table.engine.column_names[field_index]
-			end
 			ast_node = arel_table[field.to_sym]
 
 			# Build an arel node from the resolved operator, value and field

data/lib/queryfy/version.rb

@@ -1,3 +1,3 @@
 module Queryfy
-  VERSION = "0.2.2"
+  VERSION = "0.3.0"
 end

data/lib/queryfy.rb

@@ -11,14 +11,15 @@ module Queryfy
 	define_setting :default_limit, 50
 
 	# Actually builds the query
-	def self.build_query(klass, querystring, limit = 50, offset = 0)
+	def self.build_query(klass, querystring, orderstring, limit = 50, offset = 0)
 		limit = [max_limit, limit.to_i].min
 		offset = offset.to_i
 		# Handle empty and nil queries
 		if (querystring.nil? || querystring == '')
+				data = self.add_order(klass.arel_table, klass.limit(limit).offset(offset), orderstring)
 			return {
-				data: klass.limit(limit).offset(offset), 
-				count: klass.all.count, 
+				data: data,
+				count: klass.all.count,
 				limit: limit.to_i, offset: offset.to_i
 			}
 		end
@@ -37,6 +38,7 @@ module Queryfy
 		arel_tree = self.cleaned_to_arel(klass.arel_table, cleaned_tree)
 		# If we want to actually query, add the conditions to query
 		query = query.where(arel_tree) unless arel_tree.nil?
+		query = self.add_order(klass.arel_table, query, orderstring)
 
 		total = 0
 		if arel_tree.nil?
@@ -103,14 +105,58 @@ module Queryfy
 	def self.from_queryparams(klass, queryparams)
 		filter = ''
 		offset = 0
+		order = ''
 		limit = Queryfy::default_limit
 		if (queryparams.is_a?(Hash))
 			filter = queryparams['filter'] unless queryparams['filter'].nil?
 			offset = queryparams['offset'] unless queryparams['offset'].nil?
 			limit = queryparams['limit'] unless queryparams['limit'].nil?
+			order = queryparams['order'] unless queryparams['order'].nil?
 		elsif(queryparams.is_a?(String))
 			filter = queryparams
 		end
-		return Queryfy.build_query(klass, filter, limit, offset)
+		return Queryfy.build_query(klass, filter, order, limit, offset)
+	end
+
+	def self.add_order(arel_table, arel_query, orderstring)
+		# adds order conditions to the passed query
+
+		# If we don't want to order, return the oridinal query
+		return arel_query if orderstring.nil? || orderstring == ''
+
+		# Split the fields we want to order on
+		split = orderstring.split(',')
+		
+		# Determine how we want to order each field (asc or desc)
+		split.each do |s|
+				order_char = s[-1, 1]
+				s.chop! if order_char == '+' || order_char == '-'
+				next unless order_char == '+' || order_char == '-'
+				field = Queryfy.get_arel_field(arel_table, s)
+				order = :asc
+				if order_char == '-'
+						order = :desc
+				end
+
+				# Add the order as a string, since hash is unsupported with query
+				arel_query = arel_query.order("#{field} #{order}")
+		end
+		return arel_query
+	end
+
+	def self.get_arel_field(arel_table, field)
+		# Check if the field we want to filter on exists
+		field_index = arel_table.engine.column_names.index(field)
+		arel_field = nil
+
+		# Field does not exist, fail
+		if field_index.nil?
+			raise NoSuchFieldError.new("Unknown field #{ field }", field)
+		else
+			# Get the arel field name from our input, just to make sure
+			# there is nothing weird is in the input
+			arel_field = arel_table.engine.column_names[field_index]
+		end
+		return arel_field
 	end
 end

metadata

@@ -1,14 +1,14 @@
 --- !ruby/object:Gem::Specification
 name: queryfy
 version: !ruby/object:Gem::Version
-  version: 0.2.2
+  version: 0.3.0
 platform: ruby
 authors:
 - Bonemind
 autorequire: 
 bindir: exe
 cert_chain: []
-date: 2015-12-28 00:00:00.000000000 Z
+date: 2016-02-28 00:00:00.000000000 Z
 dependencies:
 - !ruby/object:Gem::Dependency
   name: filter_lexer