praxis 2.0.pre.17 → 2.0.pre.21

data/spec/praxis/extensions/attribute_filtering/filtering_params_spec.rb

@@ -1,21 +1,22 @@
+# frozen_string_literal: true
+
 require 'spec_helper'
 
 require 'praxis/extensions/attribute_filtering'
 
 describe Praxis::Extensions::AttributeFiltering::FilteringParams do
-
   context '.load' do
     subject { described_class.load(filters_string) }
 
     context 'unescapes the URL encoded values' do
       it 'for single values' do
-          str = "one=#{CGI.escape('*')}&two>#{CGI.escape('^%$#!st_uff')}|three<normal"
-          parsed = [
-            { name: :one, op: '=', value: '*'},
-            { name: :two, op: '>', value: '^%$#!st_uff'},
-            { name: :three, op: '<', value: 'normal'},
-          ]
-          expect(described_class.load(str).parsed_array.map{|i| i.slice(:name,:op,:value)}).to eq(parsed)
+        str = "one=#{CGI.escape('*')}&two>#{CGI.escape('^%$#!st_uff')}|three<normal"
+        parsed = [
+          { name: :one, op: '=', value: '*' },
+          { name: :two, op: '>', value: '^%$#!st_uff' },
+          { name: :three, op: '<', value: 'normal' }
+        ]
+        expect(described_class.load(str).parsed_array.map { |i| i.slice(:name, :op, :value) }).to eq(parsed)
       end
       it 'each of the multi-values' do
         escaped_one = [
@@ -25,55 +26,55 @@ describe Praxis::Extensions::AttributeFiltering::FilteringParams do
         ].join(',')
         str = "one=#{escaped_one}&two>normal"
         parsed = [
-          { name: :one, op: '=', value: ['fun!','Times','~!@#$%^&*()_+-={}|[]\:";\'<>?,./`']},
-          { name: :two, op: '>', value: 'normal'},
+          { name: :one, op: '=', value: ['fun!', 'Times', '~!@#$%^&*()_+-={}|[]\:";\'<>?,./`'] },
+          { name: :two, op: '>', value: 'normal' }
         ]
-        expect(described_class.load(str).parsed_array.map{|i| i.slice(:name,:op,:value)}).to eq(parsed)
+        expect(described_class.load(str).parsed_array.map { |i| i.slice(:name, :op, :value) }).to eq(parsed)
       end
       it 'does not handle badly escaped values that contain reserved chars ()|&,' do
         badly_escaped = 'val('
         str = "one=#{badly_escaped}&(two>normal|three!)"
-        expect{
+        expect do
           described_class.load(str)
-        }.to raise_error(Parslet::ParseFailed)
+        end.to raise_error(Parslet::ParseFailed)
       end
     end
     context 'parses for operator' do
       described_class::VALUE_OPERATORS.each do |op|
-        it "#{op}" do
+        it op.to_s do
           str = "thename#{op}thevalue"
-          parsed = [{ name: :thename, op: op, value: 'thevalue'}]
-          expect(described_class.load(str).parsed_array.map{|i| i.slice(:name,:op,:value)}).to eq(parsed)
+          parsed = [{ name: :thename, op: op, value: 'thevalue' }]
+          expect(described_class.load(str).parsed_array.map { |i| i.slice(:name, :op, :value) }).to eq(parsed)
         end
       end
       described_class::NOVALUE_OPERATORS.each do |op|
-        it "#{op}" do
+        it op.to_s do
           str = "thename#{op}"
-          parsed = [{ name: :thename, op: op, value: nil}]
-          expect(described_class.load(str).parsed_array.map{|i| i.slice(:name,:op,:value)}).to eq(parsed)
+          parsed = [{ name: :thename, op: op, value: nil }]
+          expect(described_class.load(str).parsed_array.map { |i| i.slice(:name, :op, :value) }).to eq(parsed)
         end
       end
       it 'can parse multiple values for filter' do
-        str="filtername=1,2,3"
-        parsed = [{ name: :filtername, op: '=', value: ["1","2","3"]}]
-        expect(described_class.load(str).parsed_array.map{|i| i.slice(:name,:op,:value)}).to eq(parsed)
+        str = 'filtername=1,2,3'
+        parsed = [{ name: :filtername, op: '=', value: %w[1 2 3] }]
+        expect(described_class.load(str).parsed_array.map { |i| i.slice(:name, :op, :value) }).to eq(parsed)
       end
     end
     context 'with all value operators at once for the same AND group' do
