muster 0.0.10 → 0.0.11

data/lib/muster/strategies/hash.rb

@@ -4,7 +4,6 @@ require 'muster/strategies/rack'
 
 module Muster
   module Strategies
-
     # Query string parsing strategy with additional value handling options for separating values and uniqueness
     #
     # @example
@@ -12,7 +11,6 @@ module Muster
     #   strategy = Muster::Strategies::Hash.new(:unique_values => true, :value_separator => ',')
     #   results  = strategy.parse('name=value&choices=1,2,1')  #=>  { 'name' => 'value', 'choices' => ['1', '2'] }
     class Hash < Muster::Strategies::Rack
-
       # @attribute [r] value_separator
       # @return [String,RegEx] when specified, each field value will be split into multiple values using the specified separator
       attr_reader :value_separator
@@ -34,7 +32,7 @@ module Muster
       #
       #   strategy = Muster::Strategies::Hash.new(:fields => [:name, :state], :value_separator => '|')
       #   strategy = Muster::Strategies::Hash.new(:unique_values => false)
-      def initialize( options={} )
+      def initialize(options = {})
         super
 
         @unique_values   = self.options.fetch(:unique_values, true)
@@ -48,29 +46,29 @@ module Muster
       # @return [Muster::Results]
       #
       # @example
-      #   
+      #
       #   results = strategy.parse('name=value&choices=1,2')  #=>  { 'name' => 'value', 'choices' => ['1', '2'] }
-      def parse( query_string )
+      def parse(query_string)
         parameters = super
 
         parameters.each do |key, value|
-          if self.value_separator.present?
-            parameters[key] = self.separate_values(value)
+          if value_separator.present?
+            parameters[key] = separate_values(value)
           end
 
-          if self.unique_values == true && value.instance_of?(Array)
+          if unique_values == true && value.instance_of?(Array)
             parameters[key].uniq!
           end
         end
 
-        return parameters
+        parameters
       end
 
       protected
 
       # Separates values into an Array of values using :values_separator
       #
-      # @param value [String,Array] the original query string field value to separate
+      # @param values_string [String,Array] the original query string field value to separate
       #
       # @return [String,Array] String if a single value exists, Array otherwise
       #
@@ -78,16 +76,15 @@ module Muster
       #
       #   value = self.separate_values('1')    #=> '1'
       #   value = self.separate_values('1,2')  #=>  ['1', '2']
-      def separate_values( value )
-        values = Array.wrap(value)
+      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
-
     end
   end
 end

data/lib/muster/strategies/joins_expression.rb

@@ -2,7 +2,6 @@ require 'muster/strategies/hash'
 
 module Muster
   module Strategies
-
     # Query string parsing strategy with additional value handling options for separating filtering expressions
     #
     # @example
@@ -10,7 +9,6 @@ module Muster
     #   strategy = Muster::Strategies::JoinsExpression.new
     #   results  = strategy.parse('joins=author.name,activity')  #=>  { 'joins' => [{'author' => 'name'}, 'activity'] }
     class JoinsExpression < 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
@@ -34,12 +32,12 @@ module Muster
       #
       #   strategy = Muster::Strategies::FilterExpression.new
       #   strategy = Muster::Strategies::FilterExpression.new(:unique_values => true)
-      def initialize( options={} )
+      def initialize(options = {})
         super
 
-        @expression_separator = self.options.fetch(:expression_separator, /,\s*/)
-        @field_separator      = self.options.fetch(:field_separator, '.')
-        @unique_values        = self.options.fetch(:unique_values, true)
+        @expression_separator = options.fetch(:expression_separator, /,\s*/)
+        @field_separator      = options.fetch(:field_separator, '.')
+        @unique_values        = options.fetch(:unique_values, true)
       end
 
       # Processes a query string and returns an array of hashes that represent an ActiveRecord joins expression
@@ -49,18 +47,19 @@ module Muster
       # @return [Muster::Results]
       #
       # @example
-      #   
+      #
       #   results = strategy.parse('joins=author.name,activity')  #=>  { 'joins' => [{'author' => 'name'}, 'activity'] }
-      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|
-          value = value.uniq.first if self.unique_values == true && value.instance_of?(Array)
-          parameters[key] = self.make_nested_hash(value)
+          value = value.uniq.first if unique_values == true && value.instance_of?(Array)
+          parameters[key] = make_nested_hash(value)
         end
       end
 
       protected
