muster 0.0.10 → 0.0.11

data/spec/muster/rack_spec.rb

@@ -1,7 +1,7 @@
 require 'spec_helper'
 
 describe Muster::Rack do
-  let(:application) { lambda{|env| [200, {'Content-Type' => 'text/plain'}, '']} }
+  let(:application) { lambda { |_| [200, { 'Content-Type' => 'text/plain' }, ''] } }
   let(:environment) { Rack::MockRequest.env_for('/?name=value&order=name') }
   let(:options)     { {} }
   let(:middleware)  { Muster::Rack.new(application, Muster::Strategies::Hash, options) }
@@ -9,7 +9,7 @@ describe Muster::Rack do
   it 'parse query string with strategy' do
     middleware.call(environment)
 
-    environment[Muster::Rack::QUERY].should == {'name' => 'value', 'order' => 'name'}
+    environment[Muster::Rack::QUERY].should eq('name' => 'value', 'order' => 'name')
     environment[Muster::Rack::QUERY].should be_an_instance_of(Muster::Results)
   end
 
@@ -18,7 +18,7 @@ describe Muster::Rack do
 
     middleware.call(environment)
 
-    environment[Muster::Rack::QUERY].should == {'name' => 'value'}
+    environment[Muster::Rack::QUERY].should eq('name' => 'value')
     environment[Muster::Rack::QUERY].should be_an_instance_of(Muster::Results)
   end
 
@@ -26,27 +26,27 @@ describe Muster::Rack do
     strategy = Muster::Strategies::Hash.new(:field => :name)
     Muster::Rack.new(application, strategy).call(environment)
 
-    environment[Muster::Rack::QUERY].should == {'name' => 'value'}
+    environment[Muster::Rack::QUERY].should eq('name' => 'value')
     environment[Muster::Rack::QUERY].should be_an_instance_of(Muster::Results)
   end
 
   it 'merges multiple strategies into one result' do
     Muster::Rack.new(application, Muster::Strategies::Hash, :field => :name).call(environment)
-    environment[Muster::Rack::QUERY].should == {'name' => 'value'}
+    environment[Muster::Rack::QUERY].should eq('name' => 'value')
     environment[Muster::Rack::QUERY].should be_an_instance_of(Muster::Results)
 
     Muster::Rack.new(application, Muster::Strategies::Hash, :field => :order).call(environment)
-    environment[Muster::Rack::QUERY].should == {'name' => 'value', 'order' => 'name'}
+    environment[Muster::Rack::QUERY].should eq('name' => 'value', 'order' => 'name')
     environment[Muster::Rack::QUERY].should be_an_instance_of(Muster::Results)
   end
 
   it 'supports indifferent access' do
     Muster::Rack.new(application, Muster::Strategies::Hash, :field => :name).call(environment)
-    environment[Muster::Rack::QUERY].should == {'name' => 'value'}
+    environment[Muster::Rack::QUERY].should eq('name' => 'value')
     environment[Muster::Rack::QUERY].should be_an_instance_of(Muster::Results)
 
     Muster::Rack.new(application, Muster::Strategies::Hash, :field => :order).call(environment)
-    environment[Muster::Rack::QUERY].should == {'name' => 'value', 'order' => 'name'}
+    environment[Muster::Rack::QUERY].should eq('name' => 'value', 'order' => 'name')
     environment[Muster::Rack::QUERY].should be_an_instance_of(Muster::Results)
 
     environment[Muster::Rack::QUERY]['name'].should eq 'value'

data/spec/muster/results_spec.rb

@@ -1,7 +1,7 @@
 require 'spec_helper'
 
 describe Muster::Results do
-  let(:data)        { {:name => [1, 2, 3]} }
+  let(:data)        { { :name => [1, 2, 3] } }
   let(:options)     { {} }
   subject(:results) { Muster::Results.new(data, options) }
 
@@ -10,7 +10,7 @@ describe Muster::Results do
   describe '#filter' do
     context 'without options hash' do
       it 'returns the same as fetch' do
-        results.filter(:name).should eq [1,2,3]
+        results.filter(:name).should eq [1, 2, 3]
       end
 
       it 'supports a default value' do