-      let(:filters_string) { 'one=11&two!=22&three>=33&four<=4&five<5&six>6&seven!&eight!!'}
+      let(:filters_string) { 'one=11&two!=22&three>=33&four<=4&five<5&six>6&seven!&eight!!' }
       it do
-        expect(subject.parsed_array.map{|i| i.slice(:name,:op,:value)}).to eq([
-          { name: :one, op: '=', value: '11'},
-          { name: :two, op: '!=', value: '22'},
-          { name: :three, op: '>=', value: '33'},
-          { name: :four, op: '<=', value: '4'},
-          { name: :five, op: '<', value: '5'},
-          { name: :six, op: '>', value: '6'},
-          { name: :seven, op: '!', value: nil},
-          { name: :eight, op: '!!', value: nil},          
-        ])
+        expect(subject.parsed_array.map { |i| i.slice(:name, :op, :value) }).to eq([
+                                                                                     { name: :one, op: '=', value: '11' },
+                                                                                     { name: :two, op: '!=', value: '22' },
+                                                                                     { name: :three, op: '>=', value: '33' },
+                                                                                     { name: :four, op: '<=', value: '4' },
+                                                                                     { name: :five, op: '<', value: '5' },
+                                                                                     { name: :six, op: '>', value: '6' },
+                                                                                     { name: :seven, op: '!', value: nil },
+                                                                                     { name: :eight, op: '!!', value: nil }
+                                                                                   ])
         # And all have the same parent, which is an AND group
-        parent = subject.parsed_array.map{|i|i[:node_object].parent_group}.uniq
+        parent = subject.parsed_array.map { |i| i[:node_object].parent_group }.uniq
         expect(parent.size).to eq(1)
         expect(parent.first.type).to eq(:and)
         expect(parent.first.parent_group).to be_nil
@@ -81,17 +82,17 @@ describe Praxis::Extensions::AttributeFiltering::FilteringParams do
     end
 
     context 'with with nested precedence groups' do
-      let(:filters_string) { '(one=11)&(two!=22|three!!)&four<=4&five>5|six!'}
+      let(:filters_string) { '(one=11)&(two!=22|three!!)&four<=4&five>5|six!' }
       it do
         parsed = subject.parsed_array
-        expect(parsed.map{|i| i.slice(:name,:op,:value)}).to eq([
-          { name: :one, op: '=', value: '11'},
-          { name: :two, op: '!=', value: '22'},
-          { name: :three, op: '!!', value: nil},
-          { name: :four, op: '<=', value: '4'},
-          { name: :five, op: '>', value: '5'},
-          { name: :six, op: '!', value: nil},
-        ])
+        expect(parsed.map { |i| i.slice(:name, :op, :value) }).to eq([
+                                                                       { name: :one, op: '=', value: '11' },
+                                                                       { name: :two, op: '!=', value: '22' },
+                                                                       { name: :three, op: '!!', value: nil },
+                                                                       { name: :four, op: '<=', value: '4' },
+                                                                       { name: :five, op: '>', value: '5' },
+                                                                       { name: :six, op: '!', value: nil }
+                                                                     ])
         # Grouped appropriately
         parent_of = parsed.each_with_object({}) do |item, hash|
           hash[item[:name]] = item[:node_object].parent_group
@@ -106,9 +107,9 @@ describe Praxis::Extensions::AttributeFiltering::FilteringParams do
         # two and 3 are grouped together by an OR
         expect(parent_of[:two]).to be(parent_of[:three])
         expect(parent_of[:two].type).to eq(:or)
-        
+
         # one, two, four and the or from two/three are grouped together by an AND
-        expect([parent_of[:one],parent_of[:two].parent_group,parent_of[:four],parent_of[:five]]).to all(be(parent_of[:one]))
+        expect([parent_of[:one], parent_of[:two].parent_group, parent_of[:four], parent_of[:five]]).to all(be(parent_of[:one]))
         expect(parent_of[:one].type).to eq(:and)
 
         # six and the whole group above are grouped together with an OR
@@ -119,11 +120,12 @@ describe Praxis::Extensions::AttributeFiltering::FilteringParams do
 
     context 'value coercing when associated to a MediaType' do
       let(:parsed) do
