muster 0.0.10 → 0.0.11

checksums.yaml

@@ -1,7 +1,15 @@
 ---
-SHA1:
-  metadata.gz: 99866bb235ad97109e1b1a3d2cf79d83c24c8f80
-  data.tar.gz: 21cd93ae1d09692932c1acb43ffd7800bbc9e3a6
+!binary "U0hBMQ==":
+  metadata.gz: !binary |-
+    Yzc3OThjMTE2N2JhMjI1YWNhMDQ3NDVhNGY1MDZjNDlkZDQwNjc4YQ==
+  data.tar.gz: !binary |-
+    YzUyMGVkODhjOTdjOTZiZWJhMzMwMjhmZTU5YmZhNDljMTU3MTkxNQ==
 SHA512:
-  metadata.gz: 0e2332f2f2b14034b6298c8803277565c0820ce1f878c7526567d018cacf53d17183c44203ca622bf4565087d56c45ef3888bcf2aabeb0c607c0dcad28612d7c
-  data.tar.gz: 63d92c6acdb5e31848d4a0d3292eb26b2507da6f8d0123f73a776f81ef4065befee3c0175c14050c792c1a140a008c3468b7c650f41dabc5c0e0adb4ddad33b1
+  metadata.gz: !binary |-
+    ZjQ4YzNjNjYzMjE4ZjlkNzg1NTNlMzFhNjAyMzA1YWJhNTMwODk2NzhmNGVj
+    MDQzYzA2MjU3MzgwZTIzNDVkODQyM2E3OGY0ZmYxMjhiOTZhYjY1OTNlZThh
+    OWU1ZjUzZjczMDQ2YWQzNGNlOGQ5NGFjNWU3ODZhMzJjYmI3YjM=
+  data.tar.gz: !binary |-
+    NjljOGJjNGEzZTFmMDI5ODAzMDMxNTU5MWI2MGJjODE5NzE3MjllZDViM2Q3
+    Y2ZmNGY0Y2Y0YWQwZTQ0MWU4MjgyZGY2N2UyMDc1ZmE5YjZmYzk1NjI2ZTQ5
+    YzAxNmJkODFhMzQyZjNjZTcyNDJhNzhkZmU2NGNjYWVkNDgxOGU=

data/.rubocop.yml

@@ -0,0 +1,14 @@
+Metrics/LineLength:
+  Max: 150
+
+Style/HashSyntax:
+  Enabled: False
+
+Style/IfUnlessModifier:
+  Enabled: False
+
+Style/Lambda:
+  Enabled: False
+
+Style/WordArray:
+  MinSize: 3

data/Changes

@@ -1,3 +1,7 @@
+= 0.0.11
+
+* Massive rubocop cleanup
+
 = 0.0.10
 
 * Added support for 'IS NULL' queries in ActiveRecord Strategy (drydevelopment)

data/Rakefile

@@ -1,11 +1,16 @@
 #!/usr/bin/env rake
-require "bundler/gem_tasks"
+require 'bundler/gem_tasks'
 require 'rspec/core/rake_task'
 require 'yard'
 require 'yard/rake/yardoc_task'
+require 'rubocop/rake_task'
 
 RSpec::Core::RakeTask.new(:spec) do |t|
   t.verbose = false
 end
 
+RuboCop::RakeTask.new
+
 YARD::Rake::YardocTask.new(:yard)
+
+task :default => [:rubocop, :spec, :yard]

data/lib/muster/rack.rb

@@ -2,7 +2,6 @@ require 'active_support/hash_with_indifferent_access'
 require 'rack'
 
 module Muster
-
   # Rack middleware plugin for Muster query string parsing
   #
   # @example
@@ -10,23 +9,22 @@ module Muster
   #   app = Rack::Builder.new do
   #     use Muster::Rack, Muster::Strategies::Hash, :fields => [:name, :choices]
   #   end
-  #   
+  #
   #   # GET /?name=bob&choices=1&choices=2
   #   match '/' do
   #     env['muster.query']  #=> {'name' => 'bob', 'choices' => ['1', '2']}
   #   end
   class Rack
-
     # @attribute [r] app
     # @return [Object] Rack application middleware is running under
     attr_reader :app
-    
+
     # @attribute [r] strategy
     # @return [Muster::Strategies::Rack] Muster Strategy to run
     attr_reader :strategy
