praxis 2.0.pre.8 → 2.0.pre.13

data/spec/praxis/extensions/field_selection/active_record_query_selector_spec.rb

@@ -29,7 +29,7 @@ describe Praxis::Extensions::FieldSelection::ActiveRecordQuerySelector do
       :id # We always load the primary keys
     ]
   end
-  let(:selector_node) { Praxis::Mapper::SelectorGenerator.new.add(ActiveBookResource,selector_fields)  }
+  let(:selector_node) { Praxis::Mapper::SelectorGenerator.new.add(ActiveBookResource,selector_fields).selectors  }
   let(:debug){ false }
 
   subject(:selector) {described_class.new(query: query, selectors: selector_node, debug: debug) }

data/spec/praxis/extensions/field_selection/sequel_query_selector_spec.rb

@@ -64,7 +64,7 @@ describe Praxis::Extensions::FieldSelection::SequelQuerySelector do
     ]
   end
 
-  let(:selector_node) { Praxis::Mapper::SelectorGenerator.new.add(SequelSimpleResource,selector_fields)  }
+  let(:selector_node) { Praxis::Mapper::SelectorGenerator.new.add(SequelSimpleResource,selector_fields).selectors  }
   subject {described_class.new(query: query, selectors: selector_node, debug: debug) }
 
   context 'generate' do

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

