praxis 2.0.pre.18 → 2.0.pre.19

data/spec/praxis/bootloader_spec.rb

@@ -1,24 +1,26 @@
+# frozen_string_literal: true
+
 require 'spec_helper'
 
 describe Praxis::Bootloader do
   let(:application) do
-    instance_double("Praxis::Application", config: "config", root: "root", plugins: {}, file_layout: {} )
+    instance_double('Praxis::Application', config: 'config', root: 'root', plugins: {}, file_layout: {})
   end
 
-  subject(:bootloader) {Praxis::Bootloader.new(application)}
+  subject(:bootloader) { Praxis::Bootloader.new(application) }
 
   context 'attributes' do
-    its(:application) {should be(application)}
+    its(:application) { should be(application) }
     it 'stages' do
-      init_stages = [:environment, :plugins, :initializers, :lib, :design, :app, :routing, :warn_unloaded_files]
-      expect(bootloader.stages.map {|s| s.name}).to eq(init_stages)
+      init_stages = %i[environment plugins initializers lib design app routing warn_unloaded_files]
+      expect(bootloader.stages.map(&:name)).to eq(init_stages)
     end
-    its(:config) {should be(application.config)}
-    its(:root) {should be(application.root)}
+    its(:config) { should be(application.config) }
+    its(:root) { should be(application.root) }
   end
 
-  context ".run" do
-    it "should call setup and run for all the stages" do
+  context '.run' do
+    it 'should call setup and run for all the stages' do
       bootloader.stages.each do |s|
         expect(s).to receive(:setup!).once
         expect(s).to receive(:run).once
@@ -26,46 +28,46 @@ describe Praxis::Bootloader do
       bootloader.run
     end
   end
-  context ".delete_stage" do
-    it "delete valid stage" do
+  context '.delete_stage' do
+    it 'delete valid stage' do
       bootloader.delete_stage(:app)
       expect(bootloader.stages.include?(:app)).to be(false)
     end
 
-    it "raise errors when deleting invalid stage" do
-      expect{bootloader.delete_stage(:unexistent_stage)}.to raise_error(Praxis::Exceptions::StageNotFound)
+    it 'raise errors when deleting invalid stage' do
+      expect { bootloader.delete_stage(:unexistent_stage) }.to raise_error(Praxis::Exceptions::StageNotFound)
     end
   end
 
-  context ".before" do
-    it "run before block of first element in stage_path" do
+  context '.before' do
+    it 'run before block of first element in stage_path' do
       stage = bootloader.stages.first
       allow(stage).to receive(:before).and_return('before!')
       expect(bootloader.before(stage.name)).to eq('before!')
     end
 
-    it "raises when given an invalid stage name" do
-      expect{
+    it 'raises when given an invalid stage name' do
+      expect do
         bootloader.before('nope!')
-      }.to raise_error(Praxis::Exceptions::StageNotFound,/Error running a before block for stage nope!/)
+      end.to raise_error(Praxis::Exceptions::StageNotFound, /Error running a before block for stage nope!/)
     end
   end
 
-  context ".after" do
-    it "run before block of first element in stage_path" do
+  context '.after' do
+    it 'run before block of first element in stage_path' do
       stage = bootloader.stages.first
       allow(stage).to receive(:after).and_return('after!')
       expect(bootloader.after(stage.name)).to eq('after!')
     end
 
-    it "raises when given an invalid stage name" do
-      expect{
+    it 'raises when given an invalid stage name' do
+      expect do
         bootloader.after('nope!')
-      }.to raise_error(Praxis::Exceptions::StageNotFound,/Error running an after block for stage nope!/)
+      end.to raise_error(Praxis::Exceptions::StageNotFound, /Error running an after block for stage nope!/)
     end
   end
 
-  context ".use" do
+  context '.use' do
     let(:plugin) do
       Class.new(Praxis::Plugin) do
         def config_key
