praxis 2.0.pre.13 → 2.0.pre.17

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

@@ -29,7 +29,14 @@ describe Praxis::Extensions::AttributeFiltering::FilteringParams do
           { name: :two, op: '>', value: 'normal'},
         ]
         expect(described_class.load(str).parsed_array.map{|i| i.slice(:name,:op,:value)}).to eq(parsed)
-    end
+      end
+      it 'does not handle badly escaped values that contain reserved chars ()|&,' do
+        badly_escaped = 'val('
+        str = "one=#{badly_escaped}&(two>normal|three!)"
+        expect{
+          described_class.load(str)
+        }.to raise_error(Parslet::ParseFailed)
+      end
     end
     context 'parses for operator' do
       described_class::VALUE_OPERATORS.each do |op|
@@ -154,9 +161,9 @@ describe Praxis::Extensions::AttributeFiltering::FilteringParams do
       # 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 'id', using: ['=', '!=', '!']
         filter 'title', using: ['=', '!='], fuzzy: true
-        filter 'content', using: ['=', '!=']
+        filter 'content', using: ['=', '!=', '!']
       end.type
     end
     let(:loaded_params) { filtering_params_type.load(filters_string) }
@@ -187,6 +194,21 @@ describe Praxis::Extensions::AttributeFiltering::FilteringParams do
         end
       end
     end
+
+    context 'non-valued operators' do
+      context 'for string typed fields' do
+        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!'}
+        it 'validates properly' do
+          expect(subject).to be_empty
+        end
+      end
+    end
     context 'fuzzy matches' do
       context 'when allowed' do
         context 'given a fuzzy string' do

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

@@ -1,6 +1,5 @@
 require 'praxis/extensions/attribute_filtering/filters_parser'
 
-
 describe Praxis::Extensions::AttributeFiltering::FilteringParams::Condition do
 end 
 
@@ -121,17 +120,26 @@ describe Praxis::Extensions::AttributeFiltering::FilteringParams::Parser do
     context 'supports everything (except &|(),) for values (even without encoding..not allowed, but just to ensure the parser does not bomb)' do
       it_behaves_like 'round-trip-properly', {
         'v=1123' => 'v=1123',
-        'v=*foo*' => 'v=*foo*',
-        'v=*^%$#@!foo' => 'v=*^%$#@!foo',
+        'v=*foo*' => 'v={*}foo{*}',
+        'v=*^%$#@!foo' => 'v={*}^%$#@!foo',
         'v=_-=\{}"?:><' => 'v=_-=\{}"?:><',
         'v=_-=\{}"?:><,another_value!' => 'v=[_-=\{}"?:><,another_value!]',
       }
     end
+    context 'properly detects and handles fuzzy matching encoded as {*} in the dump' do
+      it_behaves_like 'round-trip-properly', {
+        'v=*foo' => 'v={*}foo',
+        '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
+      }
+    end
     context 'properly handles url-encoded values' do
       it_behaves_like 'round-trip-properly', {
         "v=#{CGI.escape('1123')}" => 'v=1123',
-        "v=#{CGI.escape('*foo*')}" => 'v=*foo*',
-        "v=#{CGI.escape('*^%$#@!foo')}" => 'v=*^%$#@!foo',
+        "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!]',
       }

data/spec/praxis/extensions/support/spec_resources_active_model.rb

@@ -120,6 +120,8 @@ class ActiveBookResource < ActiveBaseResource
     'category.books.name': 'category.books.simple_name',
     'category.books.taggings.tag_id': 'category.books.taggings.tag_id',
     'category.books.taggings.label': 'category.books.taggings.label',
+    'primary_tags': 'primary_tags',
+    'category.books.taggings': 'category.books.taggings',
   )
   # Forces to add an extra column (added_column)...and yet another (author_id) that will serve
   # to check that if that's already automatically added due to an association, it won't interfere or duplicate

data/spec/praxis/mapper/resource_spec.rb

@@ -14,15 +14,15 @@ describe Praxis::Mapper::Resource do
       subject(:properties) { resource.properties }
 
       it 'includes directly-set properties' do
-        expect(properties[:other_resource]).to eq(dependencies: [:other_model])
+        expect(properties[:other_resource]).to eq(dependencies: [:other_model], through: nil)
       end
 
       it 'inherits from a superclass' do
-        expect(properties[:href]).to eq(dependencies: [:id])
+        expect(properties[:href]).to eq(dependencies: [:id], through: nil)
       end
 
       it 'properly overrides a property from the parent' do
-        expect(properties[:name]).to eq(dependencies: [:simple_name])
+        expect(properties[:name]).to eq(dependencies: [:simple_name], through: nil)
       end
     end
   end