@@ -18,21 +18,21 @@ describe Muster::Results do
       end
 
       it 'throws exception without default' do
-        expect{ results.filter(:bogons) }.to raise_error(KeyError)
+        expect { results.filter(:bogons) }.to raise_error(KeyError)
       end
     end
 
     context 'with options hash' do
       context 'with :except option' do
         context 'with data value as Array' do
-          before { data[:name] = [1,2,3] }
+          before { data[:name] = [1, 2, 3] }
 
           it 'returns values not listed in :except as array' do
-            results.filter(:name, :except => [2]).should eq [1,3]
+            results.filter(:name, :except => [2]).should eq [1, 3]
           end
 
           it 'returns values not listed in :except as scalar' do
-            results.filter(:name, :except => 2).should eq [1,3]
+            results.filter(:name, :except => 2).should eq [1, 3]
           end
         end
 
@@ -55,7 +55,7 @@ describe Muster::Results do
         end
 
         it 'returns values listed in :only as array' do
-          results.filter(:name, :only => [1,3]).should eq [1,3]
+          results.filter(:name, :only => [1, 3]).should eq [1, 3]
         end
       end
     end
@@ -80,7 +80,7 @@ describe Muster::Results do
 
         filtered_results = results.filtered
         filtered_results.should be_an_instance_of(Muster::Results)
-        filtered_results.should == {"name"=>[2, 3], "page"=>1, "order"=>[], "where"=>nil}
+        filtered_results.should eq('name' => [2, 3], 'page' => 1, 'order' => [], 'where' => nil)
       end
     end
   end
@@ -93,7 +93,7 @@ describe Muster::Results do
       end
 
       it 'returns a Hash with method missing dot notation' do
-        data[:pagination] = {:page => 1, :per_page => 10}
+        data[:pagination] = { :page => 1, :per_page => 10 }
 
         results.pagination.should be_an_kind_of(Hash)
         results.pagination.page.should eq 1
@@ -105,7 +105,7 @@ describe Muster::Results do
 
     context 'without matching key' do
       it 'returns NoMethodError' do
-        expect{ results.foop }.to raise_error(NoMethodError)
+        expect { results.foop }.to raise_error(NoMethodError)
       end
     end
 

data/spec/muster/strategies/active_record_spec.rb

@@ -6,7 +6,17 @@ describe Muster::Strategies::ActiveRecord do
 
   describe '#parse' do
     it 'returns a Muster::Results instance' do
-      subject.parse('').should == {"select"=>[], "order"=>[], "limit"=>30, "offset"=>nil, "where"=>{}, "joins"=>{}, "includes"=>{}, "pagination"=>{:page=>1, :per_page=>30}}
+      result = {
+        'select' => [],
+        'order' => [],
+        'limit' => 30,
+        'offset' => nil,
+        'where' => {},
+        'joins' => {},
+        'includes' => {},
+        'pagination' => { :page => 1, :per_page => 30 }
+      }
+      subject.parse('').should eq(result)
       subject.parse('').should be_an_instance_of(Muster::Results)
     end
 
@@ -21,7 +31,6 @@ describe Muster::Strategies::ActiveRecord do
 
       it 'supports comma separated values' do
         subject.parse('select=id&select=guid,name')[:select].should == ['id', 'guid', 'name']
-
       end
     end
 
@@ -59,11 +68,11 @@ describe Muster::Strategies::ActiveRecord do
       end
 
       it 'returns a nested hash of separated values' do
-        subject.parse('joins=author.country.name')[:joins].should eq [{'author' => { 'country' => 'name'}}]
+        subject.parse('joins=author.country.name')[:joins].should eq [{ 'author' => { 'country' => 'name' } }]
       end
 
       it 'returns an array of nested hashes' do
-        subject.parse('joins=author.country.name,activity.rule')[:joins].should eq [{'author' => { 'country' => 'name'}}, {'activity' => 'rule'}]
+        subject.parse('joins=author.country.name,activity.rule')[:joins].should eq [{ 'author' => { 'country' => 'name' } }, { 'activity' => 'rule' }]
       end
     end
 
@@ -77,17 +86,18 @@ describe Muster::Strategies::ActiveRecord do
       end
 
       it 'returns a nested hash of separated values' do