-        # Note wrap the filter_params (.for) type in an attribute (which then we discard), so it will 
-        # construct it propertly by applying the block. Seems easier than creating the type alone, and 
+        # Note wrap the filter_params (.for) type in an attribute (which then we discard), so it will
+        # construct it propertly by applying the block. Seems easier than creating the type alone, and
         # then manually apply the block
         Attributor::Attribute.new(described_class.for(Post)) do
           filter 'id', using: ['=', '!=', '!']
+          any 'updated_at', using: ['>', '<', '=']
         end.type.load(str).parsed_array
       end
 
@@ -151,19 +153,41 @@ describe Praxis::Extensions::AttributeFiltering::FilteringParams do
           expect(parsed.first[:value]).to be_nil
         end
       end
-    end
 
+      context 'for an ANY matcher' do
+        let(:str) { 'blog.timestamps.updated_at>=2001-01-01' }
+        it 'coerces its value to the associated mediatype attribute type' do
+          expect(parsed.first[:value]).to eq(DateTime.parse('2001-01-01'))
+          nested_updated_at_attr = Post.attributes[:blog].attributes[:timestamps].attributes[:updated_at]
+          expect(nested_updated_at_attr.type.valid_type?(parsed.first[:value])).to be_truthy
+        end
+      end
+
+      context 'for both normal and ANY type filters' do
+        let(:str) { 'blog.timestamps.updated_at>=2001-01-01&id=42' }
+        it 'properly parsed them both, and into their own types' do
+          expect(parsed.first[:value]).to eq(DateTime.parse('2001-01-01'))
+          nested_updated_at_attr = Post.attributes[:blog].attributes[:timestamps].attributes[:updated_at]
+          expect(nested_updated_at_attr.type.valid_type?(parsed.first[:value])).to be_truthy
+
+          expect(parsed.second[:value]).to eq(42)
+          id_attr = Post.attributes[:blog].attributes[:id]
+          expect(id_attr.type.valid_type?(parsed.second[:value])).to be_truthy
+        end
+      end
+    end
   end
 
   context '.validate' do
     let(:filtering_params_type) do
-      # Note wrap the filter_params (.for) type in an attribute (which then we discard), so it will 
-      # construct it propertly by applying the block. Seems easier than creating the type alone, and 
+      # Note wrap the filter_params (.for) type in an attribute (which then we discard), so it will
+      # construct it propertly by applying the block. Seems easier than creating the type alone, and
       # then manually apply the block
       Attributor::Attribute.new(described_class.for(Post)) do
         filter 'id', using: ['=', '!=', '!']
         filter 'title', using: ['=', '!='], fuzzy: true
         filter 'content', using: ['=', '!=', '!']
+        any 'updated_at', using: ['>', '<', '=']
       end.type
     end
     let(:loaded_params) { filtering_params_type.load(filters_string) }
@@ -171,23 +195,23 @@ describe Praxis::Extensions::AttributeFiltering::FilteringParams do
 
     context 'errors' do
       context 'given attributes that do not exist in the type' do
-        let(:filters_string) { 'NotAnExistingAttribute=Foobar*'}
+        let(:filters_string) { 'NotAnExistingAttribute=Foobar*' }
         it 'raises an error' do
-          expect{subject}.to raise_error(/NotAnExistingAttribute.*does not exist/)
+          expect { subject }.to raise_error(/NotAnExistingAttribute.*does not exist/)
         end
       end
 
       context 'given unallowed attributes' do
-        let(:filters_string) { 'href=Foobar*'}
+        let(:filters_string) { 'href=Foobar*' }
         it 'raises an error' do
           expect(subject).to_not be_empty
-          matches_error = subject.any? {|err| err =~ /Filtering by href is not allowed/}
+          matches_error = subject.any? { |err| err =~ /Filtering by href is not allowed.*leaf attributes matching updated_at/ }
           expect(matches_error).to be_truthy
         end
       end
 
       context 'given unallowed operator' do
-        let(:filters_string) { 'title>Foobar*'}
+        let(:filters_string) { 'title>Foobar*' }
         it 'raises an error' do
           expect(subject).to_not be_empty
           expect(subject.first).to match(/Operator > not allowed for filter title/)
@@ -195,15 +219,43 @@ describe Praxis::Extensions::AttributeFiltering::FilteringParams do
       end
     end
 