data/spec/praxis/media_type_identifier_spec.rb

@@ -218,7 +218,21 @@ describe Praxis::MediaTypeIdentifier do
 
     it 'replaces suffix and parameters and adds new ones' do
       expect(complex_subject + 'json; nuts=false; cherry=true').to \
-      eq(described_class.new('application/vnd.icecream+json; cherry=true; nuts=false'))
+        eq(described_class.new('application/vnd.icecream+json; cherry=true; nuts=false'))
+    end
+
+    context 'does not add json for an already json identifier' do
+      it 'non-parameterized mediatypes simply ignore adding the suffix' do
+        plain_application_json = described_class.new('application/json')
+
+        expect(plain_application_json + 'json').to \
+          eq(plain_application_json)
+      end
+      it 'parameterized mediatypes still keeps them' do
+        parameterized_application_json = described_class.new('application/json; cherry=true; nuts=false')
+        expect(parameterized_application_json + 'json').to \
+          eq(parameterized_application_json)
+      end
     end
   end
 end

data/spec/praxis/response_definition_spec.rb

@@ -8,7 +8,8 @@ describe Praxis::ResponseDefinition do
     Proc.new do
       status 200
       description 'test description'
-      headers({ "X-Header" => "value", "Content-Type" => "application/some-type" })
+      header( "X-Header", "value", description: 'Very nais header')
+      header( "Content-Type", "application/some-type" )
     end
   end
 
@@ -17,7 +18,7 @@ describe Praxis::ResponseDefinition do
   its(:parts) { should be(nil) }
   let(:response_status) { 200 }
   let(:response_content_type) { "application/some-type" }
-  let(:response_headers) { { "X-Header" => "value", "Content-Type" => response_content_type} }
+  let(:response_headers) { { "X-Header" => "value", "Content-Type" => response_content_type, "Location" => '/somewhere/over/the/rainbow'} }
 
   let(:response) { instance_double("Praxis::Response", status: response_status , headers: response_headers, content_type: response_content_type ) }
 
@@ -105,29 +106,6 @@ describe Praxis::ResponseDefinition do
     end
   end
 
-  context '#headers' do
-    it 'accepts a Hash' do
-      response_definition.headers Hash["X-Header" => "value", "Content-Type" => "application/some-type"]
-      expect(response_definition.headers).to be_a(Hash)
-    end
-
-    it 'accepts an Array' do
-      response_definition.headers ["X-Header: value", "Content-Type: application/some-type"]
-      expect(response_definition.headers).to be_a(Hash)
-      expect(response_definition.headers.keys).to include("X-Header: value", "Content-Type: application/some-type")
-    end
-
-    it 'accepts a String' do
-      response_definition.headers "X-Header: value"
-      expect(response_definition.headers).to be_a(Hash)
-      expect(response_definition.headers.keys).to include("X-Header: value")
-    end
-
-    it 'should return an error when headers are not a Hash, Array or String object' do
-      expect{ response_definition.headers Object.new }. to raise_error(Praxis::Exceptions::InvalidConfiguration)
-    end
-  end
-
   context '#parts' do
     context 'with a :like argument (and no block)' do
       before do
@@ -242,7 +220,6 @@ describe Praxis::ResponseDefinition do
 
       it "calls all the validation sub-functions" do
         expect(response_definition).to receive(:validate_status!).once
-        expect(response_definition).to receive(:validate_location!).once
         expect(response_definition).to receive(:validate_headers!).once
         expect(response_definition).to receive(:validate_content_type!).once
         response_definition.validate(response)
@@ -272,112 +249,39 @@ describe Praxis::ResponseDefinition do
 
       end
 
-      describe "#validate_location!" do
-        let(:block) { proc { status 200 } }
-
-        context 'checking location mismatches' do
-          before { response_definition.location(location) }
-
-          context 'for Regexp' do
-            let(:location) { /no_match/ }
-
-            it 'should raise an error' do
-              expect {
-                response_definition.validate_location!(response)
-              }.to raise_error(Praxis::Exceptions::Validation)
-            end
-          end
-
-          context 'for String' do
-            let(:location) { "no_match" }
-            it 'should raise error' do
-              expect {
-                response_definition.validate_location!(response)
-              }.to raise_error(Praxis::Exceptions::Validation)
-            end
+      describe "#validate_headers!" do
+        context 'when there are missing headers' do
+          it 'should raise error' do
+            response_definition.header('X-Unknown', 'test')
+            expect {
+              response_definition.validate_headers!(response)
+            }.to raise_error(Praxis::Exceptions::Validation)
           end
