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

data/spec/praxis/routing_config_spec.rb

@@ -1,22 +1,25 @@
+# frozen_string_literal: true
+
 require 'spec_helper'
 
 describe Praxis::RoutingConfig do
-
   let(:endpoint_definition) do
     Class.new do
       include Praxis::EndpointDefinition
-      def self.name; 'MyResource'; end
+      def self.name
+        'MyResource'
+      end
     end
   end
 
-  let(:routing_block) { Proc.new{} }
-  let(:base_path){ '' }
-  let(:default_route_prefix) { "/" + endpoint_definition.name.split("::").last.underscore }
+  let(:routing_block) { proc {} }
+  let(:base_path) { '' }
+  let(:default_route_prefix) { "/#{endpoint_definition.name.split('::').last.underscore}" }
 
-  subject(:routing_config){ Praxis::RoutingConfig.new(base: base_path, &routing_block) }
+  subject(:routing_config) { Praxis::RoutingConfig.new(base: base_path, &routing_block) }
 
   its(:version) { should eq('n/a') }
-  its(:prefix ) { should eq('') }
+  its(:prefix) { should eq('') }
 
   context '#prefix' do
     it 'sets the prefix' do
@@ -35,15 +38,14 @@ describe Praxis::RoutingConfig do
       routing_config.prefix '/people'
       expect(routing_config.prefix).to eq('/people')
     end
-
   end
 
   context '#add_route' do
     let(:path) { '/people' }
     let(:options) { {} }
-    let(:base_path){ '/api' }
-    let(:route) { routing_config.add_route 'GET', path, **options}
-    
+    let(:base_path) { '/api' }
+    let(:route) { routing_config.add_route 'GET', path, **options }
+
     it 'returns a corresponding Praxis::Route' do
       expect(route).to be_kind_of(Praxis::Route)
     end
@@ -53,11 +55,11 @@ describe Praxis::RoutingConfig do
     end
 
     context 'passing  options' do
-      let(:options){ { except: '/special' } }
+      let(:options) { { except: '/special' } }
 
       it 'passes them through the underlying mustermann object (telling it to ignore unknown ones)' do
         expect(Mustermann).to receive(:new).with(base_path + path, hash_including(ignore_unknown_options: true, except: '/special'))
-        expect(route.options).to eq( { except: '/special' })
+        expect(route.options).to eq({ except: '/special' })
       end
     end
 
@@ -82,5 +84,4 @@ describe Praxis::RoutingConfig do
       end
     end
   end
-
 end

data/spec/praxis/stage_spec.rb

@@ -1,106 +1,109 @@
+# frozen_string_literal: true
+
 require 'spec_helper'
 
 describe Praxis::Stage do
-  subject(:stage) {Praxis::Stage.new("name","context")}
+  subject(:stage) { Praxis::Stage.new('name', 'context') }
 
-  context "attributes" do
-    its(:name) {should eq("name")}
-    its(:context) {should eq("context")}
-    its(:stages) {should eq([])}
-    its(:before_callbacks) {should eq([])}
-    its(:after_callbacks) {should eq([])}
+  context 'attributes' do
+    its(:name) { should eq('name') }
+    its(:context) { should eq('context') }
+    its(:stages) { should eq([]) }
+    its(:before_callbacks) { should eq([]) }
+    its(:after_callbacks) { should eq([]) }
   end
 
-  context ".run" do
-    it "sets up and execute callbacks" do
+  context '.run' do
+    it 'sets up and execute callbacks' do
       expect(stage).to receive('execute')
       expect(stage).to receive('execute_callbacks').twice
       stage.run
     end
   end
 
-  context ".setup!" do
+  context '.setup!' do
     it 'should call setup_deferred_callbacks' do
       expect(stage).to receive('setup_deferred_callbacks!')
       stage.setup!
     end
   end
 
-  context ".setup_deferred_callbacks!" do
-    it "calls .before and .after for each stage name in @deferred_callbacks" do
+  context '.setup_deferred_callbacks!' do
+    it 'calls .before and .after for each stage name in @deferred_callbacks' do
       deferred_callbacks = {
-        "stage" => {
-          :before => [["before",nil]],
-          :after  => [["after",nil]]
-        }}
-      stage.instance_variable_set("@deferred_callbacks", deferred_callbacks)
-      expect(stage).to receive("before")
-      expect(stage).to receive("after")
+        'stage' => {
+          before: [['before', nil]],
+          after: [['after', nil]]
+        }
+      }
+      stage.instance_variable_set('@deferred_callbacks', deferred_callbacks)
+      expect(stage).to receive('before')
+      expect(stage).to receive('after')
       stage.setup_deferred_callbacks!
     end
   end
 
