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

data/spec/praxis/api_definition_spec.rb

@@ -1,17 +1,18 @@
+# frozen_string_literal: true
+
 require 'spec_helper'
 
 describe Praxis::ApiDefinition do
-
-  subject(:api){  Praxis::ApiDefinition.instance }
+  subject(:api) { Praxis::ApiDefinition.instance }
 
   # Without getting a fresh new ApiDefinition it is very difficult to test stuff using the Singleton
   # So for some tests we're gonna create a new instance and work with it to avoid the singleton issues
   let(:non_singleton_api) do
-    api_def=Praxis::ApiDefinition.__send__(:new)
+    api_def = Praxis::ApiDefinition.__send__(:new)
     api_def.instance_eval do |api|
-      api.response_template :template1, &Proc.new {}
-      api.trait :trait1, &Proc.new {}
-      api.trait :trait_2 do
+      api.response_template :template1, &proc {}
+      api.trait :trait1, &proc {}
+      api.trait :secondtrait do
         description 'the second testing trait'
       end
 
@@ -26,16 +27,16 @@ describe Praxis::ApiDefinition do
   end
 
   let(:info_block) do
-    Proc.new do
-      name "Name"
-      title "Title"
+    proc do
+      name 'Name'
+      title 'Title'
     end
   end
 
   context 'singleton' do
     it 'should be a Singleton' do
-      expect(Praxis::ApiDefinition.ancestors).to include( Singleton )
-      expect(subject).to eq(Praxis::ApiDefinition.instance )
+      expect(Praxis::ApiDefinition.ancestors).to include(Singleton)
+      expect(subject).to eq(Praxis::ApiDefinition.instance)
     end
 
     it 'has the :ok and :created response templates registered' do
@@ -44,10 +45,9 @@ describe Praxis::ApiDefinition do
     end
   end
 
-
   context '.response_template' do
-    let(:response_template){ Proc.new {} }
-    let(:api){ non_singleton_api }
+    let(:response_template) { proc {} }
+    let(:api) { non_singleton_api }
 
     it 'has the defined template1 response_template' do
       expect(api.responses.keys).to include(:template1)
@@ -61,7 +61,7 @@ describe Praxis::ApiDefinition do
   end
 
   context '.response' do
-    let(:api){ non_singleton_api }
+    let(:api) { non_singleton_api }
 
     it 'returns a registered response by name' do
       expect(api.response(:template1)).to be_kind_of(Praxis::ResponseTemplate)
@@ -69,9 +69,9 @@ describe Praxis::ApiDefinition do
   end
 
   context '.trait' do
-    let(:api){ non_singleton_api }
+    let(:api) { non_singleton_api }
 
-    let(:trait2){ Proc.new{} }
+    let(:trait2) { proc {} }
 
     it 'has the defined trait1 ' do
       expect(api.traits.keys).to include(:trait1)
@@ -80,19 +80,18 @@ describe Praxis::ApiDefinition do
 
     it 'complains trying to register traits with same name' do
       api.trait :trait2, &trait2
-      expect{
+      expect do
         api.trait :trait2, &trait2
-      }.to raise_error(Praxis::Exceptions::InvalidTrait, /Overwriting a previous trait with the same name/)
+      end.to raise_error(Praxis::Exceptions::InvalidTrait, /Overwriting a previous trait with the same name/)
     end
   end
 
   context '.info' do
-
-    let(:api){ non_singleton_api }
+    let(:api) { non_singleton_api }
     subject(:info) { api.info('1.0') }
 
     context '.base_path' do
-      its(:base_path) { should eq '/apps/:app_name'}
+      its(:base_path) { should eq '/apps/:app_name' }
     end
 
     context '.base_params' do
@@ -103,9 +102,9 @@ describe Praxis::ApiDefinition do
 
     context 'with a version' do
       it 'saves the data into the correct version hash' do
-        expect(api.infos.keys).to_not include("9.0")
-        api.info("9.0", &info_block)
-        expect(api.infos.keys).to include("9.0")
+        expect(api.infos.keys).to_not include('9.0')
+        api.info('9.0', &info_block)
+        expect(api.infos.keys).to include('9.0')
       end
     end
 
@@ -113,7 +112,7 @@ describe Praxis::ApiDefinition do
       it 'saves it into global_info' do
         expect(api.infos.keys).to_not include(nil)
         api.info do
-          description "Global Description"
+          description 'Global Description'
         end
         expect(api.infos.keys).to_not include(nil)
         expect(api.global_info.description).to eq 'Global Description'
@@ -122,10 +121,10 @@ describe Praxis::ApiDefinition do
   end
 
   context '.describe' do
-    subject(:output){ api.describe }
+    subject(:output) { api.describe }
 
     context 'using the spec_app definitions' do