-      
+
     # @attribute [r] options
-    # @return [Hash] options to pass to strategy 
+    # @return [Hash] options to pass to strategy
     attr_reader :options
 
     # Key in ENV where processed query string are stored
@@ -44,10 +42,10 @@ module Muster
     # @example
     #
     #   middleware = Muster::Rack.new(app, Muster::Strategies::Hash, :fields => [:name, :choices])
-    #   
+    #
     #   strategy = Muster::Strategies::Hash.new(:fields => [:name, :choices])
     #   middleware = Muster::Rack.new(app, strategy)
-    def initialize( app, strategy, options={} )
+    def initialize(app, strategy, options = {})
       @app = app
       @strategy = strategy
       @options = options
@@ -58,9 +56,9 @@ module Muster
     # @param env [Hash] Rack environment
     #
     # @return [Array]
-    def call( env )
+    def call(env) # rubocop:disable Metrics/AbcSize
       request  = ::Rack::Request.new(env)
-      parser   = self.strategy.kind_of?(Class) ? self.strategy.new(options) : self.strategy
+      parser   = strategy.is_a?(Class) ? strategy.new(options) : strategy
 
       env[QUERY] ||= Muster::Results.new({})
       env[QUERY].merge! parser.parse(request.query_string)
@@ -68,6 +66,5 @@ module Muster
 
       @app.call(env)
     end
-
   end
 end

data/lib/muster/results.rb

@@ -3,7 +3,6 @@ require 'active_support/core_ext/object/blank'
 require 'active_support/hash_with_indifferent_access'
 
 module Muster
-
   # Query parsed results helper class
   #
   # As with most Muster classes, all hashes returned and options specified support with indifferent access.
@@ -32,7 +31,6 @@ module Muster
   #   results.filtered[:select]                        #=> [:id, :name]
   #   results.filtered.select                          #=> [:id, :name]
   class Results < ActiveSupport::HashWithIndifferentAccess
-
     # @attribute [r] data
     # @return [Hash] raw data specified during initialization
     attr_reader :data
@@ -51,7 +49,7 @@ module Muster
     #
     #   data = { :select => [:id, :name, :created_at] }
     #   results = Muster::Results.new(data)
-    def initialize( data, options={} )
+    def initialize(data, options = {}) # rubocop:disable Lint/UnusedMethodArgument
       super(data)
 
       @data = data
@@ -83,8 +81,8 @@ module Muster
     #   results.add_filter(:select, :only => [:id, :name])
     #   results.add_filter(:select, :except => [:id])
     #   results.add_filter(:page, 1)
-    def add_filter( key, *options )
-      self.filters[key] = options
+    def add_filter(key, *options)
+      filters[key] = options
     end
 
     # Returns the raw data with all of the filters applied
@@ -99,15 +97,13 @@ module Muster
     #   results.add_dilter(:page, 1)
     #   results.filtered   #=> { 'select' => [:id, :name], 'page' => 1 }
     def filtered
-      return self if self.filters.empty?
+      return self if filters.empty?
 
-      filtered_results = self.filters.inject( {} ) do |results, (key, options)|
-        results[key] = self.filter( key, *options )
-
-        results
+      filtered_results = filters.each_with_object({}) do |(key, options), results|
+        results[key] = filter(key, *options)
       end
 
-      return self.class.new(filtered_results)
+      self.class.new(filtered_results)
     end
 
     # Filters and returns the raw data values for the specifid key and options
@@ -139,31 +135,32 @@ module Muster
     #   results.filter(:select, :only => [:other, :name])  #=> [:name]
     #   results.filter(:other, :default)                   #=> :default
     #   results.filter(:other)                             #=> KeyError
-    def filter( key, *options )
+    def filter(key, *options)
       if options.present? && options.first.instance_of?(Hash)
         options = options.first.with_indifferent_access
 
-        if options.has_key?(:only)
-          return filter_only_values( key, options[:only] )
-        elsif options.has_key?(:except)
-          return filter_excluded_values( key, options[:except] )
+        if options.key?(:only)
+          return filter_only_values(key, options[:only])
+        elsif options.key?(:except)
+          return filter_excluded_values(key, options[:except])
         end
       else
-        return self.fetch(key, *options)
+        return fetch(key, *options)
       end
     end
 
     private
 