-        subject.parse('includes=author.country.name')[:includes].should eq [{'author' => { 'country' => 'name'}}]
+        subject.parse('includes=author.country.name')[:includes].should eq [{ 'author' => { 'country' => 'name' } }]
       end
 
       it 'returns an array of nested hashes' do
-        subject.parse('includes=author.country.name,activity.rule')[:includes].should eq [{'author' => { 'country' => 'name'}}, {'activity' => 'rule'}]
+        results = [{ 'author' => { 'country' => 'name' } }, { 'activity' => 'rule' }]
+        subject.parse('includes=author.country.name,activity.rule')[:includes].should eq results
       end
     end
 
     context 'pagination' do
       it 'returns default will paginate compatible pagination' do
-        subject.parse('')[:pagination].should == {:page => 1, :per_page => 30}
+        subject.parse('')[:pagination].should eq(:page => 1, :per_page => 30)
       end
 
       it 'returns default limit options' do
@@ -100,35 +110,35 @@ describe Muster::Strategies::ActiveRecord do
 
       it 'accepts per_page option' do
         results = subject.parse('per_page=10')
-        results[:pagination].should == {:page => 1, :per_page => 10}
+        results[:pagination].should eq(:page => 1, :per_page => 10)
         results[:limit].should eq 10
         results[:offset].should eq nil
       end
 
       it 'ensures per_page is positive integer' do
         results = subject.parse('per_page=-10')
-        results[:pagination].should == {:page => 1, :per_page => 30}
+        results[:pagination].should eq(:page => 1, :per_page => 30)
         results[:limit].should eq 30
         results[:offset].should eq nil
       end
 
       it 'accepts page_size option' do
         results = subject.parse('page_size=10')
-        results[:pagination].should == {:page => 1, :per_page => 10}
+        results[:pagination].should eq(:page => 1, :per_page => 10)
         results[:limit].should eq 10
         results[:offset].should eq nil
       end
 
       it 'accepts page option' do
         results = subject.parse('page=2')
-        results[:pagination].should == {:page => 2, :per_page => 30}
+        results[:pagination].should eq(:page => 2, :per_page => 30)
         results[:limit].should eq 30
         results[:offset].should eq 30
       end
 
       it 'ensures page is positive integer' do
         results = subject.parse('page=a')
-        results[:pagination].should == {:page => 1, :per_page => 30}
+        results[:pagination].should eq(:page => 1, :per_page => 30)
         results[:limit].should eq 30
         results[:offset].should eq nil
       end
@@ -136,55 +146,54 @@ describe Muster::Strategies::ActiveRecord do
 
     context 'wheres' do
       it 'returns a single value as a string in a hash' do
-        subject.parse('where=id:1')[:where].should == {'id' => '1'}
+        subject.parse('where=id:1')[:where].should eq('id' => '1')
       end
 
       it 'returns a single value as nil in a hash' do
-        subject.parse('where=id:null')[:where].should == {'id' => nil}
-        subject.parse('where=id:NULL')[:where].should == {'id' => nil}
-        subject.parse('where=id:Null')[:where].should == {'id' => nil}
-        subject.parse('where=id:nil')[:where].should == {'id' => nil}
-        subject.parse('where=id:NIL')[:where].should == {'id' => nil}
-        subject.parse('where=id:Nil')[:where].should == {'id' => nil}
+        subject.parse('where=id:null')[:where].should eq('id' => nil)
+        subject.parse('where=id:NULL')[:where].should eq('id' => nil)
+        subject.parse('where=id:Null')[:where].should eq('id' => nil)
+        subject.parse('where=id:nil')[:where].should eq('id' => nil)
+        subject.parse('where=id:NIL')[:where].should eq('id' => nil)
+        subject.parse('where=id:Nil')[:where].should eq('id' => nil)
       end
 
       it 'returns values as an Array in a hash' do
-        subject.parse('where=id:1&where=id:2')[:where].should == {'id' => ['1', '2']}
+        subject.parse('where=id:1&where=id:2')[:where].should eq('id' => ['1', '2'])
       end
 
       it 'supports pipe for multiple values' do