-  context ".execute" do
-    it "runs all the stages" do
-      double_stage = double("stage")
+  context '.execute' do
+    it 'runs all the stages' do
+      double_stage = double('stage')
       expect(double_stage).to receive('run')
-      stage.instance_variable_set("@stages", [double_stage])
+      stage.instance_variable_set('@stages', [double_stage])
       stage.execute
     end
   end
 
-  context ".execute_callbacks" do
-    let(:callback) {double('callback')}
-    it "executes every callback" do
-      expect(callback).to receive("call")
+  context '.execute_callbacks' do
+    let(:callback) { double('callback') }
+    it 'executes every callback' do
+      expect(callback).to receive('call')
       stage.execute_callbacks([callback])
     end
   end
 
-  context ".callback_args" do
-    # TODO should this method return something else than nil?
-    it "returns nil" do
+  context '.callback_args' do
+    # TODO: should this method return something else than nil?
+    it 'returns nil' do
       expect(stage.callback_args).to be(nil)
     end
   end
 
-  context ".before" do
-    it "adds block to @before_callbacks when stage_path is not provided" do
-      stage.before {1}
+  context '.before' do
+    it 'adds block to @before_callbacks when stage_path is not provided' do
+      stage.before { 1 }
       expect(stage.before_callbacks.last.call).to be(1)
     end
 
-    it "calls .before for the name matched stage" do
-      double_stage = double("stage", name: "name")
+    it 'calls .before for the name matched stage' do
+      double_stage = double('stage', name: 'name')
       expect(double_stage).to receive('before')
-      stage.instance_variable_set("@stages", [double_stage])
-      stage.before("name")
+      stage.instance_variable_set('@stages', [double_stage])
+      stage.before('name')
     end
 
-    it "adds to deferred_callbacks if no state name matched" do
-      double_stage = double("stage", name: "name")
-      stage.instance_variable_set("@stages", [double_stage])
-      expect(stage.before("hello", "world")).to eq([["world",nil]])
+    it 'adds to deferred_callbacks if no state name matched' do
+      double_stage = double('stage', name: 'name')
+      stage.instance_variable_set('@stages', [double_stage])
+      expect(stage.before('hello', 'world')).to eq([['world', nil]])
     end
   end
 
-  context ".after" do
-    it "adds block to @after_callbacks when stage_path is not provided" do
-      stage.after {1}
+  context '.after' do
+    it 'adds block to @after_callbacks when stage_path is not provided' do
+      stage.after { 1 }
       expect(stage.after_callbacks.last.call).to be(1)
     end
 
-    it "calls .after for the name matched stage" do
-      double_stage = double("stage", name: "name")
-      expect(double_stage).to receive("after")
-      stage.instance_variable_set("@stages", [double_stage])
-      stage.after("name")
+    it 'calls .after for the name matched stage' do
+      double_stage = double('stage', name: 'name')
+      expect(double_stage).to receive('after')
+      stage.instance_variable_set('@stages', [double_stage])
+      stage.after('name')
     end
 
-    it "adds to deferred_callbacks if no state name matched" do
-      double_stage = double("stage", name: "name")
-      stage.instance_variable_set("@stages", [double_stage])
-      expect(stage.after("hello", "world")).to eq([["world",nil]])
+    it 'adds to deferred_callbacks if no state name matched' do
+      double_stage = double('stage', name: 'name')
+      stage.instance_variable_set('@stages', [double_stage])
+      expect(stage.after('hello', 'world')).to eq([['world', nil]])
     end
   end
 end

data/spec/praxis/trait_spec.rb

@@ -1,7 +1,8 @@
-require File.expand_path(File.dirname(__FILE__) + '/../spec_helper')
+# frozen_string_literal: true
 
-describe Praxis::Trait do
+require File.expand_path("#{File.dirname(__FILE__)}/../spec_helper")
 
+describe Praxis::Trait do
   subject(:trait) do
     Praxis::Trait.new do
       description 'my awesome trait'
@@ -19,14 +20,13 @@ describe Praxis::Trait do
       end
       params do
         attribute :order, String,
-          description: "Field to sort by."
+                  description: 'Field to sort by.'
       end
 
       headers do
-        header "Authorization"
-        key "Header2", String, required: true, null: false
+        header 'Authorization'
+        key 'Header2', String, required: true, null: false
       end
-
     end
   end
 
