intermodal 0.0.1 → 0.4.0

data/lib/intermodal/validators/account_validator.rb

@@ -0,0 +1,27 @@
+require 'active_model/validator'
+
+module Intermodal
+  module Validators
+    # Validates the associated resource is owned by the same account
+    # Examples:
+    #
+    # validates parent_id, account: true
+    # validates parent_id, account: { through: association }
+    #
+    class AccountValidator < ActiveModel::EachValidator
+      def validate_each(record, attribute, value)
+        return if value.nil?
+        association_name = options[:through] || attribute.to_s.gsub(/_id/, '')
+        return if record.send(association_name).account_id == record.account_id
+        record.errors[attribute] << message
+      end
+
+      def message
+        options[:message] || 'must belong to the same account'
+      end
+
+    end
+  end
+end
+
+AccountValidator = Intermodal::Validators::AccountValidator unless defined? AccountValidator

data/lib/intermodal/validators/different_account_validator.rb

@@ -0,0 +1,27 @@
+require 'active_model/validator'
+
+module Intermodal
+  module Validators
+    # Validates the associated resource is owned by a different account
+    # Examples:
+    #
+    # validates parent_id, different_account: true
+    # validates parent_id, different_account: { through: association }
+    #
+    class DifferentAccountValidator < ActiveModel::EachValidator
+      def validate_each(record, attribute, value)
+        return if value.nil?
+        association_name = options[:through] || attribute.to_s.gsub(/_id/, '')
+        return if record.send(association_name).account_id != record.account_id
+        record.errors[attribute] << message
+      end
+
+      def message
+        options[:message] || 'must belong to a different account'
+      end
+
+    end
+  end
+end
+
+DifferentAccountValidator = Intermodal::Validators::DifferentAccountValidator unless defined? DifferentAccountValidator

data/lib/intermodal/version.rb

@@ -0,0 +1,3 @@
+module Intermodal
+  VERSION = "0.4.0"
+end

data/spec/mapping/acceptors_spec.rb

@@ -0,0 +1,142 @@
+require 'spec_helper'
+
+describe Intermodal::Mapping::Acceptor do
+  include SpecHelpers::ClassBuilder
+
+  describe '.call' do
+    subject { acceptor.call(params) }
+
+    context 'with pass-through mappings' do
+      let(:acceptor) do
+        define_class :TestAcceptor, Intermodal::Mapping::Acceptor do
+          accepts :acceptable_field
+          accepts :optional_field
+        end
+      end
+
+      let(:value) { 'Accepted Field' }
+      let(:params) { { :acceptable_field => value, :unacceptable_field => true } }
+
+      it 'should accept explicitly whitelisted fields' do
+        should include(:acceptable_field)
+      end
+
+      it 'should pass through value without transformation' do
+        subject[:acceptable_field].should eql(value)
+      end
+
+      it 'should not accept undeclared fields' do
+        should_not include(:unacceptable_field)
+      end
+
+      context 'without optional field in params' do
+        # Since we pass the output of an acceptor directly into
+        # the active record #create or #update_attributes, we want
+        # the hash to look like:
+        #
+        # { :acceptable_fields => 'Something' }
+        #
+        # rather than
+        #
+        # { :acceptable_field => 'Something', :optional_field => nil }
+        #
+        # Doing so will update the resource and null out the fields that
+        # have not been passed through params.
+        it 'should not include the optional field' do
+          should_not include(:optional_field)
+        end
+      end
+
+      context 'with optional field in params' do
+        let(:params) { { :acceptable_field => value, :optional_field => value } }
+
+        it 'should include the optional field' do
+          should include(:optional_field)
+        end
+
+        it 'should pass through value without transformation' do
+          subject[:optional_field].should eql(value)
+        end
+      end
+    end
+
+    context 'with pass-through alias mappings' do
+      let(:acceptor) do
+        define_class :TestAcceptor, Intermodal::Mapping::Acceptor do
+          accepts :name, :with => :full_name
+        end
+      end
+
+      let(:value) { 'Henry Deacon' }
+      let(:params) { { :full_name => value } }
+
+      it 'should present explicitly whitelisted fields' do
+        should include(:name)
+      end
+
+      it 'should pass through value without transformation' do
+        subject[:name].should eql(params[:full_name])
+      end
+
+      it 'should not present undeclared fields' do
+        should_not include(:full_name)
+      end
+    end
+
+    context 'with nested mappings' do
+      let(:acceptor) do
+        define_class :TestAcceptor, Intermodal::Mapping::Acceptor do
+          # Use this to create nested parameters from flattened parameters
+          accepts :name, :with => [ :first_name, :last_name ]
+        end
+      end
+
+      let(:first_name) { 'Henry' }
+      let(:last_name) { 'Deacon' }
+      let(:params) { { :first_name => first_name, :last_name => last_name } }
+
+      it 'should merge fields into a single hash of fields' do
+        should include(:name)
+        subject[:name].should include(:first_name)
+        subject[:name].should include(:last_name)
+      end
+
+      it 'should merge fields without transforming its value' do
+        subject[:name][:first_name].should eql(first_name)
+        subject[:name][:last_name].should  eql(last_name)
+      end
+
+      # Unless you've explicitly declared the merged fields, it should
+      # not include it.
+      it 'should not accept merged fields' do
+        should_not include(:first_name)
+        should_not include(:last_name)
+      end
+    end
+
+    context 'with arbitrary mappings' do
+      let(:acceptor) do
+        define_class :TestAcceptor, Intermodal::Mapping::Acceptor do
+          # This lets you use aribrary functions to map out accepted fields.
+          # Beware! For many use-cases, declaring these in the model works better.
+          # Beware! Do not use functions with side-effects
+          accepts :phone_number, :with => lambda { |o| o[:phone_number].gsub(/[^0-9]/, '') }
+        end
+      end
+
+      let(:value) { '555-555-5555' }
+      let(:params) { { :phone_number => value } }
+
+      it 'should accept an arbitrary mapping' do
+        should include(:phone_number)
+      end
+
+      it 'should transform the value' do
+        subject[:phone_number].should_not eql(value)
+      end
+    end
+
+    pending 'with scoped acceptor'
+  end
+end
+

