praxis 0.22.pre.2 → 2.0.pre.1

data/lib/praxis/router.rb

@@ -50,7 +50,7 @@ module Praxis
     end
 
     def add_route(target, route)
-      path_versioning = (application.versioning_scheme == :path)
+      path_versioning = (Application.instance.versioning_scheme == :path)
 
       # DEPRECATED: remove with ResourceDefinition.version using: :path
       path_versioning ||= (target.action.resource_definition.version_options[:using] == :path)
@@ -65,7 +65,7 @@ module Praxis
     def call(env_or_request)
       request = case env_or_request
       when Hash
-        request_class.new(env_or_request, application: application)
+        request_class.new(env_or_request)
       when request_class
         env_or_request
       else
@@ -101,7 +101,7 @@ module Praxis
           body += " Available versions = #{pretty_versions}."
         end
         headers = {"Content-Type" => "text/plain"}
-        if application.config.praxis.x_cascade
+        if Praxis::Application.instance.config.praxis.x_cascade
           headers['X-Cascade'] = 'pass'
         end
         result = [404, headers, [body]]

data/lib/praxis/tasks/api_docs.rb

@@ -58,16 +58,8 @@ namespace :praxis do
       require 'fileutils'
 
       Praxis::Blueprint.caching_enabled = false
-      
-      apps = Praxis::Application.registered_apps
-      if apps.size == 1
-        # Backwards compatible directory generation when there's only 1 app
-        Praxis::Docs::Generator.generate(Dir.pwd, name: apps.first[0], skip_sub_directory: true)
-      else
-        apps.each do|name,instance|
-          Praxis::Docs::Generator.generate(Dir.pwd, name: name)
-        end
-      end
+      generator = Praxis::Docs::Generator.new(Dir.pwd)
+      generator.save!
     end
 
   end

data/lib/praxis/tasks/routes.rb

@@ -11,7 +11,6 @@ namespace :praxis do
     ]
 
     rows = []
-    # TODO SINGLETON: ... what do do here?...
     Praxis::Application.instance.resource_definitions.each do |resource_definition|
       resource_definition.actions.each do |name, action|
         method = begin

data/lib/praxis/version.rb

@@ -1,3 +1,3 @@
 module Praxis
-  VERSION = '0.22.pre.2'
+  VERSION = '2.0.pre.1'
 end

data/lib/praxis.rb

@@ -1,10 +1,10 @@
 require 'rack'
 require 'attributor'
-require 'praxis-mapper'
 require 'praxis-blueprints'
 
 require 'active_support/concern'
 require 'praxis/request_superclassing'
+require 'active_support/inflector'
 
 $:.unshift File.dirname(__FILE__)
 
@@ -62,7 +62,6 @@ module Praxis
 
   autoload :Links, 'praxis/links'
   autoload :MediaType, 'praxis/media_type'
-  autoload :MediaTypeCollection, 'praxis/media_type_collection'
   autoload :MediaTypeIdentifier, 'praxis/media_type_identifier'
   autoload :Multipart, 'praxis/types/multipart'
   autoload :Collection, 'praxis/collection'
@@ -89,7 +88,8 @@ module Praxis
     autoload :MapperSelectors, 'praxis/extensions/mapper_selectors'
     autoload :Rendering, 'praxis/extensions/rendering'
     autoload :FieldExpansion, 'praxis/extensions/field_expansion'
-    autoload :AttributeFiltering, 'praxis/extensions/attribute_filtering'
+    autoload :ActiveRecordFilterQueryBuilder, 'praxis/extensions/attribute_filtering/active_record_filter_query_builder'
+    autoload :SequelFilterQueryBuilder, 'praxis/extensions/attribute_filtering/sequel_filter_query_builder'
   end
 
   module Handlers
@@ -123,11 +123,15 @@ module Praxis
     autoload :Response, 'praxis/request_stages/response'
   end
 