@@ -35,25 +35,24 @@ describe Praxis::Trait do
 
     its([:description]) { should eq('my awesome trait') }
 
-    its([:responses, :something]) { should eq Hash.new }
-    its([:responses, :nothing]) { should eq Hash.new }
+    its(%i[responses something]) { should eq({}) }
+    its(%i[responses nothing]) { should eq({}) }
 
-    its([:params, :app_name, :type, :name]) { should eq 'String' }
-    its([:params, :order, :type, :name]) { should eq 'String' }
-    its([:routing, :prefix]) { should eq '/:app_name'}
+    its(%i[params app_name type name]) { should eq 'String' }
+    its(%i[params order type name]) { should eq 'String' }
+    its(%i[routing prefix]) { should eq '/:app_name' }
 
-    its([:headers, "Header2"]) { should include({required: true, null: false}) }
+    its([:headers, 'Header2']) { should include({ required: true, null: false }) }
     context 'using the special DSL syntax for headers' do
-      subject(:dsl_header) { describe[:headers]["Authorization"] }
-      its([:required]){ should be(true) }
-      its([:null]){ should be_nil }
-      its([:type]){ should eq( { :id=>"Attributor-String", :name=>"String", :family=>"string"} )}
+      subject(:dsl_header) { describe[:headers]['Authorization'] }
+      its([:required]) { should be(true) }
+      its([:null]) { should be_nil }
+      its([:type]) { should eq({ id: 'Attributor-String', name: 'String', family: 'string' }) }
     end
-
   end
 
   context 'apply!' do
-    let(:target) { double("Target") }
+    let(:target) { double('Target') }
     it 'does' do
       expect(target).to receive(:routing).once
       expect(target).to receive(:response).twice

data/spec/praxis/types/fuzzy_hash_spec.rb

@@ -1,20 +1,22 @@
-require "spec_helper"
+# frozen_string_literal: true
 
-describe Praxis::Types::FuzzyHash do
+require 'spec_helper'
 
-  let(:initial_value) {{
-    'key' => 'value',
-    /bob/ => 'rob',
-    /\d+/ => 'one'
-  }}
+describe Praxis::Types::FuzzyHash do
+  let(:initial_value) do
+    {
+      'key' => 'value',
+      /bob/ => 'rob',
+      /\d+/ => 'one'
+    }
+  end
 
   subject(:hash) { Praxis::Types::FuzzyHash.new(initial_value) }
 
   its(['key']) { should eq 'value' }
   its([/bob/]) { should eq 'rob' }
   its(['bobby']) { should eq 'rob' }
-  
+
   its([1]) { should eq 'one' }
   its(['1']) { should eq 'one' }
 end
-

data/spec/praxis/types/multipart_array/part_definition_spec.rb

@@ -1,5 +1,6 @@
-require "spec_helper"
+# frozen_string_literal: true
+
+require 'spec_helper'
 
 describe Praxis::Types::MultipartArray::PartDefinition do
 end
-

data/spec/praxis/types/multipart_array_spec.rb

@@ -1,15 +1,16 @@
-require "spec_helper"
+# frozen_string_literal: true
 
-describe Praxis::Types::MultipartArray do
+require 'spec_helper'
 
+describe Praxis::Types::MultipartArray do
   let(:type) do
     Class.new(Praxis::Types::MultipartArray) do
-      self.options[:case_insensitive_load] = true
+      options[:case_insensitive_load] = true
 
       part 'title', String, required: true
       part(/nam/, String, regexp: /Bob/i)
 
-      part /stuff/ do
+      part(/stuff/) do
         payload Hash
       end
 
@@ -22,33 +23,31 @@ describe Praxis::Types::MultipartArray do
       file 'thumbnail', Attributor::Tempfile
 
       part 'image', Attributor::Tempfile, filename: true
-
     end
   end
 
-
   let(:form) do
     form_data = MIME::Multipart::FormData.new
     entity = MIME::Text.new('Bob')
-    form_data.add entity,'name'
+    form_data.add entity, 'name'
 
     entity = MIME::Text.new('Captain')
-    form_data.add entity,'title'
+    form_data.add entity, 'title'
 
     entity = MIME::Application.new('file1')
-    form_data.add entity,'files', 'file1'
+    form_data.add entity, 'files', 'file1'
 
     entity = MIME::Application.new('file2')
-    form_data.add entity,'files', 'file2'
+    form_data.add entity, 'files', 'file2'
 
     entity = MIME::Application.new('{"first_name": "Frank"}', 'json')