-      subject(:version_output){ output["1.0"][:info] }
+      subject(:version_output) { output['1.0'][:info] }
 
       context 'for the global_info data' do
         subject(:info) { output[:global][:info] }
@@ -136,46 +135,45 @@ describe Praxis::ApiDefinition do
       end
 
       it 'outputs data for 1.0 info' do
-        expect(output.keys).to include("1.0")
-        expect(output["1.0"]).to include(:info)
+        expect(output.keys).to include('1.0')
+        expect(output['1.0']).to include(:info)
       end
 
       it 'describes 1.0 Api info properly' do
-        info = output["1.0"][:info]
+        info = output['1.0'][:info]
         expect(info).to include(:schema_version, :name, :title, :description, :base_path)
-        expect(info[:schema_version]).to eq("1.0")
-        expect(info[:name]).to eq("Spec App")
-        expect(info[:title]).to eq("A simple App to do some simple integration testing")
-        expect(info[:description]).to eq("A simple 1.0 App")
-        expect(info[:base_path]).to eq("/api")
+        expect(info[:schema_version]).to eq('1.0')
+        expect(info[:name]).to eq('Spec App')
+        expect(info[:title]).to eq('A simple App to do some simple integration testing')
+        expect(info[:description]).to eq('A simple 1.0 App')
+        expect(info[:base_path]).to eq('/api')
       end
     end
 
     context 'using a non-singleton object' do
-      let(:api){ non_singleton_api }
+      let(:api) { non_singleton_api }
 
       before do
-        api.info("9.0", &info_block)
+        api.info('9.0', &info_block)
         api.info do
-          description "Global Description"
+          description 'Global Description'
         end
       end
-      its(:keys) { should include("9.0") }
+      its(:keys) { should include('9.0') }
       its(:keys) { should include :traits }
-      its([:traits, :trait_2]) { should eq api.traits[:trait_2].describe }
+      its(%i[traits secondtrait]) { should eq api.traits[:secondtrait].describe }
 
       context 'for v9.0 info' do
-        subject(:v9_info){ output["9.0"][:info] }
+        subject(:v9_info) { output['9.0'][:info] }
 
         it 'has the info it was set in the call' do
-          expect(v9_info).to include({schema_version: "1.0"})
-          expect(v9_info).to include({name: "Name"})
-          expect(v9_info).to include({title: "Title"})
+          expect(v9_info).to include({ schema_version: '1.0' })
+          expect(v9_info).to include({ name: 'Name' })
+          expect(v9_info).to include({ title: 'Title' })
         end
         it 'inherited the description from the nil(global) one' do
-          expect(v9_info).to include({description: "Global Description"})
+          expect(v9_info).to include({ description: 'Global Description' })
         end
-
       end
     end
   end

data/spec/praxis/api_general_info_spec.rb

@@ -1,21 +1,21 @@
+# frozen_string_literal: true
+
 require 'spec_helper'
 
 describe Praxis::ApiGeneralInfo do
-
-  subject(:info){ Praxis::ApiGeneralInfo.new }
+  subject(:info) { Praxis::ApiGeneralInfo.new }
 
   before do
-    allow(Praxis::Application.instance).to receive(:versioning_scheme=).with([:header, :params])
+    allow(Praxis::Application.instance).to receive(:versioning_scheme=).with(%i[header params])
   end
 
-
   let(:info_block) do
-    Proc.new do
-      name "Name"
-      title "Title"
-      description "Description"
+    proc do
+      name 'Name'
+      title 'Title'
+      description 'Description'
       endpoint 'api.example.com'
-      base_path "/base"
+      base_path '/base'
 
       consumes 'json'
       produces 'json'
@@ -28,44 +28,44 @@ describe Praxis::ApiGeneralInfo do
 
   context 'setting' do
     it 'accepts the appropriate DSLs' do
-      expect{
-        info.instance_exec &info_block
-      }.to_not raise_error
+      expect do
+        info.instance_exec(&info_block)
+      end.to_not raise_error
     end
   end
 
   context 'getting values' do
     before do
-      info.instance_exec &info_block
+      info.instance_exec(&info_block)
     end
 
     its(:name) { should eq 'Name' }
-    its(:consumes) { should eq ['json']}
-    its(:produces) { should eq ['json']}
+    its(:consumes) { should eq ['json'] }
+    its(:produces) { should eq ['json'] }
   end
 
   context '.describe' do
     before do
-      info.instance_exec &info_block
+      info.instance_exec(&info_block)
     end
 