-  # # Avoid loading responses (and templates) lazily as they need to be registered in time
-  # ... now done in Praxis initialize
-  # require 'praxis/responses/http'
-  # require 'praxis/responses/internal_server_error'
-  # require 'praxis/responses/validation_error'
-  # require 'praxis/responses/multipart_ok'
+  module Mapper
+    autoload :Resource, 'praxis/mapper/resource'
+    autoload :SelectorGenerator, 'praxis/mapper/selector_generator'
+  end
+
+  # Avoid loading responses (and templates) lazily as they need to be registered in time
+  require 'praxis/responses/http'
+  require 'praxis/responses/internal_server_error'
+  require 'praxis/responses/validation_error'
+  require 'praxis/responses/multipart_ok'
 
 end

data/praxis.gemspec

@@ -24,10 +24,9 @@ Gem::Specification.new do |spec|
   spec.add_dependency 'mustermann', '>=0', '<=1'
   spec.add_dependency 'activesupport', '>= 3'
   spec.add_dependency 'mime', '~> 0'
-  spec.add_dependency 'praxis-mapper', '~> 4.3'
   spec.add_dependency 'praxis-blueprints', '~> 3.3'
   spec.add_dependency 'attributor', '~> 5.1'
-  spec.add_dependency 'thor', '~> 0.18'
+  spec.add_dependency 'thor'
   spec.add_dependency 'terminal-table', '~> 1.4'
 
   spec.add_development_dependency 'bundler'
@@ -50,6 +49,6 @@ Gem::Specification.new do |spec|
   spec.add_development_dependency 'rack-test', '~> 0'
   spec.add_development_dependency 'simplecov', '~> 0'
   spec.add_development_dependency 'fuubar', '~> 2'
-  spec.add_development_dependency 'yard', '~> 0'
+  spec.add_development_dependency 'yard', ">= 0.9.20"
   spec.add_development_dependency 'coveralls'
 end

data/spec/functional_spec.rb

@@ -136,7 +136,6 @@ describe 'Functional specs' do
     headers = last_response.headers
     expect(headers['Content-Type']).to eq('application/json')
     expect(headers['Spec-Middleware']).to eq('used')
-    expect(headers['Content-Length']).to eq(last_response.body.size.to_s)
   end
 
   it 'returns early when making the before filter break' do

data/spec/praxis/action_definition_spec.rb

@@ -1,15 +1,6 @@
 require 'spec_helper'
 
 describe Praxis::ActionDefinition do
-  
-  before(:context) do
-    Thread.current[:praxis_instance] = Praxis::Application.new(name: 'action_definition_spec', skip_registration: true)
-  end
-  
-  let(:praxis_instance) do
-    Thread.current[:praxis_instance]
-  end
-  
   class SpecMediaType < Praxis::MediaType
     identifier 'application/json'
 
@@ -40,8 +31,10 @@ describe Praxis::ActionDefinition do
       end
     end
   end
+
   subject(:action) do
-    praxis_instance.api_definition.define do |api|
+
+    Praxis::ApiDefinition.define do |api|
       api.response_template :ok do |media_type: , location: nil, headers: nil, description: nil |
         status 200
 
@@ -49,10 +42,6 @@ describe Praxis::ActionDefinition do
         location location
         headers headers if headers
       end
-      
-      api.info do # applies to all API infos
-        base_path "/pref"
-      end
     end
     Praxis::ActionDefinition.new(:foo, resource_definition) do
       routing { get '/:one' }
@@ -122,11 +111,11 @@ describe Praxis::ActionDefinition do
     let(:traits) { {test: trait} }
 
     before do
-      allow(praxis_instance.api_definition).to receive(:traits).and_return(traits)
+      allow(Praxis::ApiDefinition.instance).to receive(:traits).and_return(traits)
     end
 
     its('params.attributes.keys') { should eq [:inherited, :app_name, :name, :one]}
-    its('routes.first.path.to_s') { should eq '/pref/foobars/hello_world/test_trait/:app_name/:one' }
+    its('routes.first.path.to_s') { should eq '/api/foobars/hello_world/test_trait/:app_name/:one' }
     its(:traits) { should eq [:test] }
 
     it 'is reflected in the describe output' do