+
       # Converts the array that represents the value to a nested hash
       #
       # @param value [Array] the value to convert
@@ -70,15 +69,13 @@ module Muster
       # @example
       #
       #   value = self.make_nested_hash('activity,author.country.name')  #=> ['activity', {'author' => {'country' => 'name'}}]
-      def make_nested_hash( value )
+      def make_nested_hash(value)
         expressions = value.split(expression_separator)
-        expressions.map do |e| 
-          fields = e.split(field_separator)
-          fields[0..-2].reverse.reduce(fields.last) { |a, n| { n => a } }
+        expressions.map do |expression|
+          fields = expression.split(field_separator)
+          fields[0..-2].reverse.reduce(fields.last) { |a, e| { e => a } }
         end
       end
-
     end
   end
 end
-

data/lib/muster/strategies/pagination.rb

@@ -4,7 +4,6 @@ require 'muster/strategies/hash'
 
 module Muster
   module Strategies
-
     # Query string parsing strategy with logic to handle pagination options
     #
     # @example
@@ -12,7 +11,6 @@ module Muster
     #   strategy = Muster::Strategies::Pagination.new
     #   results  = strategy.parse('page=3&per_page=10')  #=>  { 'pagination' => {'page' => 3, 'per_page' => 10}, 'limit' => 10, 'offset' => 20 }
     class Pagination < Muster::Strategies::Rack
-    
       # @attribute [r] default_page_size
       # @return [Fixnum] when specified, will override the default page size of 30 when no page_size is parsed
       attr_accessor :default_page_size
@@ -31,13 +29,14 @@ module Muster
       #
       #   strategy = Muster::Strategies::Pagination.new
       #   strategy = Muster::Strategies::Pagination.new(:default_page_size => 10)
-      def initialize( options={} )
+      def initialize(options = {})
         super
 
-        self.default_page_size = self.options[:default_page_size].to_i
-        if self.default_page_size < 1
-          self.default_page_size = 30
-        end
+        self.default_page_size = options[:default_page_size].to_i
+
+        return unless default_page_size < 3
+
+        self.default_page_size = 30
       end
 
       # Processes a query string and returns a hash of its fields/values
@@ -47,25 +46,24 @@ module Muster
       # @return [Muster::Results]
       #
       # @example
-      #   
+      #
       #   results = strategy.parse('page=3&per_page=10')  #=>  { 'pagination' => {'page' => 3, 'per_page' => 10}, 'limit' => 10, 'offset' => 20 }
-      def parse( query_string )
-        parameters = self.parse_query_string(query_string)
-
-        page = self.parse_page(parameters)
-        page_size = self.parse_page_size(parameters)
+      def parse(query_string)
+        parameters = parse_query_string(query_string)
 
+        page = parse_page(parameters)
+        page_size = parse_page_size(parameters)
 
         offset = (page - 1) * page_size
         offset = nil if offset < 1
 
-        parameters = parameters.merge(:pagination => {:page => page, :per_page => page_size}, :limit => page_size, :offset => offset)
-        
-        if self.fields.present?
-          parameters = parameters.slice(*self.fields)
+        parameters = parameters.merge(:pagination => { :page => page, :per_page => page_size }, :limit => page_size, :offset => offset)
+
+        if fields.present?
+          parameters = parameters.slice(*fields)
         end
 
-        return Muster::Results.new(parameters)
+        Muster::Results.new(parameters)
       end
 
       protected
@@ -80,9 +78,9 @@ module Muster
       #
       # @example
       #
-      #   page = self.parse_page(:page => 2)    #=>  2
-      #   page = self.parse_page(:page => nil)  #=>  1
-      def parse_page( parameters )
+      #   page = parse_page(:page => 2)    #=>  2
+      #   page = parse_page(:page => nil)  #=>  1
+      def parse_page(parameters)
         page = parameters.delete(:page).to_i
         page = 1 unless page > 0
         page
@@ -98,15 +96,14 @@ module Muster
       #
       # @example
       #