data/spec/mapping/presenters_spec.rb

@@ -0,0 +1,186 @@
+require 'spec_helper'
+
+describe Intermodal::Mapping::Presenter do
+  include SpecHelpers::ClassBuilder
+  include SpecHelpers::Application
+
+  describe '.call' do
+    subject { presenter.call(resource) }
+    let(:resource) { item }
+
+    context 'with pass-through mappings' do
+      let(:presenter) do
+        define_class :TestPresenter, Intermodal::Mapping::Presenter do
+          presents :name
+          presents :description
+        end
+      end
+
+      it 'should present explicitly whitelisted fields' do
+        should include(:name)
+      end
+
+      it 'should pass through value without transformation' do
+        subject[:name].should eql(resource.name)
+      end
+
+      it 'should present all declared fields regardless of value' do
+        should include(:description)
+        subject[:description].should be_nil
+      end
+    end
+
+    context 'with pass-through alias mappings' do
+      let(:presenter) do
+        define_class :TestPresenter, Intermodal::Mapping::Presenter do
+          presents :full_name, :with => :name
+        end
+      end
+
+      it 'should present explicitly whitelisted fields' do
+        should include(:full_name)
+      end
+
+      it 'should pass through value without transformation' do
+        subject[:full_name].should eql(resource.name)
+      end
+
+      it 'should not present undeclared fields' do
+        should_not include(:name)
+      end
+    end
+
+    context 'with nested mappings' do
+      let(:presenter) do
+        define_class :TestPresenter, Intermodal::Mapping::Presenter do
+
+          # Use this to create nested presentation
+          presents :metadata, :with => [ :name, :description ]
+        end
+      end
+
+      let(:resource) { Item.make(:name => name, :description => description) }
+      let(:name) { 'Weird Eureka Thing' }
+      let(:description) { 'Makes Eureka Go Boom!' }
+
+      it 'should merge fields into a single hash of fields' do
+        should include(:metadata)
+        subject[:metadata].should include(:name)
+        subject[:metadata].should include(:description)
+      end
+
+      it 'should merge fields without transforming its value' do
+        subject[:metadata][:name].should eql(name)
+        subject[:metadata][:description].should eql(description)
+      end
+
+      # Unless you've explicitly declared the merged fields, it should
+      # not present it.
+      it 'should not present undeclared fields' do
+        should_not include(:name)
+        should_not include(:description)
+      end
+    end
+
+    pending 'with always_nest_collection'
+    context 'with arbitrary mappings' do
+      let(:presenter) do
+        define_class :TestPresenter, Intermodal::Mapping::Presenter do
+          # This lets you use aribrary functions to map out accepted fields.
+          # Beware! For many use-cases, declaring these in the model works better.
+          # Beware! Do not use functions with side-effects
+          presents :name, :with => lambda { |o| o[:name].upcase }
+        end
+      end
+
+      it 'should accept an arbitrary mapping' do
+        should include(:name)
+      end
+
+      it 'should transform the value' do
+        subject[:name].should_not eql(resource.name)
+      end
+    end
+
+    context 'when scoping' do
+      subject { presenter.call(resource, :scope => scope) }
+
+      context 'without scope declaration' do
+        let(:scope) { :default }
+        let(:presenter) do
+          define_class :TestPresenter, Intermodal::Mapping::Presenter do
+            presents :name
+          end
+        end
+
+        it 'should default to :default scope' do
+          should include(:name)
+          subject[:name].should eql(resource.name)
+        end
+      end
+
+      context 'with mixed scopes' do
+        let(:scope) { :default }
+        let(:presenter) do
+          define_class :TestPresenter, Intermodal::Mapping::Presenter do
+            presents :name
+            presents :description, :scope => :details
+          end
+        end
+
+        let(:resource) { Item.make(:name => name, :description => description) }
+        let(:name) { 'Weird Eureka Thing' }
+        let(:description) { 'Makes Eureka Go Boom!' }
+
+        it 'should default to :default scope' do
+          should include(:name)
+          subject[:name].should eql(resource.name)
+        end
+
+        it 'should not present attributes outside of scope' do
+          should_not include(:description)
+        end
+
+        context 'when called with non-default scope' do
+          let(:scope) { :details }
+
+          it 'should include non-overlapping attributes from default scope' do
+            should include(:name)
+            subject[:name].should eql(resource.name)
+          end
+
+          it 'should present attributes from non-default scope' do
+            should include(:description)
+            subject[:description].should eql(resource.description)
+          end
+        end
+      end
+
+      context 'with overlapping scopes' do
+        let(:scope) { :default }
+        let(:presenter) do
+          define_class :TestPresenter, Intermodal::Mapping::Presenter do
+            presents :name
+            presents :name, :with => lambda { |o| 'boo!' }, :scope => :details
+          end
+        end
+
+        it 'should default to :default scope' do
+          should include(:name)
+          subject[:name].should eql(resource.name)
+        end
+
+        context 'when called with non-default scope' do
+          let(:scope) { :details }
+
+          it 'should present attributes from non-default scope' do
+            should include(:name)
+            subject[:name].should_not eql(resource.name)
+            subject[:name].should eql('boo!')
+          end
+        end
+      end
+    end
+  end
+end
+