-    form_data.add entity,'stuff2'
+    form_data.add entity, 'stuff2'
 
     entity = MIME::Application.new('SOMEBINARYDATA', 'jpg')
-    form_data.add entity,'thumbnail', 'thumb.jpg'
+    form_data.add entity, 'thumbnail', 'thumb.jpg'
 
     entity = MIME::Application.new('', 'jpg')
-    form_data.add entity,'image', 'image.jpg'
+    form_data.add entity, 'image', 'image.jpg'
 
     form_data
   end
@@ -59,7 +58,6 @@ describe Praxis::Types::MultipartArray do
   subject(:payload) { type.load(body, content_type: content_type) }
 
   it 'validates' do
-    part = payload.part('files').first
     expect(payload.validate).to be_empty
   end
 
@@ -94,9 +92,9 @@ describe Praxis::Types::MultipartArray do
       end
     end
 
-    let(:json_payload) { {sub_hash: {key:'value'}}.to_json }
+    let(:json_payload) { { sub_hash: { key: 'value' } }.to_json }
     let(:body) { StringIO.new("--boundary\r\nContent-Disposition: form-data; name=blah\r\n\r\n#{json_payload}\r\n--boundary--") }
-    let(:content_type) { "multipart/form-data; boundary=boundary" }
+    let(:content_type) { 'multipart/form-data; boundary=boundary' }
 
     it do
       expect(payload.part('blah').payload['sub_hash']).to eq('key' => 'value')
@@ -117,9 +115,9 @@ describe Praxis::Types::MultipartArray do
       end
     end
 
-    let(:json_payload) { {attr: 'value'}.to_json }
+    let(:json_payload) { { attr: 'value' }.to_json }
     let(:body) { StringIO.new("--boundary\r\nContent-Disposition: form-data; name=blah\r\n\r\n#{json_payload}\r\n--boundary--") }
-    let(:content_type) { "multipart/form-data; boundary=boundary" }
+    let(:content_type) { 'multipart/form-data; boundary=boundary' }
 
     it do
       expect(payload.part('blah').payload.class.ancestors).to include(Attributor::Struct)
@@ -142,7 +140,7 @@ describe Praxis::Types::MultipartArray do
 
     context 'attributes' do
       subject(:attributes) { description[:attributes] }
-      its(:keys) { should match_array ['title', 'files', 'thumbnail', 'image']}
+      its(:keys) { should match_array %w[title files thumbnail image] }
 
       context 'the "title" part' do
         subject(:title_description) { attributes['title'] }
@@ -172,14 +170,12 @@ describe Praxis::Types::MultipartArray do
           expect(filename[:options]).to eq(regexp: /file/)
           expect(filename[:type]).to eq Attributor::String.describe
         end
-
       end
-
     end
 
     context 'pattern attributes' do
       subject(:pattern_attributes) { description[:pattern_attributes] }
-      its(:keys) { should match_array ['nam', 'stuff']}
+      its(:keys) { should match_array %w[nam stuff] }
     end
 
     context 'with no parts defined' do
@@ -226,17 +222,16 @@ describe Praxis::Types::MultipartArray do
     subject(:dumped) { payload.dump }
 
     it 'dumps' do
-      loaded = type.load(dumped, content_type: payload.content_type)
+      type.load(dumped, content_type: payload.content_type)
     end
     context 'an example' do
       let(:payload) { type.example }
 
       it 'dumps' do
-        loaded = type.load(dumped, content_type: payload.content_type)
+        type.load(dumped, content_type: payload.content_type)
       end
     end
 
-
     context 'with default_format' do
       let(:type) do
         Class.new(Praxis::Types::MultipartArray) do
@@ -267,7 +262,7 @@ describe Praxis::Types::MultipartArray do
 
       let(:output) { example.dump(default_format: default_format) }
 
-      let(:parts) { Praxis::MultipartParser.parse({'Content-Type'=>example.content_type}, output).last }
+      let(:parts) { Praxis::MultipartParser.parse({ 'Content-Type' => example.content_type }, output).last }
 
       it 'dumps the parts with the proper handler' do
         json_handler = Praxis::Application.instance.handlers['json']
@@ -290,9 +285,7 @@ describe Praxis::Types::MultipartArray do
           expect(instance.payload).to eq json_handler.generate(example.part('instances')[i].payload.dump)
         end
       end
-
     end
-
   end
 
   context 'with errors' do
@@ -300,11 +293,10 @@ describe Praxis::Types::MultipartArray do
       form_data = MIME::Multipart::FormData.new
 
       entity = MIME::Text.new('James')