+    context 'for any-type leaf filters' do
+      context 'with the correct operator' do
+        let(:filters_string) { 'timestamps.updated_at>2001-01-01' }
+        it 'succeeds' do
+          expect(subject).to be_empty
+        end
+      end
+      context 'with the correct operator on a nested mediatype' do
+        let(:filters_string) { 'blog.timestamps.updated_at>2001-01-01' }
+        it 'succeeds' do
+          expect(subject).to be_empty
+        end
+      end
+      context 'with an incorrect operator' do
+        let(:filters_string) { 'blog.timestamps.updated_at>=2001-01-01' }
+        it 'complains about it' do
+          expect(subject).to_not be_empty
+          expect(subject.first).to match(/Operator >= not allowed for filter blog.timestamps.updated_at/)
+        end
+      end
+      context 'with an correct operator but passing an unexistent attribute path' do
+        let(:filters_string) { 'some.not.true.path.updated_at>=2001-01-01' }
+        it 'complains about it' do
+          expect { subject }.to raise_error(/Error, you've requested to filter by field 'some'/)
+        end
+      end
+    end
+
     context 'non-valued operators' do
       context 'for string typed fields' do
-        let(:filters_string) { 'content!'}
+        let(:filters_string) { 'content!' }
         it 'validates properly' do
           expect(subject).to be_empty
         end
       end
       context 'for non-string typed fields' do
-        let(:filters_string) { 'id!'}
+        let(:filters_string) { 'id!' }
         it 'validates properly' do
           expect(subject).to be_empty
         end
@@ -212,7 +264,7 @@ describe Praxis::Extensions::AttributeFiltering::FilteringParams do
     context 'fuzzy matches' do
       context 'when allowed' do
         context 'given a fuzzy string' do
-          let(:filters_string) { 'title=IAmAString*'}
+          let(:filters_string) { 'title=IAmAString*' }
           it 'validates properly' do
             expect(subject).to be_empty
           end
@@ -220,14 +272,14 @@ describe Praxis::Extensions::AttributeFiltering::FilteringParams do
       end
       context 'when NOT allowed' do
         context 'given a fuzzy string' do
-          let(:filters_string) { 'content=IAmAString*'}
+          let(:filters_string) { 'content=IAmAString*' }
           it 'errors out' do
             expect(subject).to_not be_empty
             expect(subject.first).to match(/Fuzzy matching for content is not allowed/)
           end
         end
         context 'given a non-fuzzy string' do
-          let(:filters_string) { 'content=IAmAString'}
+          let(:filters_string) { 'content=IAmAString' }
           it 'validates properly' do
             expect(subject).to be_empty
           end

data/spec/praxis/extensions/attribute_filtering/filters_parser_spec.rb

@@ -1,22 +1,22 @@
+# frozen_string_literal: true
+
 require 'praxis/extensions/attribute_filtering/filters_parser'
 
 describe Praxis::Extensions::AttributeFiltering::FilteringParams::Condition do
-end 
+end
 
 describe Praxis::Extensions::AttributeFiltering::FilteringParams::ConditionGroup do
-end 
+end
 
 describe Praxis::Extensions::AttributeFiltering::FilteringParams::Parser do
-
   context 'testing' do
     let(:expectations) do
-      { 
-        'one=11|two=22' => "( one=11 OR two=22 )"
+      {
+        'one=11|two=22' => '( one=11 OR two=22 )'
       }
     end
     it 'parses and loads the parsed result into the tree objects' do
       expectations.each do |filters, dump_result|
-
         parsed = described_class.new.parse(filters)
         tree = Praxis::Extensions::AttributeFiltering::FilteringParams::ConditionGroup.load(parsed)
 
@@ -24,8 +24,7 @@ describe Praxis::Extensions::AttributeFiltering::FilteringParams::Parser do
       end
     end
   end
-   context 'parses the grammar' do
-
+  context 'parses the grammar' do
     # Takes a hash with keys containing literal filters string, and values being the "dump format for Condition/Group"
     shared_examples 'round-trip-properly' do |expectations|
       it description do
@@ -38,24 +37,24 @@ describe Praxis::Extensions::AttributeFiltering::FilteringParams::Parser do
     end
 
     context 'single expression' do
-      it_behaves_like 'round-trip-properly', { 
+      it_behaves_like 'round-trip-properly', {
         'one=11' => 'one=11',
         '(one=11)' => 'one=11',
-        'one!' => "one!",
+        'one!' => 'one!'
       }
     end
     context 'same expression operator' do
-      it_behaves_like 'round-trip-properly', { 
+      it_behaves_like 'round-trip-properly', {
         'one=11&two=22' => '( one=11 AND two=22 )',
         'one=11&two=22&three=3' => '( one=11 AND two=22 AND three=3 )',
         'one=1,2,3&two=4,5' => '( one=[1,2,3] AND two=[4,5] )',
         'one=11|two=22' => '( one=11 OR two=22 )',
-        'one=11|two=22|three=3' => '( one=11 OR two=22 OR three=3 )',
+        'one=11|two=22|three=3' => '( one=11 OR two=22 OR three=3 )'
       }
     end
 
     context 'respects and/or precedence and parenthesis grouping' do
-      it_behaves_like 'round-trip-properly', { 
+      it_behaves_like 'round-trip-properly', {
         'a=1&b=2&z=9|c=3' => '( ( a=1 AND b=2 AND z=9 ) OR c=3 )',
         'a=1|b=2&c=3' => '( a=1 OR ( b=2 AND c=3 ) )',
         'a=1|b=2&c=3&d=4' => '( a=1 OR ( b=2 AND c=3 AND d=4 ) )',
@@ -65,56 +64,56 @@ describe Praxis::Extensions::AttributeFiltering::FilteringParams::Parser do
         'one=11&two=2|three=3' => '( ( one=11 AND two=2 ) OR three=3 )', # AND has higer precedence
         'one=11|two=2&three=3' => '( one=11 OR ( two=2 AND three=3 ) )', # AND has higer precedence
         'one=11&two=2|three=3&four=4' => '( ( one=11 AND two=2 ) OR ( three=3 AND four=4 ) )',
-        '(one=11)&(two!=2|three=3)&four=4&five=5|six=6' => 
+        '(one=11)&(two!=2|three=3)&four=4&five=5|six=6' =>
             '( ( one=11 AND ( two!=2 OR three=3 ) AND four=4 AND five=5 ) OR six=6 )',
         '(one=11)&three=3' => '( one=11 AND three=3 )',
         '(one=11|two=2)&(three=3|four=4)' => '( ( one=11 OR two=2 ) AND ( three=3 OR four=4 ) )',
         '(category_uuid=deadbeef1|category_uuid=deadbeef2)&(name=Book1|name=Book2)' =>
             '( ( category_uuid=deadbeef1 OR category_uuid=deadbeef2 ) AND ( name=Book1 OR name=Book2 ) )',
         '(category_uuid=deadbeef1&name=Book1)|(category_uuid=deadbeef2&name=Book2)' =>
-            '( ( category_uuid=deadbeef1 AND name=Book1 ) OR ( category_uuid=deadbeef2 AND name=Book2 ) )',
+            '( ( category_uuid=deadbeef1 AND name=Book1 ) OR ( category_uuid=deadbeef2 AND name=Book2 ) )'
       }
     end
 
     context 'empty values get converted to empty strings' do
-      it_behaves_like 'round-trip-properly', { 
+      it_behaves_like 'round-trip-properly', {
         'one=' => 'one=""',
-        'one=&two=2' => '( one="" AND two=2 )',
+        'one=&two=2' => '( one="" AND two=2 )'
       }
     end
 
     context 'no value operands' do
-      it_behaves_like 'round-trip-properly', { 
-        'one!' => "one!",
-        'one!!' => "one!!"
+      it_behaves_like 'round-trip-properly', {
+        'one!' => 'one!',
+        'one!!' => 'one!!'
       }
 
       it 'fails if passing a value' do
-        expect {
+        expect do
           described_class.new.parse('one!val')
-        }.to raise_error(Parslet::ParseFailed)
-        expect {
+        end.to raise_error(Parslet::ParseFailed)
+        expect do
           described_class.new.parse('one!!val')
-        }.to raise_error(Parslet::ParseFailed)
-      end 
+        end.to raise_error(Parslet::ParseFailed)
+      end
     end
 
     context 'csv values result in multiple values for the operation' do
-      it_behaves_like 'round-trip-properly', { 
-        'multi=1,2' => "multi=[1,2]",
-        'multi=1,2,valuehere' => "multi=[1,2,valuehere]"
+      it_behaves_like 'round-trip-properly', {
+        'multi=1,2' => 'multi=[1,2]',
+        'multi=1,2,valuehere' => 'multi=[1,2,valuehere]'
       }
     end
 
     context 'supports [a-zA-Z0-9_\.] for filter names' do
-      it_behaves_like 'round-trip-properly', { 
-        'normal=1'      => 'normal=1',
-        'cOmBo=1'       => 'cOmBo=1',
-        '1=2'           => '1=2',
+      it_behaves_like 'round-trip-properly', {
+        'normal=1' => 'normal=1',
+        'cOmBo=1' => 'cOmBo=1',
+        '1=2' => '1=2',
         'aFew42Things=1' => 'aFew42Things=1',
         'under_scores=1' => 'under_scores=1',
         'several.dots.in.here=1' => 'several.dots.in.here=1',
-        'cOrN.00copia.of_thinGs.42_here=1' => 'cOrN.00copia.of_thinGs.42_here=1',
+        'cOrN.00copia.of_thinGs.42_here=1' => 'cOrN.00copia.of_thinGs.42_here=1'
       }
     end
     context 'supports everything (except &|(),) for values (even without encoding..not allowed, but just to ensure the parser does not bomb)' do
@@ -123,7 +122,7 @@ describe Praxis::Extensions::AttributeFiltering::FilteringParams::Parser do
         'v=*foo*' => 'v={*}foo{*}',
         'v=*^%$#@!foo' => 'v={*}^%$#@!foo',
         'v=_-=\{}"?:><' => 'v=_-=\{}"?:><',
-        'v=_-=\{}"?:><,another_value!' => 'v=[_-=\{}"?:><,another_value!]',
+        'v=_-=\{}"?:><,another_value!' => 'v=[_-=\{}"?:><,another_value!]'
       }
     end
     context 'properly detects and handles fuzzy matching encoded as {*} in the dump' do
@@ -132,7 +131,7 @@ describe Praxis::Extensions::AttributeFiltering::FilteringParams::Parser do
         'v=*foo*' => 'v={*}foo{*}',
         'v=foo*' => 'v=foo{*}',
         'v=*start,end*,*both*' => 'v=[{*}start,end{*},{*}both{*}]',
-        "v=*#{CGI.escape('***')},#{CGI.escape('*')}" => 'v=[{*}***,*]', # Simple exact match on 2nd
+        "v=*#{CGI.escape('***')},#{CGI.escape('*')}" => 'v=[{*}***,*]' # Simple exact match on 2nd
       }
     end
     context 'properly handles url-encoded values' do
@@ -141,8 +140,8 @@ describe Praxis::Extensions::AttributeFiltering::FilteringParams::Parser do
         "v=*#{CGI.escape('foo')}*" => 'v={*}foo{*}',
         "v=*#{CGI.escape('^%$#@!foo')}" => 'v={*}^%$#@!foo',
         "v=#{CGI.escape('~!@#$%^&*()_+-={}|[]\:";\'<>?,./`')}" => 'v=~!@#$%^&*()_+-={}|[]\:";\'<>?,./`',
-        "v=#{CGI.escape('_-+=\{}"?:><')},#{CGI.escape('another_value!')}" => 'v=[_-+=\{}"?:><,another_value!]',
+        "v=#{CGI.escape('_-+=\{}"?:><')},#{CGI.escape('another_value!')}" => 'v=[_-+=\{}"?:><,another_value!]'
       }
-    end 
+    end
   end
-end
+end

data/spec/praxis/extensions/field_expansion_spec.rb

@@ -1,9 +1,10 @@
+# frozen_string_literal: true
+
 require 'spec_helper'
 
 require 'praxis/extensions/field_selection'
 
 describe Praxis::Extensions::FieldExpansion do
-
   # include the ActionDefinitionExtension module directly, as that's where the
   # bulk of lies, and by including this instead of the base FieldExpansion module
   # we avoid the side-effect of injecting the ActionDefinitionExtension into
@@ -24,8 +25,7 @@ describe Praxis::Extensions::FieldExpansion do
 
   let(:request_params) do
     double('params',
-      fields: Praxis::Extensions::FieldSelection::FieldSelector.for(Person).load(fields)
-    )
+           fields: Praxis::Extensions::FieldSelection::FieldSelector.for(Person).load(fields))
   end
 
   let(:request) { double('Praxis::Request', params: request_params) }
@@ -33,26 +33,25 @@ describe Praxis::Extensions::FieldExpansion do
 
   let(:fields) { nil }
 
-  let(:test_attributes) {  }
+  let(:test_attributes) {}
   let(:test_params) { double('test_params', attributes: test_attributes) }
 
-  subject(:expansion) { test_instance.expanded_fields(request, media_type)}
+  subject(:expansion) { test_instance.expanded_fields(request, media_type) }
 
   context '#expanded_fields' do
-
     context 'with fields and view params defined' do
       let(:test_attributes) { {} }
 
       context 'with no fields provided' do
         it 'returns the fields for the default view' do
-          expect(expansion).to eq({id: true, name: true})
+          expect(expansion).to eq({ id: true, name: true })
         end
       end
 
       context 'with a set of fields provided' do
         let(:fields) { 'id,name,owner{name}' }
         it 'returns the subset of fields' do
-          expected = {id: true, name: true }
+          expected = { id: true, name: true }
           expect(expansion).to eq expected
         end
       end
@@ -61,9 +60,8 @@ describe Praxis::Extensions::FieldExpansion do
     context 'with an action with no params' do
       let(:test_params) { nil }
       it 'ignores incoming parameters and expands for the default fieldset' do
-        expect(expansion).to eq({id: true, name: true})
+        expect(expansion).to eq({ id: true, name: true })
       end
     end
   end
-
 end

data/spec/praxis/extensions/field_selection/active_record_query_selector_spec.rb

@@ -1,10 +1,12 @@
+# frozen_string_literal: true
+
 require 'spec_helper'
 
-require_relative '../support/spec_resources_active_model.rb'
+require_relative '../support/spec_resources_active_model'
 
 describe Praxis::Extensions::FieldSelection::ActiveRecordQuerySelector do
   let(:selector_fields) do
-    { 
+    {
       name: true,
       author: {
         id: true,
@@ -29,13 +31,13 @@ describe Praxis::Extensions::FieldSelection::ActiveRecordQuerySelector do
       :id # We always load the primary keys
     ]
   end
-  let(:selector_node) { Praxis::Mapper::SelectorGenerator.new.add(ActiveBookResource,selector_fields).selectors  }
-  let(:debug){ false }
+  let(:selector_node) { Praxis::Mapper::SelectorGenerator.new.add(ActiveBookResource, selector_fields).selectors }
+  let(:debug) { false }
 
-  subject(:selector) {described_class.new(query: query, selectors: selector_node, debug: debug) }
+  subject(:selector) { described_class.new(query: query, selectors: selector_node, debug: debug) }
   context '#generate with a mocked' do
-    let(:query) { double("Query") }
-    it 'calls the select columns for the top level, and includes the right association hashes' do      
+    let(:query) { double('Query') }
+    it 'calls the select columns for the top level, and includes the right association hashes' do
       expect(query).to receive(:select).with(*expected_select_from_to_query).and_return(query)
       expected_includes = {
         author: {
@@ -49,9 +51,9 @@ describe Praxis::Extensions::FieldSelection::ActiveRecordQuerySelector do
       expect(query).to receive(:includes).with(expected_includes).and_return(query)
       expect(subject).to_not receive(:explain_query)
       subject.generate
-    end 
+    end
     context 'when debug is enabled' do
-      let(:debug){ true }
+      let(:debug) { true }
       it 'calls the explain method' do
         expect(query).to receive(:select).and_return(query)
         expect(query).to receive(:includes).and_return(query)
@@ -74,7 +76,7 @@ describe Praxis::Extensions::FieldSelection::ActiveRecordQuerySelector do
         },
         tags: {}
       }
-      #expect(query).to receive(:includes).with(expected_includes).and_return(query)
+      # expect(query).to receive(:includes).with(expected_includes).and_return(query)
       expect(subject).to_not receive(:explain_query)
       final_query = subject.generate
       expect(final_query.select_values).to match_array(expected_select_from_to_query)
@@ -90,7 +92,7 @@ describe Praxis::Extensions::FieldSelection::ActiveRecordQuerySelector do
       expect(book1.author.books.size).to eq 1
       expect(book1.author.books.map(&:simple_name)).to eq(['Book1'])
       expect(book1.category.name).to eq 'cat1'
-      expect(book1.tags.map(&:name)).to match_array(['blue','red','green'])
+      expect(book1.tags.map(&:name)).to match_array(%w[blue red green])
 
       expect(book2.author.id).to eq 22
       expect(book2.author.books.size).to eq 1
@@ -104,7 +106,6 @@ describe Praxis::Extensions::FieldSelection::ActiveRecordQuerySelector do
         # Actually make it run all the way...but suppressing the output
         subject.generate
       end
-    end 
+    end
   end
-
 end