-        subject.parse('where=id:1|2')[:where].should == {'id' => ['1', '2']}
+        subject.parse('where=id:1|2')[:where].should eq('id' => ['1', '2'])
       end
     end
 
     context 'the full monty' do
       it 'returns a hash of all options' do
-        query_string = 'select=id,guid,name&where=name:foop&order=id:desc&order=name&page=3&page_size=5&includes=author.country,comments&joins=activity'
+        query_string = 'select=id,guid,name&where=name:foop&order=id:desc&order=name&page=3&page_size=5&includes=author.country,comments&joins=activity' # rubocop:disable Metrics/LineLength
         results = subject.parse(query_string)
 
-        results[:select].should == ['id', 'guid', 'name']
-        results[:where].should  == {'name' => 'foop'}
-        results[:order].should  == ['id desc', 'name asc']
-        results[:includes].should == [{'author' => 'country'}, 'comments']
-        results[:joins].should == ['activity']
-        results[:pagination].should == {:page => 3, :per_page => 5}
-        results[:offset].should == 10
-        results[:limit].should == 5
+        results[:select].should eq ['id', 'guid', 'name']
+        results[:where].should eq('name' => 'foop')
+        results[:order].should eq ['id desc', 'name asc']
+        results[:includes].should eq [{ 'author' => 'country' }, 'comments']
+        results[:joins].should eq ['activity']
+        results[:pagination].should eq(:page => 3, :per_page => 5)
+        results[:offset].should eq 10
+        results[:limit].should eq 5
       end
 
       it 'supports indifferent access' do
-        query_string = 'select=id,guid,name&where=name:foop&order=id:desc&order=name&page=3&page_size=5&includes=author.country,comments&joins=activity'
+        query_string = 'select=id,guid,name&where=name:foop&order=id:desc&order=name&page=3&page_size=5&includes=author.country,comments&joins=activity' # rubocop:disable Metrics/LineLength
         results = subject.parse(query_string)
 
-        results['select'].should == ['id', 'guid', 'name']
-        results['where'].should  == {'name' => 'foop'}
-        results['order'].should  == ['id desc', 'name asc']
-        results['includes'].should == [{'author' => 'country'}, 'comments']
-        results['joins'].should == ['activity']
-        results['pagination'].should == {:page => 3, :per_page => 5}
-        results['offset'].should == 10
-        results['limit'].should == 5
-
+        results['select'].should eq ['id', 'guid', 'name']
+        results['where'].should eq('name' => 'foop')
+        results['order'].should eq ['id desc', 'name asc']
+        results['includes'].should eq [{ 'author' => 'country' }, 'comments']
+        results['joins'].should eq ['activity']
+        results['pagination'].should eq(:page => 3, :per_page => 5)
+        results['offset'].should eq 10
+        results['limit'].should eq 5
       end
     end
   end

data/spec/muster/strategies/filter_expression_spec.rb

@@ -5,15 +5,14 @@ describe Muster::Strategies::FilterExpression do
   subject { Muster::Strategies::FilterExpression.new(options) }
 
   describe '#parse' do
-
     context 'by default' do
       it 'returns empty hash for empty query string' do
-        subject.parse('').should == {}
+        subject.parse('').should eq({})
         subject.parse('').should be_an_instance_of(Muster::Results)
       end
 
       it 'returns hash of all key/value pairs' do
-        subject.parse('where=id:1&filter=name:foop').should == { 'where' => {'id' => '1'}, 'filter' => {'name' => 'foop'} }
+        subject.parse('where=id:1&filter=name:foop').should eq('where' => { 'id' => '1' }, 'filter' => { 'name' => 'foop' })
       end
 
       it 'hash supports indifferent key access' do
@@ -23,19 +22,19 @@ describe Muster::Strategies::FilterExpression do
       end
 
       it 'combines multiple expressions into an array' do
-        subject.parse('where=id:1&where=id:2').should == { 'where' => {'id' => ['1', '2']} }
+        subject.parse('where=id:1&where=id:2').should eq('where' => { 'id' => ['1', '2'] })
       end
 
       it 'support for multiple values using |' do