data/spec/models/accountability_spec.rb

@@ -0,0 +1,13 @@
+require 'spec_helper'
+
+describe Intermodal::Models::Accountability do
+  context 'when implemented as a resource' do
+    include SpecHelpers::Application
+    include Intermodal::RSpec::Accountability
+
+    subject { item }
+    implements_get_interface
+
+    pending 'should belong to account model'
+  end
+end

data/spec/models/has_parent_resource_spec.rb

@@ -0,0 +1,18 @@
+require 'spec_helper'
+
+describe Intermodal::Models::HasParentResource do
+  context 'when implemented as a resource' do
+    include SpecHelpers::Application
+    include Intermodal::RSpec::HasParentResource
+
+    subject { part }
+    let(:parent_resource_name) { :item }
+    let(:different_parent) { Item.make!(:account => account) }
+    let(:parent_with_different_account) { Item.make!(:account => different_account) }
+    let(:different_account) { Account.make! }
+
+    implements_get_interface_for_nested_resource
+
+    pending 'should belong to parent model'
+  end
+end

data/spec/models/resource_linking_spec.rb

@@ -0,0 +1,21 @@
+require 'spec_helper'
+
+describe Intermodal::Models::ResourceLinking do
+  context 'when implemented as a resource' do
+    include SpecHelpers::Application
+    include Intermodal::RSpec::ResourceLinking
+
+    subject { sku }
+
+    let(:model) { Sku }
+    let(:skus) { item.vendors << vendors }
+
+    # Protip: sku, item, and vendors can be defined in a global helper, such as SpecHelpers::Application
+    let(:sku) { Sku.create(:item => item, :vendor => vendor) }
+    let(:item) { Item.make!(:account => account) }
+    let(:vendor) { Vendor.make!(:account => account) }
+    let(:vendors) { (1..3).map { Vendor.make!(:account => account) } }
+
+    concerned_with_resource_linking :item, :vendor, :skip_association_examples => true, :skip_validation_examples => true
+  end
+end

data/spec/proxies/will_paginate_spec.rb