@@ -326,9 +315,11 @@ describe Praxis::ActionDefinition do
   end
 
   context 'with a base_path and base_params on ApiDefinition' do
-    subject(:action) do
-      api_def=Praxis::ApiDefinition.new(praxis_instance)
-      api_def.define do |api|
+    # 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.instance_eval do |api|
 
         api.info do
           base_path '/apps/:app_name'
@@ -341,13 +332,11 @@ describe Praxis::ActionDefinition do
         end
 
       end
-      # No setter...and its fine to do it here as it would not be used in a runtime situation
-      praxis_instance.instance_variable_set(:@api_definition, api_def)
-      # Define the action after the api_definition is set (as it uses is config to setup the routes)
-      Praxis::ActionDefinition.new(:bar, resource_definition) do
-        routing { get '/:one' }
-        params  { attribute :one, String }
-      end
+      api_def
+    end
+
+    before do
+      allow(Praxis::ApiDefinition).to receive(:instance).and_return(non_singleton_api)
     end
 
     its('routes.first.path.to_s') { should eq '/apps/:app_name/foobars/hello_world/:one' }

data/spec/praxis/api_definition_spec.rb

@@ -2,18 +2,12 @@ require 'spec_helper'
 
 describe Praxis::ApiDefinition do
 
-  # TODO: perhaps grab the spec app instance from some global var...(instead of relying on the singleton compat method)
-  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(:app_instance){ double("AppInstance") }
-  before do
-    allow(app_instance).to receive(:versioning_scheme=).with([:header, :params])
-  end
-  
   let(:non_singleton_api) do
-    api_def=Praxis::ApiDefinition.new(app_instance)
+    api_def=Praxis::ApiDefinition.__send__(:new)
     api_def.instance_eval do |api|
       api.response_template :template1, &Proc.new {}
       api.trait :trait1, &Proc.new {}
@@ -38,7 +32,12 @@ describe Praxis::ApiDefinition do
     end
   end
 
-  context 'initial definition' do
+  context 'singleton' do
+    it 'should be a Singleton' do
+      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
       expect(api.responses.keys).to include(:ok)
       expect(api.responses.keys).to include(:created)
@@ -59,10 +58,6 @@ describe Praxis::ApiDefinition do
       expect(api.responses.keys).to include(:foobar)
       expect(api.response(:foobar)).to be_kind_of(Praxis::ResponseTemplate)
     end
-    it 'stores the app instance' do
-      template = api.response(:template1)
-      expect(template.application).to be(app_instance)
-    end
   end
 
   context '.response' do

data/spec/praxis/api_general_info_spec.rb

@@ -2,7 +2,12 @@ require 'spec_helper'
 
 describe Praxis::ApiGeneralInfo do
 
-  subject(:info){ Praxis::ApiGeneralInfo.new(application: APP) }
+  subject(:info){ Praxis::ApiGeneralInfo.new }
+
+  before do
+    allow(Praxis::Application.instance).to receive(:versioning_scheme=).with([:header, :params])
+  end
+
 
   let(:info_block) do
     Proc.new do
@@ -59,8 +64,8 @@ describe Praxis::ApiGeneralInfo do
   end
 
   context 'base_path with versioning' do
-    let(:global_info){ Praxis::ApiGeneralInfo.new(application: APP) }
-    subject(:info){ Praxis::ApiGeneralInfo.new(global_info, application: APP, version: '1.0') }
+    let(:global_info){ Praxis::ApiGeneralInfo.new }
+    subject(:info){ Praxis::ApiGeneralInfo.new(global_info, version: '1.0') }
 
     before do
       global_info

data/spec/praxis/application_spec.rb

@@ -3,7 +3,7 @@ require 'spec_helper'
 describe Praxis::Application do
   context 'configuration' do
     subject(:app) do
-      app = Class.new(Praxis::Application).new(skip_registration: true)
+      app = Class.new(Praxis::Application).instance
 
       config = Object.new
       def config.define(key=nil, type=Attributor::Struct, **opts, &block)
@@ -45,7 +45,7 @@ describe Praxis::Application do
   end
 
   context 'media type handlers' do