+    # rubocop:disable Lint/NestedMethodDefinition, Metrics/MethodLength
     def method_missing(meth, *args, &block)
-      if self.has_key?(meth)
+      if key?(meth)
         value = self[meth]
 
-        if value.kind_of?(Hash)
+        if value.is_a?(Hash)
           value.instance_eval do
             def method_missing(meth, *args, &block)
-              if self.has_key?(meth)
-                return self.fetch(meth)
+              if key?(meth)
+                return fetch(meth)
               end
 
               super
@@ -173,11 +170,12 @@ module Muster
 
         return value
       end
+      # rubocop:enable
 
       super
     end
 
-    def filter_excluded_values( key, excluded )
+    def filter_excluded_values(key, excluded)
       value = self[key]
       excluded = Array.wrap(excluded)
 
@@ -190,8 +188,8 @@ module Muster
       end
     end
 
-    def filter_only_values( key, allowed )
-      values = Array.wrap( self[key] )
+    def filter_only_values(key, allowed)
+      values = Array.wrap(self[key])
 
       if allowed.instance_of?(Array)
         return values & allowed
@@ -199,6 +197,5 @@ module Muster
         return allowed
       end
     end
-
   end
 end

data/lib/muster/strategies/active_record.rb

@@ -9,7 +9,6 @@ require 'muster/strategies/joins_expression'
 
 module Muster
   module Strategies
-
     # Query string parsing strategy that outputs ActiveRecord Query compatible options
     #
     # @example
@@ -21,7 +20,6 @@ module Muster
     #   #
     #   # Person.select( results[:select] ).where( results[:where] ).order( results[:order] )
     class ActiveRecord < Muster::Strategies::Rack
-
       # Processes a query string and returns a hash of its fields/values
       #
       # @param query_string [String] the query string to parse
@@ -33,22 +31,22 @@ module Muster
       #   results  = strategy.parse('select=id,name&where=status:new&order=name:desc')
       #
       #   # { 'select' => ['id', 'name'], :where => {'status' => 'new}, :order => 'name desc' }
-      def parse( query_string )
-        pagination = self.parse_pagination( query_string )
+      def parse(query_string) # rubocop:disable Metrics/MethodLength
+        pagination = parse_pagination(query_string)
 
         parameters = Muster::Results.new(
-          :select   => self.parse_select(query_string),
-          :order    => self.parse_order(query_string),
+          :select   => parse_select(query_string),
+          :order    => parse_order(query_string),
           :limit    => pagination[:limit],
           :offset   => pagination[:offset],
-          :where    => self.parse_where(query_string),
-          :joins    => self.parse_joins(query_string),
-          :includes => self.parse_includes(query_string)
+          :where    => parse_where(query_string),
+          :joins    => parse_joins(query_string),
+          :includes => parse_includes(query_string)
         )
 
         parameters.regular_writer('pagination', pagination[:pagination].symbolize_keys)
 
-        return parameters
+        parameters
       end
 
       protected
@@ -61,12 +59,12 @@ module Muster
       #
       # @example
       #
-      #   value = self.parse_select('select=id,name')  #=> ['id', 'name']
-      def parse_select( query_string )
+      #   value = parse_select('select=id,name')  #=> ['id', 'name']
+      def parse_select(query_string)
         strategy = Muster::Strategies::Hash.new(:field => :select)
         results  = strategy.parse(query_string)
 
-        return Array.wrap( results[:select] )
+        Array.wrap(results[:select])
       end
 
       # Returns order by clauses for AR queries
@@ -77,12 +75,12 @@ module Muster
       #
       # @example
       #
-      #   value = self.parse_order('order=name:desc')  #=> ['name asc']
-      def parse_order( query_string )
+      #   value = parse_order('order=name:desc')  #=> ['name asc']
+      def parse_order(query_string)
         strategy = Muster::Strategies::SortExpression.new(:field => :order)
         results  = strategy.parse(query_string)
 
-        return Array.wrap( results[:order] )
+        Array.wrap(results[:order])
       end
 
       # Returns pagination information for AR queries
@@ -93,12 +91,10 @@ module Muster
       #
       # @example
       #