@@ -74,27 +76,27 @@ describe Praxis::Bootloader do
       end
     end
 
-    it "plugin add to application" do
+    it 'plugin add to application' do
       bootloader.use(plugin)
       expect(bootloader.application.plugins[:foo].class).to be(plugin)
     end
 
-    it "complains if a plugin with same name already registered" do
+    it 'complains if a plugin with same name already registered' do
       bootloader.use(plugin)
       expect do
         bootloader.use(plugin)
-      end.to raise_error /another plugin (.*) is already registered with key: foo/
+      end.to raise_error(/another plugin (.*) is already registered with key: foo/)
     end
-    context "defaults config_key" do
+    context 'defaults config_key' do
       let(:plugin_two) do
         Class.new(Praxis::Plugin) do
           def self.name
-            "Two" # Need this to avoid creating a true named class.
+            'Two' # Need this to avoid creating a true named class.
           end
         end
       end
 
-      it "to the class name" do
+      it 'to the class name' do
         bootloader.use(plugin_two)
         expect(bootloader.application.plugins[:two].class).to be(plugin_two)
       end

data/spec/praxis/callbacks_spec.rb

@@ -1,41 +1,43 @@
+# frozen_string_literal: true
+
 require 'spec_helper'
 
 describe Praxis::Callbacks do
-  let(:controller){ double("controller", request: "request") }
-  
+  let(:controller) { double('controller', request: 'request') }
+
   subject do
-    Class.new {
+    Class.new do
       include Praxis::Callbacks
 
-#      implements PeopleResource
+      #      implements PeopleResource
 
-      before :validate, actions: [:index] do |controller|
-        "before"
+      before :validate, actions: [:index] do |_controller|
+        'before'
       end
 
       before actions: [:show] do |controller|
       end
 
-      after :response, actions: [:show] do |controller|
-        "after"
+      after :response, actions: [:show] do |_controller|
+        'after'
       end
 
-      around :action , actions: [:foobar] do |controller, callee|
+      around :action, actions: [:foobar] do |controller, callee|
         controller.request
         callee.call
       end
-    }
+    end
   end
-  
+
   context '.before' do
     let(:validate_conditions) { subject.before_callbacks[[:validate]][0][0] }
     let(:validate_block) { subject.before_callbacks[[:validate]][0][1] }
 
     it 'sets up the before_callbacks' do
       expect(subject.before_callbacks.keys).to match_array([[:validate], [:action]])
-      expect(validate_conditions).to eq({:actions => [:index]})
+      expect(validate_conditions).to eq({ actions: [:index] })
       expect(validate_block).to be_kind_of(Proc)
-      expect(validate_block.call(controller)).to eq("before")
+      expect(validate_block.call(controller)).to eq('before')
     end
   end
 
@@ -45,63 +47,61 @@ describe Praxis::Callbacks do
 
     it 'sets up the after_callbacks' do
       expect(subject.after_callbacks.keys).to match_array([[:response]])
-      expect(response_conditions).to eq({:actions => [:show]})
+      expect(response_conditions).to eq({ actions: [:show] })
       expect(response_block).to be_kind_of(Proc)
-      expect(response_block.call(controller)).to eq("after")
+      expect(response_block.call(controller)).to eq('after')
     end
   end
-  
 
   context '.around' do
-    let(:callee_result){ "result" }
-    let(:callee){ double("callee", call: callee_result) }
+    let(:callee_result) { 'result' }
+    let(:callee) { double('callee', call: callee_result) }
     let(:around_conditions) { subject.around_callbacks[[:action]][0][0] }
     let(:around_block) { subject.around_callbacks[[:action]][0][1] }
 
     it 'sets up the before_callbacks' do
       expect(subject.around_callbacks.keys).to match_array([[:action]])