-    subject { Class.new(Praxis::Application).new(skip_registration: true) }
+    subject { Class.new(Praxis::Application).instance }
 
     before do
       # don't actually bootload; we're merely running specs
@@ -94,14 +94,12 @@ describe Praxis::Application do
   end
 
   describe '#setup' do
-    subject { Praxis::Application.new(skip_registration: true) }
-    let(:boot_loader) { double("BL", setup!: true) }
-    let(:builder) { double("Builder", to_app: double('Rack app'), run: true) }
-    
+    subject { Class.new(Praxis::Application).instance }
+
     before do
-      # don't actually bootload; we're merely running specs  
-      allow(subject).to receive(:bootloader).and_return(boot_loader)
-      allow(subject).to receive(:builder).and_return(builder)
+      # don't actually bootload; we're merely running specs
+      allow(subject.bootloader).to receive(:setup!).and_return(true)
+      allow(subject.builder).to receive(:to_app).and_return(double('Rack app'))
     end
 
     it 'is idempotent' do
@@ -114,9 +112,5 @@ describe Praxis::Application do
       expect(subject.setup).to eq(subject)
       expect(subject.setup).to eq(subject)
     end
-    
-    it 'creates an ApiDefinition that has a back-reference' do
-      expect(subject.api_definition.application).to eq(subject)
-    end
   end
 end

data/spec/praxis/handlers/xml_spec.rb

@@ -128,7 +128,7 @@ describe Praxis::Handlers::XML do
         it_behaves_like 'xml something'
       end
       context 'a array with elements of all types' do
-        let(:parsed){ ["just text",:a,1,BigDecimal.new(100),0.1,true,Date.new] }
+        let(:parsed){ ["just text",:a,1,BigDecimal(100),0.1,true,Date.new] }
         it_behaves_like 'xml something'
       end
       context 'a hash with a complex substructure' do
@@ -137,7 +137,7 @@ describe Praxis::Handlers::XML do
             "text" => "just text",
             "symbol" => :a,
             "num" => 1,
-            "bd" => BigDecimal.new(100),
+            "bd" => BigDecimal(100),
             "float" => 0.1,
             "truthyness" => true,
             "day" => Date.new,

data/spec/praxis/mapper/resource_spec.rb