-
         end
-      end
-
-      describe "#validate_headers!" do
-        before { response_definition.headers(headers) }
-        context 'checking headers are set' do
-          context 'when there are missing headers' do
-            let (:headers) { { 'X-some' => 'test' } }
-            it 'should raise error' do
-              expect {
-                response_definition.validate_headers!(response)
-              }.to raise_error(Praxis::Exceptions::Validation)
-            end
+        context 'when headers with same names are returned' do
+          it 'a simply required header should not raise error just by being there' do
+            response_definition.header('X-Header', nil)
+            expect {
+              response_definition.validate_headers!(response)
+            }.to_not raise_error
           end
-
-          context "when headers specs are name strings" do
-            context "and is missing" do
-              let (:headers) { [ "X-Just-Key" ] }
-              it 'should raise error' do
-                expect {
-                  response_definition.validate_headers!(response)
-                }.to raise_error(Praxis::Exceptions::Validation)
-              end
-            end
-
-            context "and is not missing" do
-              let (:headers) { [ "X-Header" ] }
-              it 'should not raise error' do
-                expect {
-                  response_definition.validate_headers!(response)
-                }.not_to raise_error
-              end
-            end
+          it 'an exact string header should not raise error if it fully matches' do
+            response_definition.header('X-Header', 'value')
+            expect {
+              response_definition.validate_headers!(response)
+            }.to_not raise_error
           end
-
-          context "when header specs are hashes" do
-            context "and is missing" do
-              let (:headers) {
-                [ { "X-Just-Key" => "notfoodbar" } ]
-              }
-              it 'should raise error' do
-                expect {
-                  response_definition.validate_headers!(response)
-                }.to raise_error(Praxis::Exceptions::Validation)
-              end
-            end
-
-            context "and is not missing" do
-              let (:headers) {
-                [ { "X-Header" => "value" } ]
-              }
-              it 'should not raise error' do
-                expect {
-                  response_definition.validate_headers!(response)
-                }.not_to raise_error
-              end
-            end
+          it 'a regexp header should not raise error if it matches the regexp' do
+            response_definition.header('X-Header', /value/)
+            expect {
+              response_definition.validate_headers!(response)
+            }.to_not raise_error
           end
-
-          context "when header specs are of mixed type " do
-            context "and is missing" do
-              let (:headers) {
-                [ { "X-Header" => "value" }, "not-gonna-find-me" ]
-              }
-              it 'should raise error' do
-                expect {
-                  response_definition.validate_headers!(response)
-                }.to raise_error(Praxis::Exceptions::Validation)
-              end
-            end
-
-            context "and is not missing" do
-              let (:headers) {
-                [ { "X-Header" => "value" }, "Content-Type" ]
-              }
-              it 'should not raise error' do
-                expect {
-                  response_definition.validate_headers!(response)
-                }.not_to raise_error
-              end
-            end
+          it 'a regexp header should raise error if it does not match the regexp' do
+            response_definition.header('X-Header', /anotherthing/)
+            expect {
+              response_definition.validate_headers!(response)
+            }.to raise_error(Praxis::Exceptions::Validation)
           end
         end
       end
@@ -478,7 +382,10 @@ describe Praxis::ResponseDefinition do
       if parts || parts_block
         parts ? response.parts(nil, **parts, &parts_block) : response.parts(nil, &parts_block) 
       end
-      response.headers(headers) if headers
+
+      headers&.each do |(name, value)|
+        response.header(name, value)
+      end
     end
 
     context 'for a definition with a media type' do
@@ -520,8 +427,9 @@ describe Praxis::ResponseDefinition do
       its([:location]){ should == {value: location.inspect ,type: :regexp} }
 
       it 'should have a header defined with value and type keys' do
-        expect( output[:headers] ).to have(1).keys
+        expect( output[:headers] ).to have(2).keys
         expect( output[:headers]['Header1'] ).to eq({value: 'Value1' ,type: :string })
+        expect( output[:headers]['Location'] ).to eq({value: "/\\/my\\/url\\//" ,type: :regexp })        
       end
     end
 

data/spec/spec_helper.rb

@@ -17,6 +17,7 @@ require 'simplecov'
 SimpleCov.start 'praxis'
 
 require 'pry'
+require 'pry-byebug'
 
 require 'praxis'
 

data/tasks/thor/templates/generator/example_app/app/v1/concerns/href.rb