-      expect(around_conditions).to eq({:actions => [:foobar]})
+      expect(around_conditions).to eq({ actions: [:foobar] })
       expect(around_block).to be_kind_of(Proc)
     end
     it 'passes the right parameters to the block call' do
       expect(controller).to receive(:request)
       expect(callee).to receive(:call)
-      expect(around_block.call( controller,callee )).to eq(callee_result)
+      expect(around_block.call(controller, callee)).to eq(callee_result)
     end
   end
-  
+
   # DONT DO THIS...this is just a test to show what would happen
   context 'inheriting callbacks from base classes ' do
-    let!(:child1) {
+    let!(:child1) do
       Class.new(subject) do
-        before actions: [:child1] do |controller|
-          "before show child1"
+        before actions: [:child1] do |_controller|
+          'before show child1'
         end
       end
-    }
-    let!(:child2) {
+    end
+    let!(:child2) do
       Class.new(subject) do
-        before actions: [:child2] do |controller|
-          "before show child2"
+        before actions: [:child2] do |_controller|
+          'before show child2'
         end
       end
-    }
+    end
 
     describe '.before_callbacks (but same for after and around)' do
       context 'for child1 (and viceversa for child2)' do
-        let(:inherited_callbacks){ child1.before_callbacks }
-        it "will inherits not just the base callbacks, but child2 also!" do
+        let(:inherited_callbacks) { child1.before_callbacks }
+        it 'will inherits not just the base callbacks, but child2 also!' do
           expect(inherited_callbacks).to be_a(Hash)
-          expect(inherited_callbacks.keys).to eq([[:validate],[:action]])
+          expect(inherited_callbacks.keys).to eq([[:validate], [:action]])
           action_callbacks = inherited_callbacks[[:action]]
           expect(action_callbacks).to have(3).items
-          action_callback_options = action_callbacks.map{|options, block| options}
-          expect(action_callback_options).to eq([{:actions=>[:show]}, 
-                                                 {:actions=>[:child1]}, 
-                                                 {:actions=>[:child2]}])
+          action_callback_options = action_callbacks.map { |options, _block| options }
+          expect(action_callback_options).to eq([{ actions: [:show] },
+                                                 { actions: [:child1] },
+                                                 { actions: [:child2] }])
         end
       end
     end
-
   end
 end

data/spec/praxis/collection_spec.rb

@@ -1,10 +1,10 @@
-require "spec_helper"
+# frozen_string_literal: true
 
-describe Praxis::Collection do
+require 'spec_helper'
 
+describe Praxis::Collection do
   let(:member_type) { Volume }
 
-
   subject!(:collection) do
     Praxis::Collection.of(member_type)
   end
@@ -40,15 +40,14 @@ describe Praxis::Collection do
 
   context '.member_type' do
     subject(:collection) do
-      class Team < Praxis::Collection
+      Class.new(Praxis::Collection) do
         member_type Person
       end
-      Team
     end
-    its(:member_type){ should be(Person) }
-    its(:member_attribute){ should be_kind_of(Attributor::Attribute) }
-    its('member_attribute.type'){ should be(Person) }
-    its(:identifier) { should eq Person.identifier + "; type=collection" }
+    its(:member_type) { should be(Person) }
+    its(:member_attribute) { should be_kind_of(Attributor::Attribute) }
+    its('member_attribute.type') { should be(Person) }
+    its(:identifier) { should eq Person.identifier + '; type=collection' } # rubocop:disable Style/StringConcatenation
   end
 
   context '.load' do
@@ -60,15 +59,14 @@ describe Praxis::Collection do
       }
     end
 
-    let(:snapshots_data) {
+    let(:snapshots_data) do
       nil
-    }
-
+    end
 
     context 'loading an array' do
       let(:snapshots_data) do
-        [{id: 1, name: 'snapshot-1'},
-         {id: 2, name: 'snapshot-2'}]
+        [{ id: 1, name: 'snapshot-1' },
+         { id: 2, name: 'snapshot-2' }]
       end
 
       let(:volume) { Volume.load(volume_data) }