@@ -0,0 +1,169 @@
+require 'spec_helper'
+
+describe Praxis::Mapper::Resource do
+  let(:parent_record) { ParentModel.new(id: 100, name: 'george sr') }
+  let(:parent_records) { [ParentModel.new(id: 101, name: "georgia"),ParentModel.new(id: 102, name: 'georgina')] }
+  let(:record) { SimpleModel.new(id: 103, name: 'george xvi') }
+  let(:model) { SimpleModel}
+
+  context 'configuration' do
+    subject(:resource) { SimpleResource }
+    its(:model) { should == model }
+
+    context 'properties' do
+      subject(:properties) { resource.properties }
+
+      it 'includes directly-set properties' do
+        expect(properties[:other_resource]).to eq(dependencies: [:other_model])
+      end
+
+      it 'inherits from a superclass' do
+        expect(properties[:href]).to eq(dependencies: [:id])
+      end
+
+      it 'properly overrides a property from the parent' do
+        expect(properties[:name]).to eq(dependencies: [:simple_name])
+      end
+    end
+  end
+
+  context 'retrieving resources' do
+    context 'getting a single resource' do
+      before do
+       expect(SimpleModel).to receive(:get).with(name: 'george xvi').and_return(record)
+      end
+
+      subject(:resource)  { SimpleResource.get(:name => 'george xvi') }
+
+      it { is_expected.to be_kind_of(SimpleResource) }
+
+      its(:record) { should be record }
+    end
+
+    context 'getting multiple resources' do
+      before do
+        expect(SimpleModel).to receive(:all).with(name: ['george xvi']).and_return([record])
+      end
+
+      subject(:resource_collection) { SimpleResource.all(:name => ["george xvi"]) }
+
+      it { is_expected.to be_kind_of(Array) }
+
+      it 'fetches the models and wraps them' do
+        resource = resource_collection.first
+        expect(resource).to be_kind_of(SimpleResource)
+        expect(resource.record).to eq record
+      end
+    end
+  end
+
+  context 'delegating to the underlying model' do
+
+    subject { SimpleResource.new(record) }
+
+    it 'does respond_to attributes in the model' do
+      expect(subject).to respond_to(:name)
+    end
+
+    it 'does not respond_to :id if the model does not have it' do
+      resource = OtherResource.new(OtherModel.new(:name => "foo"))
+      expect(resource).not_to respond_to(:id)
+    end
+
+    it 'returns raw results for simple attributes' do
+      expect(record).to receive(:name).and_call_original
+      expect(subject.name).to eq("george xvi")
+    end
+
+    it 'wraps model objects in Resource instances' do
+      expect(record).to receive(:parent).and_return(parent_record)
+
+      parent = subject.parent
+
+      expect(parent).to be_kind_of(ParentResource)
+      expect(parent.name).to eq("george sr")
+      expect(parent.record).to eq(parent_record)
+    end
+
+    context "for serialized array associations" do
+      let(:record) { YamlArrayModel.new(:id => 1)}
+
+      subject { YamlArrayResource.new(record)}
+
+      it 'wraps arrays of model objects in an array of resource instances' do
+        expect(record).to receive(:parents).and_return(parent_records)
+
+        parents = subject.parents
+        expect(parents).to have(parent_records.size).items
+        expect(parents).to be_kind_of(Array)
+
+        parents.each { |parent| expect(parent).to be_kind_of(ParentResource) }
+        expect(parents.collect { |parent| parent.record }).to match_array(parent_records)
+      end
+    end
+  end
+
+  context 'resource_delegate' do
+    let(:other_name) { "foo" }
+    let(:other_attribute) { "other value" }
+    let(:other_record) { OtherModel.new(:name => other_name, :other_attribute => other_attribute)}
+    let(:other_resource) { OtherResource.new(other_record) }
+
+    let(:record) { SimpleModel.new(id: 105, name: "george xvi", other_name: other_name) }
+
+    subject(:resource) { SimpleResource.new(record) }
+    
+    it 'delegates to the target' do
+      expect(record).to receive(:other_model).and_return(other_record)
+      expect(resource.other_attribute).to eq(other_attribute)
+    end
+  end
+
+
+  context "memoized resource creation" do
+    let(:other_name) { "foo" }
+    let(:other_attribute) { "other value" }
+    let(:other_record) { OtherModel.new(:name => other_name, :other_attribute => other_attribute)}
+    let(:other_resource) { OtherResource.new(other_record) }
+    let(:record) { SimpleModel.new(id: 105, name: "george xvi", other_name: other_name) }
+
+    subject(:resource) { SimpleResource.new(record) }
+
+    it 'memoizes related resource creation' do
+      allow(record).to receive(:other_model).and_return(other_record)
+      expect(resource.other_resource).to be(SimpleResource.new(record).other_resource)
+    end
+
+  end
+
+
+  context ".wrap" do
+    it 'memoizes resource creation' do
+      expect(SimpleResource.wrap(record)).to be(SimpleResource.wrap(record))
+    end
+
+    it 'works with nil resources, returning an empty set' do
+      wrapped_obj = SimpleResource.wrap(nil)
+      expect(wrapped_obj).to be_kind_of(Array)
+      expect(wrapped_obj.length).to be(0)
+    end
+
+    it 'works array with nil member, returning only existing records' do
+      wrapped_set = SimpleResource.wrap([nil, record])
+      expect(wrapped_set).to be_kind_of(Array)
+      expect(wrapped_set.length).to be(1)
+    end
+    
+    it 'works with non-enumerable objects, that respond to collect' do
+      collectable = double("ArrayProxy", to_a: [record, record] )
+
+      wrapped_set = SimpleResource.wrap(collectable)
+      expect(wrapped_set.length).to be(2)
+    end
+
+    it 'works regardless of the resource class used' do
+      expect(SimpleResource.wrap(record)).to be(OtherResource.wrap(record))
+    end
+  end
+
+end