@@ -0,0 +1,33 @@
+# frozen_string_literal: true
+
+module V1
+  module Resources
+    module Concerns
+      module Href
+        extend ActiveSupport::Concern
+
+        # Base module where the href concern will grab constants from
+        included do
+          def self.base_module
+            ::V1
+          end
+        end
+
+        module ClassMethods
+          def endpoint_path_template
+            # memoize a templated path for an endpoint, like
+            # /im/contacts/%{id}
+            return @endpoint_path_template if @endpoint_path_template
+
+            path = self.base_module.const_get(:Endpoints).const_get(model.name.split(':').last.pluralize).canonical_path.route.path
+            @endpoint_path_template = path.names.inject(path.to_s) { |p, name| p.sub(':' + name, "%{#{name}}") }
+          end
+        end
+
+        def href
+          format(self.class.endpoint_path_template, id: id)
+        end
+      end
+    end
+  end
+end

data/tasks/thor/templates/generator/example_app/app/v1/resources/base.rb

@@ -1,8 +1,12 @@
 # frozen_string_literal: true
 
+require_relative '../concerns/href'
+
 module V1
   module Resources
     class Base < Praxis::Mapper::Resource
+      include Resources::Concerns::Href
+
       # Base for all V1 resources.
       # Resources withing a single version should have resource mappings separate from other versions
       # and the Mapper::Resource will appropriately maintain different model_maps for each Base classes

data/tasks/thor/templates/generator/example_app/config/environment.rb

@@ -4,7 +4,7 @@ Praxis::Application.configure do |application|
   # Configure the Mapper plugin (if we want to use all the filtering/field_selection extensions)
   application.bootloader.use Praxis::Plugins::MapperPlugin
   # Configure the Pagination plugin (if we want to use all the pagination/ordering extensions)
-  application.bootloader.use Praxis::Plugins::PaginationPlugin, {
+  application.bootloader.use Praxis::Plugins::PaginationPlugin, **{
     # max_items: 500,  # Unlimited by default,
     # default_page_size: 100,
     # paging_default_mode: {by: :id},

data/tasks/thor/templates/generator/scaffold/implementation/resources/item.rb

@@ -18,7 +18,7 @@ module <%= version_module %>
       <%- if action_enabled?(:create) -%>
       def self.create(payload)
         # Assuming the API field names directly map the the model attributes. Massage if appropriate.
-        self.new(model.create(*payload.to_h))
+        self.new(model.create(**payload.to_h))
       end
       <%- end -%>
 
@@ -27,7 +27,7 @@ module <%= version_module %>
         record = model.find_by(id: id)
         return nil unless record
         # Assuming the API field names directly map the the model attributes. Massage if appropriate.
-        record.update(*payload.to_h)
+        record.update(**payload.to_h)
         self.new(record)
       end
       <%- end -%>

metadata

@@ -1,15 +1,15 @@
 --- !ruby/object:Gem::Specification
 name: praxis
 version: !ruby/object:Gem::Version
-  version: 2.0.pre.13
+  version: 2.0.pre.17
 platform: ruby
 authors:
 - Josep M. Blanquer
 - Dane Jensen
-autorequire:
+autorequire: 
 bindir: bin
 cert_chain: []
-date: 2021-02-24 00:00:00.000000000 Z
+date: 2021-08-18 00:00:00.000000000 Z
 dependencies:
 - !ruby/object:Gem::Dependency
   name: rack
@@ -367,7 +367,7 @@ dependencies:
     - - ">"
       - !ruby/object:Gem::Version
         version: '4'
-description:
+description: 
 email:
 - blanquer@gmail.com
 - dane.jensen@gmail.com
@@ -647,6 +647,7 @@ files:
 - tasks/thor/templates/generator/example_app/Rakefile
 - tasks/thor/templates/generator/example_app/app/models/user.rb
 - tasks/thor/templates/generator/example_app/app/v1/concerns/controller_base.rb
+- tasks/thor/templates/generator/example_app/app/v1/concerns/href.rb
 - tasks/thor/templates/generator/example_app/app/v1/controllers/users.rb
 - tasks/thor/templates/generator/example_app/app/v1/resources/base.rb
 - tasks/thor/templates/generator/example_app/app/v1/resources/user.rb
@@ -671,7 +672,7 @@ homepage: https://github.com/praxis/praxis
 licenses:
 - MIT
 metadata: {}
-post_install_message:
+post_install_message: 
 rdoc_options: []
 require_paths:
 - lib
@@ -687,7 +688,7 @@ required_rubygems_version: !ruby/object:Gem::Requirement
       version: 1.3.1
 requirements: []
 rubygems_version: 3.1.2
-signing_key:
+signing_key: 
 specification_version: 4
 summary: Building APIs the way you want it.
 test_files: []