-        subject.parse('where=id:1|2&where=id:3').should == { 'where' => {'id' => ['1', '2', '3']} }
+        subject.parse('where=id:1|2&where=id:3').should eq('where' => { 'id' => ['1', '2', '3'] })
       end
 
       it 'support for multiple expressions using ,' do
-        subject.parse('where=id:1,id:2,id:3').should == { 'where' => {'id' => ['1', '2', '3']} }
+        subject.parse('where=id:1,id:2,id:3').should eq('where' => { 'id' => ['1', '2', '3'] })
       end
 
       it 'discards non unique values' do
-        subject.parse('where=id:1&where=id:2&where=id:1').should == { 'where' => {'id' => ['1', '2']} }
+        subject.parse('where=id:1&where=id:2&where=id:1').should eq('where' => { 'id' => ['1', '2'] })
       end
     end
 
@@ -47,11 +46,11 @@ describe Muster::Strategies::FilterExpression do
         end
 
         it 'converts comma separated value into Array' do
-          subject.parse('where=id:1,2').should == { 'where' => {'id' => ['1', '2']} }
+          subject.parse('where=id:1,2').should eq('where' => { 'id' => ['1', '2'] })
         end
 
         it 'ignores spaces after commas' do
-          subject.parse('where=id:1,+2,%20   3').should == { 'where' => {'id' => ['1', '2', '3']} }
+          subject.parse('where=id:1,+2,%20   3').should eq('where' => { 'id' => ['1', '2', '3'] })
         end
       end
 
@@ -62,7 +61,7 @@ describe Muster::Strategies::FilterExpression do
         end
 
         it 'converts comma separated value into Array' do
-          subject.parse('where=id:1,2,3').should == { 'where' => {'id' => ['1', '2', '3']} }
+          subject.parse('where=id:1,2,3').should eq('where' => { 'id' => ['1', '2', '3'] })
         end
       end
     end
@@ -72,11 +71,11 @@ describe Muster::Strategies::FilterExpression do
         before { options[:field_separator] = /\s*!\s*/ }
 
         it 'splits field from values' do
-          subject.parse('where=id!1').should == { 'where' => {'id' => '1'} }
+          subject.parse('where=id!1').should eq('where' => { 'id' => '1' })
         end
 
         it 'ignores spaces after field' do
-          subject.parse('where=id ! 1').should == { 'where' => {'id' => '1'} }
+          subject.parse('where=id ! 1').should eq('where' => { 'id' => '1' })
         end
       end
 
@@ -84,7 +83,7 @@ describe Muster::Strategies::FilterExpression do
         before { options[:field_separator] = '!' }
 
         it 'converts comma separated value into Array' do
-          subject.parse('where=id!1').should == { 'where' => {'id' => '1'} }
+          subject.parse('where=id!1').should eq('where' => { 'id' => '1' })
         end
       end
     end
@@ -94,7 +93,7 @@ describe Muster::Strategies::FilterExpression do
         before { options[:field] = :where }
 
         it 'fields returns expressions for the key specified' do
-          subject.parse('where=id:1&filters=id:2').should == { 'where' => {'id' => '1'} }
+          subject.parse('where=id:1&filters=id:2').should eq('where' => { 'id' => '1' })
         end
       end
 
@@ -102,7 +101,7 @@ describe Muster::Strategies::FilterExpression do
         before { options[:fields] = [:where, :filter] }
 
         it 'fields returns expressions for the keys specified' do
-          subject.parse('where=id:1&filter=id:2&attribute=id:3').should == { 'where' => {'id' => '1'}, 'filter' => {'id' => '2'} }
+          subject.parse('where=id:1&filter=id:2&attribute=id:3').should eq('where' => { 'id' => '1' }, 'filter' => { 'id' => '2' })
         end
       end
 
@@ -110,7 +109,7 @@ describe Muster::Strategies::FilterExpression do
         before { options[:field] = 'where' }
 
         it 'fields returns expressions for the key specified' do
-          subject.parse('where=id:1&filter=id:2').should == { 'where' => {'id' => '1'} }
+          subject.parse('where=id:1&filter=id:2').should eq('where' => { 'id' => '1' })
         end
       end
 
@@ -118,10 +117,9 @@ describe Muster::Strategies::FilterExpression do
         before { options[:fields] = ['where', 'filter'] }
 
         it 'fields returns expressions for the keys specified' do