-      #   value = self.parse_pagination('page=2&page_size=10')  #=> { 'pagination' => {:page => 2, :per_page => 10}, 'limit' => 10, 'offset' => 10 }
-      def parse_pagination( query_string )
+      #   value = parse_pagination('page=2&page_size=10')  #=> { 'pagination' => {:page => 2, :per_page => 10}, 'limit' => 10, 'offset' => 10 }
+      def parse_pagination(query_string)
         strategy = Muster::Strategies::Pagination.new(:fields => [:pagination, :limit, :offset])
-        results  = strategy.parse(query_string)
-
-        return results
+        strategy.parse(query_string)
       end
 
       # Returns where clauses for AR queries
@@ -111,10 +107,10 @@ module Muster
       #
       # @example
       #
-      #   value = self.parse_where('where=id:1')  #=> {'id' => '1'}
-      #   value = self.parse_where('where=id:null')  #=> {'id' => nil}
-      #   value = self.parse_where('where=id:nil')  #=> {'id' => nil}
-      def parse_where( query_string )
+      #   value = parse_where('where=id:1')  #=> {'id' => '1'}
+      #   value = parse_where('where=id:null')  #=> {'id' => nil}
+      #   value = parse_where('where=id:nil')  #=> {'id' => nil}
+      def parse_where(query_string)
         strategy = Muster::Strategies::FilterExpression.new(:field => :where)
         results  = strategy.parse(query_string)
 
@@ -126,7 +122,7 @@ module Muster
           end
         end
 
-        return results[:where] || {}
+        results[:where] || {}
       end
 
       # Returns joins clauses for AR queries
@@ -137,12 +133,12 @@ module Muster
       #
       # @example
       #
-      #   value = self.parse_joins('joins=authors')  #=> {'joins' => 'authors'}
-      def parse_joins( query_string )
+      #   value = parse_joins('joins=authors')  #=> {'joins' => 'authors'}
+      def parse_joins(query_string)
         strategy = Muster::Strategies::JoinsExpression.new(:field => :joins)
         results  = strategy.parse(query_string)
 
-        return results[:joins] || {}
+        results[:joins] || {}
       end
 
       # Returns includes clauses for AR queries
@@ -153,14 +149,13 @@ module Muster
       #
       # @example
       #
-      #   value = self.parse_joins('includes=authors')  #=> {'includes' => 'authors'}
-      def parse_includes( query_string )
+      #   value = parse_joins('includes=authors')  #=> {'includes' => 'authors'}
+      def parse_includes(query_string)
         strategy = Muster::Strategies::JoinsExpression.new(:field => :includes)
         results  = strategy.parse(query_string)
 
-        return results[:includes] || {}
+        results[:includes] || {}
       end
-
     end
   end
 end

data/lib/muster/strategies/filter_expression.rb

@@ -4,7 +4,6 @@ require 'muster/strategies/hash'
 
 module Muster
   module Strategies
-
     # Query string parsing strategy with additional value handling options for separating filtering expressions
     #
     # @example
@@ -12,11 +11,10 @@ module Muster
     #   strategy = Muster::Strategies::FilterExpression.new
     #   results  = strategy.parse('where=id:1&name:Bob')  #=>  { 'where' => {'id' => '1', 'name' => 'Bob'} }
     class FilterExpression < Muster::Strategies::Hash
-
       # @attribute [r] expression_separator
       # @return [String,RegEx] when specified, each field value will be split into multiple expressions using the specified separator
       attr_reader :expression_separator
-      
+
       # @attribute [r] field_separator
       # @return [String,RegEx] when specified, each expression will be split into multiple field/values using the specified separator
       attr_reader :field_separator
@@ -38,7 +36,7 @@ module Muster
       #
       #   strategy = Muster::Strategies::FilterExpression.new
       #   strategy = Muster::Strategies::FilterExpression.new(:unique_values => false)
-      def initialize( options={} )
+      def initialize(options = {})
         super
 
         @expression_separator = self.options.fetch(:expression_separator, /,\s*/)
@@ -53,93 +51,106 @@ module Muster
       # @return [Muster::Results]
       #
       # @example
-      #   
+      #
       #   results = strategy.parse('where=id:1&name:Bob')  #=>  { 'where' => {'id' => '1', 'name' => 'Bob'} }
-      def parse( query_string )
-        parameters = Muster::Results.new( self.fields_to_parse(query_string) )
+      def parse(query_string)
+        parameters = Muster::Results.new(fields_to_parse(query_string))
 
         parameters.each do |key, value|