-    subject(:output){ info.describe }
-    its([:schema_version]) {should eq '1.0' }
-    its([:name]) {should eq 'Name' }
-    its([:title]) {should eq 'Title' }
-    its([:description]) {should eq 'Description' }
-    its([:base_path]) {should eq '/base' }
+    subject(:output) { info.describe }
+    its([:schema_version]) { should eq '1.0' }
+    its([:name]) { should eq 'Name' }
+    its([:title]) { should eq 'Title' }
+    its([:description]) { should eq 'Description' }
+    its([:base_path]) { should eq '/base' }
     its([:base_params]) { should have_key :name }
-    its([:base_params, :name, :type, :name]) { should eq 'String' }
-    its([:version_with]) { should eq([:header, :params]) }
+    its(%i[base_params name type name]) { should eq 'String' }
+    its([:version_with]) { should eq(%i[header params]) }
     its([:endpoint]) { should eq 'api.example.com' }
     its([:consumes]) { should eq ['json'] }
     its([:produces]) { should eq ['json'] }
   end
 
   context 'base_path with versioning' do
-    let(:global_info){ Praxis::ApiGeneralInfo.new }
-    subject(:info){ Praxis::ApiGeneralInfo.new(global_info, version: '1.0') }
+    let(:global_info) { Praxis::ApiGeneralInfo.new }
+    subject(:info) { Praxis::ApiGeneralInfo.new(global_info, version: '1.0') }
 
     before do
       global_info
@@ -74,9 +74,8 @@ describe Praxis::ApiGeneralInfo do
 
       global_info.version_with :path
       global_info.base_path '/api/v:api_version'
-    end    
+    end
 
-    its(:base_path) { should eq '/api/v1.0'}
+    its(:base_path) { should eq '/api/v1.0' }
   end
-
 end

data/spec/praxis/application_spec.rb

@@ -1,3 +1,5 @@
+# frozen_string_literal: true
+
 require 'spec_helper'
 
 describe Praxis::Application do
@@ -6,29 +8,31 @@ describe Praxis::Application do
       app = Class.new(Praxis::Application).instance
 
       config = Object.new
-      def config.define(key=nil, type=Attributor::Struct, **opts, &block)
-        return [key,type,opts,block]
+      def config.define(key = nil, type = Attributor::Struct, **opts, &block)
+        [key, type, opts, block]
       end
+
       def config.get
-        return 'gotconfig'
+        'gotconfig'
       end
+
       def config.set(config)
-        return config
+        config
       end
       app.instance_variable_set(:@config, config)
       app
     end
 
     describe '#config' do
-      let(:myblock){ lambda {} }
+      let(:myblock) { -> {} }
       it 'passes the block to config (and sets the right defaults)' do
         ret = app.config(&myblock)
-        expect(ret).to eq([nil,Attributor::Struct,{},myblock])
+        expect(ret).to eq([nil, Attributor::Struct, {}, myblock])
       end
 
       it 'passes the params and block to config' do
-        ret = app.config(:key, Attributor::Hash, **{option: :one}, &myblock)
-        expect(ret).to eq([:key, Attributor::Hash, {option: :one}, myblock])
+        ret = app.config(:key, Attributor::Hash, **{ option: :one }, &myblock)
+        expect(ret).to eq([:key, Attributor::Hash, { option: :one }, myblock])
       end
 
       it 'gets config with no block given' do
@@ -69,13 +73,13 @@ describe Praxis::Application do
 
       context 'given a non-Class' do
         it 'raises' do
-          expect {
+          expect do
             subject.handler('awesomesauce', 'hi') # no instances allowed
-          }.to raise_error(NoMethodError)
+          end.to raise_error(NoMethodError)
 
-          expect {
+          expect do
             subject.handler('awesomesauce', ::Kernel) # no modules allowed
-          }.to raise_error(NoMethodError)
+          end.to raise_error(NoMethodError)
         end
       end
 
@@ -86,9 +90,9 @@ describe Praxis::Application do
       end
 
       it 'ensures that handlers will work' do
-        expect {
+        expect do
           subject.handler new_handler_name, bad_handler_class
-        }.to raise_error(ArgumentError)
+        end.to raise_error(ArgumentError)
       end
     end
   end

data/spec/praxis/blueprint_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::Blueprint do
   subject(:blueprint_class) { PersonBlueprint }
@@ -8,11 +9,11 @@ describe Praxis::Blueprint do
 
   context 'deterministic examples' do
     it 'works' do
-      person_1 = PersonBlueprint.example('person 1')
-      person_2 = PersonBlueprint.example('person 1')
+      person1 = PersonBlueprint.example('person 1')
+      person2 = PersonBlueprint.example('person 1')
 
-      expect(person_1.name).to eq(person_2.name)
-      expect(person_1.address.name).to eq(person_2.address.name)
+      expect(person1.name).to eq(person2.name)
+      expect(person1.address.name).to eq(person2.address.name)
     end
   end
 