@@ -82,12 +80,9 @@ describe Praxis::Collection do
         expect(snapshots[1].id).to eq(2)
         expect(snapshots[1].name).to eq('snapshot-2')
       end
-
     end
   end
 
-
-
   context '#render' do
     context 'for members' do
       let(:example) { Volume.example('example-volume') }
@@ -110,15 +105,14 @@ describe Praxis::Collection do
       }
     end
 
-    let(:snapshots_data) {
+    let(:snapshots_data) do
       nil
-    }
-
+    end
 
     context 'for an array' do
       let(:snapshots_data) do
-        [{id: 1, name: 'snapshot-1'},
-         {id: 2, name: 'snapshot-2'}]
+        [{ id: 1, name: 'snapshot-1' },
+         { id: 2, name: 'snapshot-2' }]
       end
 
       let(:volume) { Volume.load(volume_data) }
@@ -130,8 +124,8 @@ describe Praxis::Collection do
 
       context 'with invalid members' do
         let(:snapshots_data) do
-          [{id: 1, name: 'invalid-1'},
-           {id: 2, name: 'snapshot-2'}]
+          [{ id: 1, name: 'invalid-1' },
+           { id: 2, name: 'snapshot-2' }]
         end
 
         it 'returns the error' do
@@ -141,5 +135,4 @@ describe Praxis::Collection do
       end
     end
   end
-
 end

data/spec/praxis/config_hash_spec.rb

@@ -1,5 +1,6 @@
 # frozen_string_literal: true
-require File.expand_path(File.dirname(__FILE__) + '/../spec_helper')
+
+require File.expand_path("#{File.dirname(__FILE__)}/../spec_helper")
 
 describe Praxis::ConfigHash do
   subject(:instance) { Praxis::ConfigHash.new(hash, &block) }
@@ -45,12 +46,12 @@ describe Praxis::ConfigHash do
     end
     context 'when keys already exist in the hash key' do
       it 'adds one value to the hash' do
-        subject.one'newval'
-        expect(subject.hash[:one]).to match_array(%w(existing newval))
+        subject.one 'newval'
+        expect(subject.hash[:one]).to match_array(%w[existing newval])
       end
       it 'adds multiple values to the hash key' do
         subject.one 'newval', 'other1', 'other2'
-        expect(subject.hash[:one]).to match_array(%w(existing newval other1 other2))
+        expect(subject.hash[:one]).to match_array(%w[existing newval other1 other2])
       end
       context 'when passing a value and a block' do
         let(:my_block) { proc {} }

data/spec/praxis/config_spec.rb

@@ -1,3 +1,5 @@
+# frozen_string_literal: true
+
 require 'spec_helper'
 
 describe Praxis::Config do
@@ -7,7 +9,7 @@ describe Praxis::Config do
 
   describe '#initialize' do
     it 'its type is a Struct type' do
-      expect( config.attribute.type < Attributor::Struct).to be(true)
+      expect(config.attribute.type < Attributor::Struct).to be(true)
     end
     it 'has no value' do
       expect(config.get.attributes).to eq({})
@@ -17,26 +19,26 @@ describe Praxis::Config do
   describe '#define' do
     context 'using a block' do
       context 'at the top level' do
-        let(:key) { nil}  
+        let(:key) { nil }
         before do
           config.define key do
             attribute :foo, String
           end
         end
-        
+
         it 'defines a Struct-type configuration under :foo' do
           expect(config.attribute.attributes.keys).to eq [:foo]
         end
-        
+
         context 'called again with new attributes' do
           before do
             config.define key do
               attribute :bar, String
             end
           end
-        
+
           it 'adds the additional attributes to the Struct under :bar' do
-            expect(config.attribute.attributes.keys).to eq [:foo, :bar]
+            expect(config.attribute.attributes.keys).to eq %i[foo bar]
           end
         end
       end