-      #   page_size = self.parse_page(:page_size => 10)  #=>  10
-      #   page_size = self.parse_page(:per_page  => 10)  #=>  10
-      #   page_size = self.parse_page(:per_page  => nil) #=>  30
-      def parse_page_size( parameters )
+      #   page_size = parse_page(:page_size => 10)  #=>  10
+      #   page_size = parse_page(:per_page  => 10)  #=>  10
+      #   page_size = parse_page(:per_page  => nil) #=>  30
+      def parse_page_size(parameters)
         page_size = (parameters.delete(:page_size) || parameters.delete(:per_page)).to_i
-        page_size = self.default_page_size unless page_size > 0
+        page_size = default_page_size unless page_size > 0
         page_size
       end
-
     end
   end
 end

data/lib/muster/strategies/rack.rb

@@ -6,7 +6,6 @@ require 'muster/results'
 
 module Muster
   module Strategies
-
     # Query string parsing strategy based on Rack::Utils#parse_query
     #
     # @example
@@ -14,7 +13,6 @@ module Muster
     #   strategy = Muster::Strategies::Rack.new
     #   results  = strategy.parse('name=value&choices=1&choices=2')  #=>  { 'name' => 'value', 'choices' => ['1', '2'] }
     class Rack
-
       # @attribute [r] options
       # @return [Hash] options specified during initialization
       attr_reader :options
@@ -33,11 +31,11 @@ module Muster
       #
       #   strategy = Muster::Strategies::Rack.new(:fields => [:name, :state])
       #   strategy = Muster::Strategies::Rack.new(:field  => :name)
-      def initialize( options={} )
+      def initialize(options = {})
         @options = options.with_indifferent_access
 
         @fields  = Array.wrap(@options[:field] || @options[:fields])
-        @fields.map!{ |field| field.to_sym }
+        @fields.map!(&:to_sym)
       end
 
       # Processes a query string and returns a hash of its fields/values
@@ -47,10 +45,10 @@ module Muster
       # @return [Muster::Results]
       #
       # @example
-      #   
+      #
       #   results = strategy.parse('name=value&choices=1&choices=1')  #=>  { 'name' => 'value', 'choices' => ['1', '2'] }
-      def parse( query_string )
-        Muster::Results.new( self.fields_to_parse(query_string) )
+      def parse(query_string)
+        Muster::Results.new(fields_to_parse(query_string))
       end
 
       protected
@@ -64,7 +62,7 @@ module Muster
       # @example
       #
       #   fields = self.parse_query_string('name=value&choices=1&choices=1')  #=>  { 'name' => 'value', 'choices' => ['1', '2'] }
-      def parse_query_string( query_string )
+      def parse_query_string(query_string)
         ::Rack::Utils.parse_query(query_string).with_indifferent_access
       end
 
@@ -75,16 +73,15 @@ module Muster
       # If the :fields option was specified, only those fields will be returned. Otherwise, all fields will be returned.
       #
       # @return [Hash]
-      def fields_to_parse( query_string )
-        fields = self.parse_query_string(query_string)
+      def fields_to_parse(query_string)
+        fields = parse_query_string(query_string)
 
         if self.fields.present?
-          fields = fields.select{ |key, value| self.fields.include?(key.to_sym) }
+          fields = fields.select { |key, _| self.fields.include?(key.to_sym) }
         end
 
-        return fields.with_indifferent_access
+        fields.with_indifferent_access
       end
-
     end
   end
 end

data/lib/muster/strategies/sort_expression.rb

@@ -3,7 +3,6 @@ require 'muster/strategies/hash'
 
 module Muster
   module Strategies
-
     # Query string parsing strategy with additional value handling for sort orders
     #
     # @example
@@ -11,7 +10,6 @@ module Muster
     #   strategy = Muster::Strategies::SortExpression.new
     #   results  = strategy.parse('sort=name:desc')  #=>  { 'sort' => 'name desc' }
     class SortExpression < Muster::Strategies::Hash
-
       # Processes a query string and returns a hash of its fields/values
       #
       # @param query_string [String] the query string to parse
@@ -19,15 +17,15 @@ module Muster
       # @return [Hash]
       #
       # @example
-      #   
+      #
       #   results = strategy.parse('order=name')            #=>  { 'order' => 'name asc' }
       #   results = strategy.parse('order=name:desc')       #=>  { 'order' => 'name desc' }
       #   results = strategy.parse('order=name,date:desc')  #=>  { 'order' => ['name asc', 'date desc'] }