-      form_data.add entity,'name'
-
+      form_data.add entity, 'name'
 
       entity = MIME::Text.new('file1')
-      form_data.add entity,'files', 'file1'
+      form_data.add entity, 'files', 'file1'
 
       form_data
     end
@@ -314,10 +306,10 @@ describe Praxis::Types::MultipartArray do
     it 'validates part headers' do
       expect(errors).to have(3).items
       expect(errors).to match_array([
-                                      %r|\.name\.payload value .* does not match regexp|,
-                                      %r|\.files\.headers.* is not within the allowed values|,
-                                      %r|\.title is required|
-      ])
+                                      /\.name\.payload value .* does not match regexp/,
+                                      /\.files\.headers.* is not within the allowed values/,
+                                      /\.title is required/
+                                    ])
     end
   end
 
@@ -327,14 +319,14 @@ describe Praxis::Types::MultipartArray do
     it 'generates parts' do
       title = payload.part('title')
       expect(title).to_not be_nil
-      expect(title.payload).to match /\w+/
+      expect(title.payload).to match(/\w+/)
 
       files = payload.part('files')
       expect(files).to have(2).items
 
       files.each do |file|
         expect(file.payload).to be_kind_of(Tempfile)
-        expect(file.filename).to match /\w+/
+        expect(file.filename).to match(/\w+/)
 
         expect(file.headers['Content-Type']).to eq 'application/octet-stream'
       end
@@ -343,15 +335,14 @@ describe Praxis::Types::MultipartArray do
     it 'is valid' do
       expect(payload.validate).to have(0).items
     end
-
   end
 
   context 'with a hackish default part definition' do
     let(:type) do
       Class.new(Praxis::Types::MultipartArray) do
-        self.options[:case_insensitive_load] = true
+        options[:case_insensitive_load] = true
 
-        part /\d+/, Instance
+        part(/\d+/, Instance)
       end
     end
 
@@ -362,7 +353,7 @@ describe Praxis::Types::MultipartArray do
         instance = Instance.example("instance-#{i}")
         body = JSON.pretty_generate(instance.render)
         entity = MIME::Text.new(body)
-        form_data.add entity,i.to_s
+        form_data.add entity, i.to_s
       end
 
       form_data
@@ -373,10 +364,8 @@ describe Praxis::Types::MultipartArray do
         expect(part.payload).to be_kind_of(Instance)
       end
     end
-
   end
 
-
   context 'anonymous generation' do
     let(:definition_block) do
       proc do
@@ -396,7 +385,7 @@ describe Praxis::Types::MultipartArray do
         instance = Instance.example("instance-#{i}")
         body = JSON.pretty_generate(instance.render)
         entity = MIME::Text.new(body)
-        form_data.add entity,i.to_s
+        form_data.add entity, i.to_s
       end
 
       form_data
@@ -411,9 +400,5 @@ describe Praxis::Types::MultipartArray do
         expect(part.payload).to be_kind_of(Instance)
       end
     end
-
-
   end
-
-
 end

data/spec/spec_app/app/concerns/authenticated.rb

@@ -1,15 +1,15 @@
+# frozen_string_literal: true
+
 module Concerns
   module Authenticated
     extend ActiveSupport::Concern
     include Praxis::Callbacks
-    
+
     included do
       before :action do |controller|
         auth_data = controller.request.headers['Authorization']
-        if auth_data && auth_data !~ /secret/ 
-          Praxis::Responses::Unauthorized.new(body: 'Authentication info is invalid')
-        end
+        Praxis::Responses::Unauthorized.new(body: 'Authentication info is invalid') if auth_data && auth_data !~ /secret/
       end
     end
   end
-end
+end

data/spec/spec_app/app/concerns/basic_api.rb

@@ -1,3 +1,5 @@
+# frozen_string_literal: true
+
 require_relative 'authenticated'
 require_relative 'log_wrapper'
 
@@ -9,4 +11,4 @@ module Concerns
     include Concerns::Authenticated
     include Concerns::LogWrapper
   end
-end
+end

data/spec/spec_app/app/concerns/log_wrapper.rb

@@ -1,14 +1,16 @@
+# frozen_string_literal: true
+
 module Concerns
   module LogWrapper
     extend ActiveSupport::Concern
     include Praxis::Callbacks
-    
+
     included do
-      before :around do |controller, callee|
+      before :around do |_controller, callee|
         # Log something at the beginning
         callee.call
         # Log something at the end
       end
     end
   end
-end
+end