@@ -103,7 +103,7 @@ class ActiveBookResource < ActiveBaseResource
 
   filters_mapping(
     id: :id,
-    category_uuid: :category_uuid,
+    # category_uuid: :category_uuid  #NOTE: we do not need to define same-name-mappings if they exist
     'fake_nested.name': 'simple_name',
     'name': 'simple_name',
     'name_is_not': lambda do |spec| # Silly way to use a proc, but good enough for testing

data/spec/praxis/field_expander_spec.rb

@@ -0,0 +1,149 @@
+# frozen_string_literal: true
+require 'spec_helper'
+
+describe Praxis::FieldExpander do
+  let(:field_expander) { Praxis::FieldExpander.new }
+  let(:expanded_person_default_fieldset) do
+    # The only ones that are not already leaves is the full name, which can expand to first, last
+    PersonBlueprint.default_fieldset.merge!(full_name: {first: true, last: true})
+  end
+  let(:expanded_address_default_fieldset) do
+    # AddressBlueprint' default fieldset already has all attributes as leaves
+    AddressBlueprint.default_fieldset
+  end
+
+  context 'expanding attributes of a PersonBlueprint blueprint' do
+    it 'with fields=true, expands all fields on the default fieldset' do
+      expect(field_expander.expand(PersonBlueprint, true)).to eq(expanded_person_default_fieldset)
+    end
+
+    it 'expands for a subset of the direct fields' do
+      expect(field_expander.expand(PersonBlueprint, name: true)).to eq(name: true)
+    end
+
+    it 'raises when trying to expand fields that do not exist in the type' do
+      expect do
+        field_expander.expand(PersonBlueprint, name: true, foobar: true)
+      end.to raise_error(/.*:foobar.*do not exist in PersonBlueprint/)
+    end
+
+    context 'given inlined struct attribtue' do
+      it 'expands for a sub-struct' do
+        expect(field_expander.expand(PersonBlueprint, parents: true)).to eq(parents: { mother: true, father: true })
+      end
+
+      it 'expands for a subset of a substruct' do
+        expect(field_expander.expand(PersonBlueprint, parents: { mother: true })).to eq(parents: { mother: true })
+      end
+    end
+
+    context 'given a non-inlined struct sub attribute' do
+      it 'expands a specific subattribute of a struct' do
+        expect(field_expander.expand(PersonBlueprint, full_name: { first: true })).to eq(full_name: { first: true })
+      end
+
+      it 'fully expands collections properly by simply listing subfields' do
+        expect(field_expander.expand(PersonBlueprint, prior_addresses: true)).to eq(prior_addresses: expanded_address_default_fieldset)
+      end
+    end
+
+    context 'given a attribute that is also a blueprint' do
+      it 'expands to default fieldset for an attribute that is also blueprint' do
+        expect(field_expander.expand(PersonBlueprint, address: true)).to eq(address: expanded_address_default_fieldset)
+      end
+
+      it 'expands to default fieldset for a subset of fields of an attribute that is a blueprint' do
+        expect(field_expander.expand(PersonBlueprint, address: { resident: true })).to eq(address: { resident: expanded_person_default_fieldset })
+      end
+    end
+
+    context 'collection attributes' do
+      it 'expands subfields by simply listing subfields the same as structs/blueprints' do
+        expect(field_expander.expand(PersonBlueprint, prior_addresses: { state: true })).to eq(prior_addresses: { state: true })
+      end
+    end
+  end
+
+  it 'expands for for a primitive type' do
+    expect(field_expander.expand(String)).to eq(true)
+  end
+
+  it 'expands for an Attributor::Model' do
+    expect(field_expander.expand(FullName)).to eq(first: true, last: true)
+  end
+
+  it 'expands for a Blueprint' do
+    expect(field_expander.expand(PersonBlueprint, parents: true)).to eq(parents: { father: true, mother: true })
+  end
+
+  it 'expands for an Attributor::Collection of an Attrbutor::Model' do
+    expect(field_expander.expand(Attributor::Collection.of(FullName))).to eq(first: true, last: true)
+  end
+
+  it 'expands for an Attributor::Collection of a Blueprint' do
+    expected = { name: true, resident: { full_name: { first: true, last: true } } }
+    expect(field_expander.expand(Attributor::Collection.of(AddressBlueprint), name: true, resident: { full_name: true })).to eq(expected)
+  end
+
+  it 'also expands array-wrapped field hashes for collections' do
+    expected = { name: true, resident: { full_name: { first: true, last: true } } }
+    expect(field_expander.expand(Attributor::Collection.of(AddressBlueprint), name: true, resident: { full_name: true })).to eq(expected)
+  end
+
+  it 'expands for an Attributor::Collection of a primitive type' do
+    expect(field_expander.expand(Attributor::Collection.of(String))).to eq(true)
+  end
+
+  context 'expanding a two-dimensional collection' do
+    it 'expands the fields discarding the collection nexting nesting' do
+      matrix_type =  Attributor::Collection.of(Attributor::Collection.of(FullName))
+      expect(field_expander.expand(matrix_type)).to eq(first: true, last: true)
+    end
+  end
+
+  context 'circular expansions' do
+    it 'preserve field object identity for circular references' do
+      result = field_expander.expand(PersonBlueprint, address: {resident: true}, work_address: {resident: true})
+      expect(result[:address][:resident]).to be(result[:work_address][:resident])
+    end
+
+    context 'with collections of Blueprints' do
+      it 'still preserves object identity' do
+        result = field_expander.expand(PersonBlueprint, address: {resident: true}, prior_addresses: {resident: true})
+        expect(result[:address][:resident]).to be(result[:prior_addresses][:resident])
+      end
+    end
+  end
+
+  it 'optimizes duplicate field expansions' do
+    expect(field_expander.expand(FullName, true)).to be(field_expander.expand(FullName, true))
+  end
+
+  context 'expanding hash attributes' do
+    let(:type) do
+      Class.new(Attributor::Model) do
+        attributes do
+          attribute :name, String
+          attribute :simple_hash, Hash
+          attribute :keyed_hash, Hash do
+            key :foo, String
+            key :bar, String
+          end
+          attribute :some_struct do
+            attribute :something, String
+          end
+        end
+      end
+    end
+
+    it 'expands' do
+      expected = {
+        name: true,
+        simple_hash: true,
+        keyed_hash: { foo: true, bar: true },
+        some_struct: { something: true }
+      }
+      expect(field_expander.expand(type, true)).to eq(expected)
+    end
+  end
+end

data/spec/praxis/mapper/selector_generator_spec.rb

@@ -8,7 +8,7 @@ describe Praxis::Mapper::SelectorGenerator do
   context '#add' do
     let(:resource) { SimpleResource }
     shared_examples 'a proper selector' do
-      it { expect(generator.add(resource, fields).dump).to be_deep_equal selectors }
+      it { expect(generator.add(resource, fields).selectors.dump).to be_deep_equal selectors }
     end
     
     context 'basic combos' do

data/spec/praxis/media_type_identifier_spec.rb

@@ -42,10 +42,11 @@ describe Praxis::MediaTypeIdentifier do
         expect(described_class.new(unquoted_example).parameters['encoding']).to eq('martian')
       end
 
-      it 'handles quoted semicolons in values' do
-        pending("need to stop using a regexp to do a context-free parser's job")
-        expect(described_class.new(tricky_example).parameters['sauce']).to eq('yes; absolutely')
-      end
+      # TODO: Maybe that's something we want to support in the future? seems a big hammer for such a thing
+      # it 'handles quoted semicolons in values' do
+      #   pending("need to stop using a regexp to do a context-free parser's job")
+      #   expect(described_class.new(tricky_example).parameters['sauce']).to eq('yes; absolutely')
+      # end
 
 
     end

data/spec/praxis/media_type_spec.rb

@@ -22,7 +22,6 @@ describe Praxis::MediaType do
 
   subject(:address) { Address.new(resource) }
 
-
   context 'attributes' do
     its(:id)    { should eq(1) }
     its(:name)  { should eq('Home') }
@@ -30,112 +29,24 @@ describe Praxis::MediaType do
   end
 
 
-  context 'loading' do
-    it do
-      Person.load({id: 1})
-      Person.load(owner_resource)
-
-    end
-  end
-
-
   context 'accessor methods' do
     subject(:address_klass) { address.class }
 
     context '#identifier' do
-      context 'in praxis v1.0 and beyond' do
-        it 'should be a kind of Praxis::MediaTypeIdentifier' do
-          pending('interface-breaking change') if Praxis::VERSION =~ /^0/
-          expect(subject.identifier).to be_kind_of(Praxis::MediaTypeIdentifier)
-        end
+      it 'should be a kind of Praxis::MediaTypeIdentifier' do
+        expect(subject.identifier).to be_kind_of(Praxis::MediaTypeIdentifier)
       end
     end
 
     its(:description) { should be_kind_of(String) }
-
   end
 
   context "rendering" do
-    subject(:output) { address.render(view: :default) }
+    subject(:output) { address.render }
 
     its([:id])    { should eq(address.id) }
     its([:name])  { should eq(address.name) }
-    its([:owner]) { should eq(Person.dump(owner_resource, view: :default)) }
+    its([:owner]) { should eq(Person.dump(owner_resource)) }
     its([:fields]) { should eq(address.fields.dump ) }
-
-  end
-
-  context 'describing' do
-
-    subject(:described){ Address.describe }
-
-    its(:keys) { should match_array( [:attributes, :description, :display_name, :family, :id, :identifier, :key, :name, :views, :requirements] ) }
-    its([:attributes]) { should be_kind_of(::Hash) }
-    its([:description]) { should be_kind_of(::String) }
-    its([:display_name]) { should be_kind_of(::String) }
-    its([:family]) { should be_kind_of(::String) }
-    its([:id]) { should be_kind_of(::String) }
-    its([:name]) { should be_kind_of(::String) }
-    its([:identifier]) { should be_kind_of(::String) }
-    its([:key]) { should be_kind_of(::Hash) }
-    its([:views]) { should be_kind_of(::Hash) }
-
-    its([:description]) { should eq(Address.description) }
-    its([:display_name]) { should eq(Address.display_name) }
-    its([:family]) { should eq(Address.family) }
-    its([:id]) { should eq(Address.id) }
-    its([:name]) { should eq(Address.name) }
-    its([:identifier]) { should eq(Address.identifier.to_s) }
-    it 'should include the defined views' do
-      expect( subject[:views].keys ).to match_array([:default, :master])
-    end
-    it 'should include the defined attributes' do
-      expect( subject[:attributes].keys ).to match_array([:id, :name, :owner, :custodian, :residents, :residents_summary, :fields])
-    end
-  end
-
-  context 'using blueprint caching' do
-    it 'has specs'
-  end
-
-  context Praxis::MediaType::FieldResolver do
-    let(:expander) { Praxis::FieldExpander }
-    let(:user_view) { User.views[:default] }
-
-    let(:fields) { expander.expand(user_view) }
-
-    let(:field_resolver) { Praxis::MediaType::FieldResolver }
-
-    subject(:output) { field_resolver.resolve(User,fields) }
-
-    context 'resolving collections' do
-      let(:fields) { {:id=>true, :posts=>[{:href=>true}]}}
-      it 'strips arrays from the incoming fields' do
-        expect(output).to eq(id: true, posts: {href: true})
-      end
-
-      it 'supports multi-dimensional collections' do
-        fields = {
-          id: true,
-          post_matrix:[[{title: true, href: true}]]
-        }
-        output = field_resolver.resolve(User,fields)
-        expect(output).to eq(id: true, post_matrix:{href: true, title: true})
-      end
-
-      it 'supports nesting structs and arrays collections' do
-        fields = {
-         id: true,
-         daily_posts: [
-           {day: true, posts: [{id: true}]}
-         ]
-        }
-        output = field_resolver.resolve(User,fields)
-        expect(output).to eq(id: true, daily_posts:{day: true, posts: {id:true}})
-      end
-    end
-
   end
-
-
 end

data/spec/praxis/renderer_spec.rb

@@ -0,0 +1,188 @@
+# frozen_string_literal: true
+require_relative '../spec_helper'
+
+describe Praxis::Renderer do
+  let(:address) { AddressBlueprint.example }
+  let(:prior_addresses) { Array.new(2) { AddressBlueprint.example } }
+  let(:alias_one) { FullName.example }
+  let(:alias_two) { FullName.example }
+  let(:aliases) { [alias_one, alias_two] }
+  let(:metadata_hash) { { something: 'here' } }
+  let(:metadata) { Attributor::Hash.load(metadata_hash) }
+
+  let(:person) do
+    PersonBlueprint.example(
+      address: address,
+      email: nil,
+      prior_addresses: prior_addresses,
+      alive: false,
+      work_address: nil,
+      aliases: aliases,
+      metadata: metadata
+    )
+  end
+
+  let(:fields) do
+    {
+      name: true,
+      email: true,
+      full_name: { first: true, last: true },
+      address: {
+        state: true,
+        street: true,
+        resident:  { name: true }
+      },
+      prior_addresses: { name: true },
+      work_address: true,
+      alive: true,
+      metadata: true,
+      aliases: true
+    }
+  end
+
+  let(:renderer) { Praxis::Renderer.new }
+
+  subject(:output) { renderer.render(person, fields) }
+
+  it 'renders existing attributes' do
+    expect(output.keys).to match_array([:name, :full_name, :alive, :address, :prior_addresses, :metadata, :aliases])
+
+    expect(output[:name]).to eq person.name
+    expect(output[:full_name]).to eq(first: person.full_name.first, last: person.full_name.last)
+    expect(output[:alive]).to be false
+
+    expect(output[:address]).to eq(state: person.address.state,
+                               street: person.address.street,
+                               resident: { name: person.address.resident.name })
+
+    expected_prior_addresses = prior_addresses.collect { |addr| { name: addr.name } }
+    expect(output[:prior_addresses]).to match_array(expected_prior_addresses)
+
+    expect(output[:aliases]).to match_array(aliases.collect(&:dump))
+    expect(output[:metadata]).to eq(metadata.dump)
+  end
+
+  context 'calls dump for non-Blueprint, but still Dumpable instances' do
+    it 'when rendering them in full as array members' do
+      expect(alias_one).to receive(:dump).and_call_original
+      expect(output[:aliases].first).to eq(first: alias_one.first, last: alias_one.last)
+    end
+    it 'when rendering them in full as leaf object' do
+      expect(metadata).to receive(:dump).and_call_original
+      expect(output[:metadata]).to eq(metadata_hash)
+    end
+  end
+
+  it 'does not render attributes with nil values' do
+    expect(output).to_not have_key(:email)
+  end
+
+  context 'with include_nil: true' do
+    let(:renderer) { Praxis::Renderer.new(include_nil: true) }
+    let(:address) { nil }
+
+    it 'renders attributes with nil values' do
+      expect(output).to have_key :email
+      expect(output[:email]).to be_nil
+
+      expect(output).to have_key :work_address
+      expect(output[:work_address]).to be_nil
+    end
+
+    it 'renders nil directly for nil subobjects' do
+      expect(output).to have_key :address
+      expect(output[:address]).to be_nil
+    end
+  end
+
+  context 'rendering a two-dimmensional collection' do
+    let(:names) { Array.new(9) { |i| AddressBlueprint.example(i.to_s, name: i.to_s) } }
+    let(:matrix_type) do
+      Attributor::Collection.of(Attributor::Collection.of(AddressBlueprint))
+    end
+
+    let(:matrix) { matrix_type.load(names.each_slice(3).collect { |slice| slice }) }
+
+    let(:fields) { { name: true } }
+
+    it 'renders with render_collection and per-element field spec' do
+      rendered = renderer.render(matrix, fields)
+      expect(rendered.flatten.collect { |r| r[:name] }).to eq((0..8).collect(&:to_s))
+    end
+
+    it 'renders with render and proper field spec' do
+      rendered = renderer.render(matrix, fields)
+      expect(rendered.flatten.collect { |r| r[:name] }).to eq((0..8).collect(&:to_s))
+    end
+  end
+
+  context 'rendering stuff that breaks badly' do
+    it 'does not break badly' do
+      expect{renderer.render(person, {tags: true})}.to_not raise_error
+    end
+  end
+
+  context 'caching rendered objects' do
+    let(:fields) { {full_name: true} }
+    it 'caches and returns identical results for the same field objects' do
+      expect(person).to receive(:full_name).once.and_call_original
+
+      render_1 = renderer.render(person, fields)
+      render_2 = renderer.render(person, fields)
+      expect(render_1).to be(render_2)
+    end
+  end
+
+  context 'rendering hashes' do
+    let(:fields) do
+      {
+        id: true,
+        hash: true
+      }
+    end
+
+    let(:data) { { id: 10, hash: { foo: 'bar' } } }
+    let(:object) { SimpleHash.load(data) }
+    let(:renderer) { Praxis::Renderer.new }
+
+    subject(:output) { renderer.render(object, fields) }
+
+    its([:id]) { should eq data[:id] }
+    its([:hash]) { should eq data[:hash] }
+    its([:hash]) { should be_kind_of(Hash) }
+  end
+
+  context 'rendering collections of hashes' do
+    let(:fields) do
+      {
+        id: true,
+        hash_collection: true
+      }
+    end
+
+    let(:data) { { id: 10, hash_collection: [{ foo: 'bar' }] } }
+    let(:object) { SimpleHashCollection.load(data) }
+    let(:renderer) { Praxis::Renderer.new }
+
+    subject(:output) { renderer.render(object, fields) }
+
+    its([:id]) { should eq data[:id] }
+    its([:hash_collection]) { should eq data[:hash_collection] }
+    its([:hash_collection]) { should be_kind_of(Array) }
+
+    it 'renders the hashes' do
+      expect(output[:hash_collection].first).to be_kind_of(Hash)
+    end
+  end
+
+  context 'rendering a Blueprint with fields true' do
+    let(:fields) do
+      {
+        name: true,
+        address: true
+      }
+    end
+
+    its([:address]) { should eq person.address.dump }
+  end
+end