@@ -21,10 +22,10 @@ describe Praxis::Blueprint do
 
     it { should_not be(nil) }
     it 'contains all attributes' do
-      simple_attributes = [:id, :name, :street, :state]
+      simple_attributes = %i[id name street state]
       expect(default_fieldset.keys).to match_array(simple_attributes)
       # Should not have blueprint-derived attributes (or collections of them)
-      expect(default_fieldset.keys).to_not include( AddressBlueprint.attributes.keys - simple_attributes )
+      expect(default_fieldset.keys).to_not include(AddressBlueprint.attributes.keys - simple_attributes)
     end
   end
 
@@ -77,7 +78,6 @@ describe Praxis::Blueprint do
     expect(blueprint_class.attribute.type).to be blueprint_class::Struct
   end
 
-
   context 'an instance' do
     shared_examples 'a blueprint instance' do
       let(:expected_name) { blueprint_instance.name }
@@ -99,13 +99,12 @@ describe Praxis::Blueprint do
 
     context 'from Blueprint.example' do
       subject(:blueprint_instance) do
-        blueprint_class.example('ExamplePersonBlueprint', 
-          address: nil,
-          prior_addresses: [],
-          work_address: nil,
-          myself: nil,
-          friends: []
-        )
+        blueprint_class.example('ExamplePersonBlueprint',
+                                address: nil,
+                                prior_addresses: [],
+                                work_address: nil,
+                                myself: nil,
+                                friends: [])
       end
       it_behaves_like 'a blueprint instance'
     end
@@ -236,25 +235,25 @@ describe Praxis::Blueprint do
     let(:person) { PersonBlueprint.example('1') }
     it 'is an alias to dump' do
       person.object.contents
-      rendered = PersonBlueprint.render(person, fields: [:name, :full_name])
-      dumped = PersonBlueprint.dump(person, fields: [:name, :full_name])
+      rendered = PersonBlueprint.render(person, fields: %i[name full_name])
+      dumped = PersonBlueprint.dump(person, fields: %i[name full_name])
       expect(rendered).to eq(dumped)
     end
   end
 
   context '#render' do
     let(:person) { PersonBlueprint.example }
-    let(:fields) do 
+    let(:fields) do
       {
         name: true,
         full_name: true,
         address: {
           street: true,
-          state: true,
+          state: true
         },
         prior_addresses: {
           street: true,
-          state: true,
+          state: true
         }
       }
     end
@@ -262,15 +261,16 @@ describe Praxis::Blueprint do
     subject(:output) { person.render(fields: fields, **render_opts) }
 
     context 'without passing fields' do
-      it 'renders the default field set defined' do 
-        rendered = person.render( **render_opts)
+      it 'renders the default field set defined' do
+        rendered = person.render(**render_opts)
         default_top_fields = PersonBlueprint.default_fieldset.keys
         expect(rendered.keys).to match_array(default_top_fields)
-        expect(default_top_fields).to match_array([
-          :name,
-          :full_name,
-          :address,
-          :prior_addresses])
+        expect(default_top_fields).to match_array(%i[
+                                                    name
+                                                    full_name
+                                                    address
+                                                    prior_addresses
+                                                  ])
       end
     end
     context 'with a sub-attribute that is a blueprint' do
@@ -317,17 +317,16 @@ describe Praxis::Blueprint do
     end
 
     context 'using un-expanded fields for blueprints' do
-      let(:fields) do 
+      let(:fields) do
         {
           name: true,
-          address: true, # A blueprint!
+          address: true # A blueprint!
         }
       end
       it 'should still render the blueprint sub-attribute with its default fieldset' do
         address_default_top_fieldset = AddressBlueprint.default_fieldset.keys
         expect(output[:address].keys).to match(address_default_top_fieldset)
       end
-
     end
   end
 
@@ -346,7 +345,7 @@ describe Praxis::Blueprint do
 
   context 'FieldsetParser' do
     let(:definition_block) do
-      Proc.new do
+      proc do
         attribute :one
         attribute :two do
           attribute :sub_two
@@ -356,17 +355,17 @@ describe Praxis::Blueprint do
     subject { described_class::FieldsetParser.new(&definition_block) }
 
     it 'parses properly' do
-      expect(subject.fieldset).to eq(one: true, two: { sub_two: true} )
+      expect(subject.fieldset).to eq(one: true, two: { sub_two: true })
     end
 
     context 'with attribute parameters' do
       let(:definition_block) do
-        Proc.new do
+        proc do
           attribute :one, view: :other
         end
       end
       it 'complains and gives instructions if legacy view :default' do
-        expect{ subject.fieldset }.to raise_error(/Default fieldset definitions do not accept parameters/)
+        expect { subject.fieldset }.to raise_error(/Default fieldset definitions do not accept parameters/)
       end
     end
   end