-      def parse( query_string )
-        parameters  = super
+      def parse(query_string)
+        parameters = super
 
         parameters.each do |key, value|
-          parameters[key] = self.parse_sort_expression(value)
+          parameters[key] = parse_sort_expression(value)
         end
       end
 
@@ -35,7 +33,7 @@ module Muster
 
       # Separates the values into their field and direction
       #
-      # @param value [String] the value being parsed
+      # @param expression [String] the value being parsed
       #
       # @return [String,Arrary] String if a single value, Array otherwise
       #
@@ -43,17 +41,17 @@ module Muster
       #
       #    value = self.parse_sort_expression('name:asc')  #=>  'name asc'
       #    value = self.parse_sort_expression(['name:asc', 'date'])  #=>  ['name asc', 'date asc']
-      def parse_sort_expression( value )
-        values = Array.wrap(value)
+      def parse_sort_expression(expression)
+        values = Array.wrap(expression)
 
         values = values.map do |value|
           name, direction = value.split(':', 2)
-          direction = self.parse_direction(direction)
+          direction = parse_direction(direction)
 
           "#{name} #{direction}"
         end.flatten
 
-        return (values.size > 1) ? values : values.first
+        (values.size > 1) ? values : values.first
       end
 
       # Parse and normalize the sot expression direction
@@ -66,10 +64,9 @@ module Muster
       #
       #   direction = self.parse_direction('ascending')   #=> 'asc'
       #   direction = self.parse_direction('descending')  #=> 'desc'
-      def parse_direction( direction )
+      def parse_direction(direction)
         direction.to_s.match(/^desc/i) ? 'desc' : 'asc'
       end
-
     end
   end
 end

data/lib/muster/version.rb

@@ -1,4 +1,5 @@
+# Muster
 module Muster
   # Current version of Muster
-  VERSION = "0.0.10"
+  VERSION = '0.0.11'
 end

data/muster.gemspec

@@ -1,26 +1,28 @@
 # -*- encoding: utf-8 -*-
 require File.expand_path('../lib/muster/version', __FILE__)
 
+# rubocop:disable Metrics/LineLength
 Gem::Specification.new do |gem|
-  gem.authors       = ["Christopher H. Laco"]
-  gem.email         = ["claco@chrislaco.com"]
-  gem.description   = %q{Muster is a gem that turns query strings of varying formats into data structures suitable for easier consumption in AR/DataMapper scopes and queries.}
-  gem.summary       = %q{Muster various query string formats into a more reusable data structure.}
-  gem.homepage      = "https://github.com/claco/muster"
+  gem.authors       = ['Christopher H. Laco']
+  gem.email         = ['claco@chrislaco.com']
+  gem.description   = 'Muster is a gem that turns query strings of varying formats into data structures suitable for easier consumption in AR/DataMapper scopes and queries.'
+  gem.summary       = 'Muster various query string formats into a more reusable data structure.'
+  gem.homepage      = 'https://github.com/claco/muster'
 
-  gem.files         = `git ls-files`.split($\)
-  gem.executables   = gem.files.grep(%r{^bin/}).map{ |f| File.basename(f) }
+  gem.files         = `git ls-files`.split($ORS)
+  gem.executables   = gem.files.grep(%r{^bin/}).map { |f| File.basename(f) }
   gem.test_files    = gem.files.grep(%r{^(test|spec|features)/})
-  gem.name          = "muster"
-  gem.require_paths = ["lib"]
+  gem.name          = 'muster'
+  gem.require_paths = ['lib']
   gem.version       = Muster::VERSION
 
   gem.add_dependency 'activesupport', '>= 3.0'
-  gem.add_dependency 'rack',          '~> 1.4'
+  gem.add_dependency 'rack', '~> 1.4'
 
   gem.add_development_dependency 'pry'
-  gem.add_development_dependency 'rspec',     '~> 2.11.0'
+  gem.add_development_dependency 'rspec', '~> 2.11.0'
   gem.add_development_dependency 'redcarpet', '~> 2.1'
+  gem.add_development_dependency 'rubocop', '~> 0.33.0'
   gem.add_development_dependency 'simplecov'
-  gem.add_development_dependency 'yard',      '~> 0.8.2'
+  gem.add_development_dependency 'yard', '~> 0.8.2'
 end