-          parameters[key] = self.separate_expressions(value)
-          parameters[key] = self.separate_fields(parameters[key])
+          parameters[key] = separate_expressions(value)
+          parameters[key] = separate_fields(parameters[key])
         end
 
-        return parameters
+        parameters
       end
 
       protected
 
       # Separates values into an Array of expressions using :expression_separator
       #
-      # @param value [String,Array] the original query string field value to separate
+      # @param expression [String,Array] the original query string field value to separate
       #
       # @return [String,Array] String if a single value exists, Array otherwise
       #
       # @example
       #
-      #   value = self.separate_values('where=id:1')       #=> {'where' => 'id:1'}
-      #   value = self.separate_values('where=id:1,id:2')  #=> {'where' => ['id:1', 'id:2']}
-      def separate_expressions( value )
-        values = Array.wrap(value)
+      #   value = separate_values('where=id:1')       #=> {'where' => 'id:1'}
+      #   value = separate_values('where=id:1,id:2')  #=> {'where' => ['id:1', 'id:2']}
+      def separate_expressions(expression)
+        values = Array.wrap(expression)
 
         values = values.map do |value|
-          value.split(self.expression_separator)
+          value.split(expression_separator)
         end.flatten
 
-        return (values.size > 1) ? values : values.first
+        (values.size > 1) ? values : values.first
       end
 
       # Separates expression field values into an Hash of expression filters using :field_separator
       #
-      # @param value [String,Array] the expressions field value to separate
+      # @param values_string [String,Array] the expressions field value to separate
       #
       # @return [Hash]
       #
       # @example
       #
-      #   value = self.separate_fields('id:1')    #=> {'id' => '1'}
-      #   value = self.separate_values('id:1|2')  #=> {'id' => '1|2'}
-      def separate_fields( value )
-        values = Array.wrap(value)
-        
+      #   value = separate_fields('id:1')    #=> {'id' => '1'}
+      #   value = separate_values('id:1|2')  #=> {'id' => '1|2'}
+      def separate_fields(values_string)
+        values = Array.wrap(values_string)
+
         filters = {}
 
         values.each do |value|
-          name, value = value.split(self.field_separator, 2)
-
-          if self.value_separator.present?
-            value = self.separate_values(value)
-          end
+          name, value = value.split(field_separator, 2)
+          value = separate_values(value)
 
-          filters[name] = filters.has_key?(name) ? [filters[name], value].flatten : value
+          filters[name] = filters.key?(name) ? [filters[name], value].flatten : value
 
-          if self.unique_values == true && filters[name].instance_of?(Array)
-            filters[name].uniq!
-          end
+          filters[name] = ensure_unique_values(filters[name])
         end
 
-        return filters
+        filters
       end
 
       # Separates expression filter values into an Array of expression filter values using :value_separator
       #
-      # @param value [String,Array] the expressions filter value to separate
+      # @param values_string [String,Array] the expressions filter value to separate
       #
       # @return [String,Array] String if a single value exists, Array otherwise
       #
       # @example
       #
-      #   value = self.separate_values('1')    #=> '1'
-      #   value = self.separate_values('1|2')  #=> ['1', '2']
-      def separate_values( value )
-        values = Array.wrap(value)
+      #   value = separate_values('1')    #=> '1'
+      #   value = separate_values('1|2')  #=> ['1', '2']
+      def separate_values(values_string)
+        values = Array.wrap(values_string)
 
         values = values.map do |value|
-          value.split(self.value_separator)
+          value.split(value_separator)
         end.flatten
 
-        return (values.size > 1) ? values : value
+        (values.size > 1) ? values : values_string
       end
 
+      # Ensures that if an Array is given, the values are unique if unique_values is set.
+      #
+      # @param values [String,Array] the expressions filter values to ensure are unique
+      #
+      # @return [String,Array] String if a single value exists, Array otherwise
+      #
+      # @example
+      #
+      #   value = ensure_unique_values('1')    #=> '1'
+      #   value = ensure_unique_values(['1', '2'])  #=> ['1', '2']
+      #   value = ensure_unique_values(['1', '1'])  #=> ['1']
+      def ensure_unique_values(values)
+        if unique_values && values.instance_of?(Array)
+          values.uniq
+        else
+          values
+        end
+      end
     end
   end
 end