-          subject.parse('where=id:1&filter=id:2&attribute=id:3').should == { 'where' => {'id' => '1'}, 'filter' => {'id' => '2'} }
+          subject.parse('where=id:1&filter=id:2&attribute=id:3').should eq('where' => { 'id' => '1' }, 'filter' => { 'id' => '2' })
         end
       end
     end
-
   end
 end

data/spec/muster/strategies/hash_spec.rb

@@ -5,15 +5,14 @@ describe Muster::Strategies::Hash do
   subject { Muster::Strategies::Hash.new(options) }
 
   describe '#parse' do
-
     context 'by default' do
       it 'returns empty hash for empty query string' do
-        subject.parse('').should == {}
+        subject.parse('').should eq({})
         subject.parse('').should be_an_instance_of(Muster::Results)
       end
 
       it 'returns hash of all key/value pairs' do
-        subject.parse('a=1&b=2').should == {'a' => '1', 'b' => '2'}
+        subject.parse('a=1&b=2').should eq('a' => '1', 'b' => '2')
       end
 
       it 'hash supports indifferent key access' do
@@ -23,11 +22,11 @@ describe Muster::Strategies::Hash do
       end
 
       it 'combines multiple key values into an array' do
-        subject.parse('a=1&a=2').should == {'a' => ['1', '2']}
+        subject.parse('a=1&a=2').should eq('a' => ['1', '2'])
       end
 
       it 'discards non unique values' do
-        subject.parse('a=1&a=2&a=1').should == {'a' => ['1', '2']}
+        subject.parse('a=1&a=2&a=1').should eq('a' => ['1', '2'])
       end
     end
 
@@ -36,11 +35,11 @@ describe Muster::Strategies::Hash do
         before { options[:value_separator] = /,\s*/ }
 
         it 'converts comma separated value into Array' do
-          subject.parse('a=1,2&a=3').should == {'a' => ['1', '2', '3']}
+          subject.parse('a=1,2&a=3').should eq('a' => ['1', '2', '3'])
         end
 
         it 'ignores spaces after commas' do
-          subject.parse('a=1,+2,%20   3').should == {'a' => ['1', '2', '3']}
+          subject.parse('a=1,+2,%20   3').should eq('a' => ['1', '2', '3'])
         end
       end
 
@@ -48,7 +47,7 @@ describe Muster::Strategies::Hash do
         before { options[:value_separator] = '|' }
 
         it 'converts comma separated value into Array' do
-          subject.parse('a=1|2|3').should == {'a' => ['1', '2', '3']}
+          subject.parse('a=1|2|3').should eq('a' => ['1', '2', '3'])
         end
       end
     end
@@ -58,7 +57,7 @@ describe Muster::Strategies::Hash do
         before { options[:field] = :a }
 
         it 'fields returns values for the key specified' do
-          subject.parse('a=1&b=2').should == {'a' => '1'}
+          subject.parse('a=1&b=2').should eq('a' => '1')
         end
       end
 
@@ -66,7 +65,7 @@ describe Muster::Strategies::Hash do
         before { options[:fields] = [:a, :b] }
 
         it 'fields returns values for the keys specified' do
-          subject.parse('a=1&b=2&c=3').should == {'a' => '1', 'b' => '2'}
+          subject.parse('a=1&b=2&c=3').should eq('a' => '1', 'b' => '2')
         end
       end
 
@@ -74,7 +73,7 @@ describe Muster::Strategies::Hash do
         before { options[:field] = 'a' }
 
         it 'fields returns values for the key specified' do
-          subject.parse('a=1&b=2').should == {'a' => '1'}
+          subject.parse('a=1&b=2').should eq('a' => '1')
         end
       end
 
@@ -82,10 +81,9 @@ describe Muster::Strategies::Hash do
         before { options[:fields] = ['a', 'b'] }
 
         it 'fields returns values for the keys specified' do
-          subject.parse('a=1&b=2&c=3').should == {'a' => '1', 'b' => '2'}
+          subject.parse('a=1&b=2&c=3').should eq('a' => '1', 'b' => '2')
         end
       end
     end
-
   end
 end