@@ -0,0 +1,163 @@
+require 'spec_helper'
+
+describe Intermodal::Proxies::WillPaginate::Collection do
+  include Intermodal::RSpec::Resources
+  include SpecHelpers::Application
+  include SpecHelpers::API
+
+  let(:api_class) do
+    define_class :Api, Rails::Engine do
+      include Intermodal::API
+      include SpecHelpers::Epiphyte
+
+      map_data do
+        presentation_for :item do
+          presents :id
+          presents :name
+          presents :description
+        end
+      end
+
+      controllers do
+      end
+
+      routes.draw do
+      end
+    end
+  end
+
+  describe '#as_json' do
+    before(:each) { api_class.load_presentations! }
+    subject { presented_collection }
+
+    let(:presenter) { api_class.presenters[:item] }
+    let(:collection) { Item.make!(3, :account => account) }
+    let(:paginated_collection) { collection; Item.paginate :page => 1 }
+    let(:presented_collection) { paginated_collection.as_json presenter_options }
+
+    let(:collection_ids) { collection.map(&:id) }
+
+    let(:_ids) { ->(r) { r[:id] } }
+    let(:presented_collection_ids) { presented_collection[:collection].map(&_ids) }
+
+    context 'with presenter default options' do
+      let(:presenter_options) { { :presenter => presenter } }
+
+      it 'should present page' do
+        subject[:page].should_not be_nil
+      end
+
+      it 'should present per_page' do
+        subject[:per_page].should_not be_nil
+      end
+
+      it 'should present total_pages' do
+        subject[:total_pages].should_not be_nil
+      end
+
+      it 'should present total_entries' do
+        subject[:total_entries].should_not be_nil
+      end
+
+      it 'should present collection' do
+        subject[:collection].should_not be_nil
+      end
+
+      it 'should present collection of resources' do
+        presented_collection_ids.should eql(collection_ids)
+      end
+    end
+
+    context 'with root option' do
+      let(:presenter_options) { { :presenter => presenter, :root => root } }
+      let(:root) { :node }
+      let(:presented_collection_ids) { presented_collection[root].map(&_ids) }
+
+      it 'should present page' do
+        subject[:page].should_not be_nil
+      end
+
+      it 'should present per_page' do
+        subject[:per_page].should_not be_nil
+      end
+
+      it 'should present total_pages' do
+        subject[:total_pages].should_not be_nil
+      end
+
+      it 'should present total_entries' do
+        subject[:total_entries].should_not be_nil
+      end
+
+      it 'should present collection' do
+        subject[root].should_not be_nil
+      end
+
+      it 'should present collection of resources' do
+        presented_collection_ids.should eql(collection_ids)
+      end
+    end
+
+    context 'with always_nest_collections option' do
+      let(:presenter_options) { { :presenter => presenter, :always_nest_collections => true } }
+      let(:presented_collection_ids) { presented_collection[:collection].map(&_ids) }
+      let(:_ids) { ->(r) { r['item'][:id] } }
+
+      it 'should present page' do
+        subject[:page].should_not be_nil
+      end
+
+      it 'should present per_page' do
+        subject[:per_page].should_not be_nil
+      end
+
+      it 'should present total_pages' do
+        subject[:total_pages].should_not be_nil
+      end
+
+      it 'should present total_entries' do
+        subject[:total_entries].should_not be_nil
+      end
+
+      it 'should present collection' do
+        subject[:collection].should_not be_nil
+      end
+
+      it 'should present collection of resources' do
+        presented_collection_ids.should eql(collection_ids)
+      end
+    end
+
+    context 'with always_nest_collections and root option' do
+      let(:presenter_options) { { :presenter => presenter, :root => root, :always_nest_collections => true } }
+      let(:root) { :nodes }
+      let(:element_name) { root.to_s.singularize }
+      let(:presented_collection_ids) { presented_collection[root].map(&_ids) }
+      let(:_ids) { ->(r) { r[element_name][:id] } }
+
+      it 'should present page' do
+        subject[:page].should_not be_nil
+      end
+
+      it 'should present per_page' do
+        subject[:per_page].should_not be_nil
+      end
+
+      it 'should present total_pages' do
+        subject[:total_pages].should_not be_nil
+      end
+
+      it 'should present total_entries' do
+        subject[:total_entries].should_not be_nil
+      end
+
+      it 'should present collection' do
+        subject[root].should_not be_nil
+      end
+
+      it 'should present collection of resources' do
+        presented_collection_ids.should eql(collection_ids)
+      end
+    end
+  end
+end