@@ -48,34 +50,33 @@ describe Praxis::Config do
           end
         end
         it 'when it does not exist, it creates a whole new subkey Struct containing one key' do
-           expect(config.attribute.attributes[:subkey].attributes.keys).to eq [:inside]
+          expect(config.attribute.attributes[:subkey].attributes.keys).to eq [:inside]
         end
         it 'when it already exists, will fail if it is of a different type' do
-          expect{
+          expect do
             config.define key, Attributor::Hash
-          }.to raise_error(/Incompatible type received for extending configuration key/)
+          end.to raise_error(/Incompatible type received for extending configuration key/)
         end
         it 'when it already exists, it add another subkey to the existing Struct' do
           config.define key do
-             attribute :inside2, String 
-           end
-          expect(config.attribute.attributes[:subkey].attributes.keys).to eq [:inside,:inside2]
+            attribute :inside2, String
+          end
+          expect(config.attribute.attributes[:subkey].attributes.keys).to eq %i[inside inside2]
         end
-
       end
     end
-    
+
     context 'using a direct type' do
-      let(:config_type){ Attributor::Hash.of(key:String) }
-      let(:config_opts){ {} }
-      let(:config_key){ :foo }
-      
+      let(:config_type) { Attributor::Hash.of(key: String) }
+      let(:config_opts) { {} }
+      let(:config_key) { :foo }
+
       it 'it is not allowed if its for the top key' do
-        expect{
+        expect  do
           config.define nil, config_type, **config_opts
-        }.to raise_error(/You cannot define the top level configuration with a non-Struct type/)
+        end.to raise_error(/You cannot define the top level configuration with a non-Struct type/)
       end
-      
+
       before do
         config.define config_key, config_type, **config_opts
       end
@@ -84,10 +85,10 @@ describe Praxis::Config do
         expect(config.attribute.attributes[config_key].type).to be(config_type)
       end
       it 'does not allow to redefine types that are not Structs' do
-        expect{ 
+        expect do
           config.define config_key, Attributor::Hash
-        }.to raise_error(Praxis::Exceptions::InvalidConfiguration,
-                         /Incompatible type received for extending configuration key/)
+        end.to raise_error(Praxis::Exceptions::InvalidConfiguration,
+                           /Incompatible type received for extending configuration key/)
       end
     end
   end
@@ -105,14 +106,14 @@ describe Praxis::Config do
       config.define do
         attribute :foo, String, required: true
       end
-      expect{ config.set({}) }.to raise_error(Praxis::Exceptions::ConfigValidation)
+      expect { config.set({}) }.to raise_error(Praxis::Exceptions::ConfigValidation)
     end
 
     it 'fails when config cannot be loaded' do
       config.define do
         attribute :foo, Integer, required: true
       end
-      expect{ config.set({foo: 'five'}) }.to raise_error(Praxis::Exceptions::ConfigLoad)
+      expect { config.set({ foo: 'five' }) }.to raise_error(Praxis::Exceptions::ConfigLoad)
     end
   end
 end

data/spec/praxis/controller_spec.rb

@@ -1,29 +1,29 @@
+# frozen_string_literal: true
+
 require 'spec_helper'
 
 describe Praxis::Controller do
   subject do
-    Class.new {
+    Class.new do
       include Praxis::Controller
 
       implements PeopleResource
 
       before :validate, actions: [:index] do
-        "before"
+        'before'
       end
 
       before actions: [:show] do
       end
 
       after :response, actions: [:show] do
-        "after"
+        'after'
       end
 
-      def index
-      end
+      def index; end
 
-      def show
-      end
-    }
+      def show; end
+    end
   end
 
   context '.implements' do
@@ -31,5 +31,4 @@ describe Praxis::Controller do
       expect(subject).to eq(PeopleResource.controller)
     end
   end
-
 end