strong_presenter 0.1.0 → 0.2.0

data/spec/strong_presenter/collection_presenter_spec.rb

@@ -17,18 +17,50 @@ module StrongPresenter
         expect(products_presenter[0].class).to be ProductPresenter
       end
     end
+
+    it "has to_s method" do
+      collection = CollectionPresenter.new([Model.new, Model.new])
+      expect(collection.to_s).to include "inferred"
+    end
+
     describe "Permissible" do
-      it "permits on items" do
-        collection = [Model.new, Model.new]
-        collection_presenter = CollectionPresenter.new(collection, :with => Presenter)
+      before(:each) do
+        @collection = [Model.new, Model.new]
+        @collection_presenter = CollectionPresenter.new(@collection, :with => Presenter)
+      end
 
-        expect(collection_presenter[0].filter :z).to be_empty
+      it "collection permits on items" do
+        expect(@collection_presenter[0].select_permitted :z).to be_empty
 
-        collection_presenter.permit :a, :b, :c
-        permitted = collection_presenter[0].filter :a, :c, :z
+        @collection_presenter.permit! :a, :b, :c
+        permitted = @collection_presenter[0].select_permitted :a, :c, :z
         expect(permitted).to include(:a, :c)
         expect(permitted).to_not include(:b, :z)
       end
+
+      it "permits items" do
+        @collection_presenter[0].permit! :a
+        expect(@collection_presenter[0].select_permitted :a).to eq [:a]
+      end
+
+      it "does not leak item permit to siblings" do
+        @collection_presenter[0].permit! :a
+        expect(@collection_presenter[1].select_permitted :a).to be_empty
+      end
+
+      it "resets item permit on reload" do
+        @collection_presenter[0].permit! :a
+        @collection_presenter.reload!
+        expect(@collection_presenter[0].select_permitted :a).to be_empty
+      end
+
+      it "propagates to items" do
+        @collection_presenter[0].permit! :a
+        expect(@collection_presenter[0].select_permitted :a, :b).to eq [:a]
+        @collection_presenter.permit! :b
+        expect(@collection_presenter[0].select_permitted :a, :b).to eq [:a, :b]
+        expect(@collection_presenter[1].select_permitted :a, :b).to eq [:b]
+      end
     end
   end
 end

data/spec/strong_presenter/controller_additions_spec.rb

@@ -0,0 +1,115 @@
+require 'spec_helper'
+
+module StrongPresenter
+  describe ControllerAdditions do
+    before(:each) do
+      stub_const "MyController", Class.new {
+        attr_writer :action_name
+        def action_name
+          @action_name || ""
+        end
+      }
+      allow(MyController).to receive(:helper_method)
+      allow(MyController).to receive(:before_filter)
+      StrongPresenter.setup_action_controller(MyController)
+    end
+
+    describe '#presents' do
+      it 'sets up arbitrary helper method for presenter' do
+        expect(MyController).to receive(:helper_method).with(:arbitrary).once
+        MyController.presents :arbitrary
+      end
+
+      it 'sets up multiple helper methods' do
+        expect(MyController).to receive(:helper_method).with(:arbitrary).once
+        expect(MyController).to receive(:helper_method).with(:arb).once
+        MyController.presents :arbitrary, :arb
+      end
+
+      it 'sets up helper method with only' do
+        MyController.presents :arbitrary, :only => :show
+      end
+
+      it 'sets up helper method with except' do
+        MyController.presents :arbitrary, :except => :show
+      end
+
+      it 'sets up helper method with presenter option' do
+        MyController.presents :arbitrary, :with => ProductPresenter
+      end
+    end
+
+    context 'with product helper' do
+      before(:each) do
+        @controller = MyController.new
+        @controller.send :instance_variable_set, :@product, Product.new
+      end
+
+      context 'with plain presents' do
+        before(:each) do
+          MyController.presents :product
+        end
+
+        it 'presents product' do
+          expect(@controller.product.class).to be ProductPresenter
+        end
+
+        it 'memoizes presenter' do
+          presenter = @controller.product
+          expect(@controller.product).to be presenter
+        end
+      end
+
+      context 'with only' do
+        before(:each) do
+          MyController.presents :product, :only => :show
+        end
+
+        it 'presents on action' do
+          @controller.action_name = "show"
+          expect(@controller.product.class).to be ProductPresenter
+        end
+
+        it 'does not present on action' do
+          expect{@controller.product}.to raise_error NoMethodError
+        end
+      end
+
+      context 'with shadowed method, multiple presents with' do
+        before(:each) do
+          stub_const('Presenter1', Class.new(StrongPresenter::Presenter))
+          stub_const('Presenter2', Class.new(StrongPresenter::Presenter))
+          MyController.send(:define_method, :product) {|number| "Product ##{number}"}
+          MyController.presents :product, :with => Presenter1, :only => :unused
+          MyController.presents :product, :except => :index
+          MyController.presents :product, :with => Presenter1, :only => :show
+          MyController.presents :product, :with => Presenter2, :only => :edit
+        end
+
+        it 'presents show on show' do
+          @controller.action_name = "show"
+          expect(@controller.product.class).to be Presenter1
+        end
+
+        it 'presents show on edit' do
+          @controller.action_name = "edit"
+          expect(@controller.product.class).to be Presenter2
+        end
+
+        it 'presents default on other' do
+          expect(@controller.product.class).to be ProductPresenter
+        end
+
+        it 'presents default on shadowed unused presents' do
+          @controller.action_name = "unused"
+          expect(@controller.product.class).to be ProductPresenter
+        end
+
+        it 'falls back to original method without match' do
+          @controller.action_name = "index"
+          expect(@controller.product(5)).to eq "Product #5"
+        end
+      end
+    end
+  end
+end

data/spec/strong_presenter/helper_proxy_spec.rb

@@ -0,0 +1,53 @@
+require 'spec_helper'
+
+module StrongPresenter
+  describe HelperProxy do
+    describe "#initialize" do
+      it "sets the view context" do
+        view_context = double
+        helper_proxy = HelperProxy.new(view_context)
+
+        expect(helper_proxy.send(:view_context)).to be view_context
+      end
+    end
+
+    describe "#method_missing" do
+      protect_class HelperProxy
+
+      it "proxies methods to the view context" do
+        view_context = double
+        helper_proxy = HelperProxy.new(view_context)
+
+        view_context.stub(:foo).and_return{|arg| arg}
+        expect(helper_proxy.foo(:passed)).to be :passed
+      end
+
+      it "passes blocks" do
+        view_context = double
+        helper_proxy = HelperProxy.new(view_context)
+
+        view_context.stub(:foo).and_return{|&block| block.call}
+        expect(helper_proxy.foo{:yielded}).to be :yielded
+      end
+
+      it "defines the method for better performance" do
+        helper_proxy = HelperProxy.new(double(foo: "bar"))
+
+        expect(HelperProxy.instance_methods).not_to include :foo
+        helper_proxy.foo
+        expect(HelperProxy.instance_methods).to include :foo
+      end
+    end
+
+    describe "proxying methods which are overriding" do
+      it "proxies :capture" do
+        view_context = double
+        helper_proxy = HelperProxy.new(view_context)
+
+        view_context.stub(:capture).and_return{|*args, &block| [*args, block.call] }
+        expect(helper_proxy.capture(:first_arg, :second_arg){:yielded}).to \
+          be_eql [:first_arg, :second_arg, :yielded]
+      end
+    end
+  end
+end

data/spec/strong_presenter/permissible_spec.rb

@@ -2,22 +2,22 @@ require 'spec_helper'
 
 module StrongPresenter
   describe Permissible do
-    it "filters permitted attributes" do
+    it "selects permitted attributes" do
       object = Model.new
       presenter = Presenter.new(object)
       
-      presenter.permit :a, :b, :c
-      permitted = presenter.filter :a, :c, :z
+      presenter.permit! :a, :b, :c
+      permitted = presenter.select_permitted :a, :c, :z
       expect(permitted).to include(:a, :c)
       expect(permitted).to_not include(:b, :z)
     end
 
-    it "permits all if permit!" do
+    it "permits all if permit_all!" do
       object = Model.new
       presenter = Presenter.new(object)
 
-      presenter.permit!
-      permitted = presenter.filter :a, :b, :c
+      presenter.permit_all!
+      permitted = presenter.select_permitted :a, :b, :c
       expect(permitted).to include(:a, :b, :c)
     end
   end

data/spec/strong_presenter/permissions_spec.rb

@@ -16,131 +16,148 @@ module StrongPresenter
 
     describe "#permit" do
       it 'permits an attribute' do
-        expect(Permissions.new.permit([], :attr).permitted?([], :attr)).to be true
-      end
-
-      it 'permits with prefix' do
-        expect(Permissions.new.permit(:prefix, :attr).permitted?(:prefix, :attr)).to be true
+        expect(Permissions.new.permit(:attr).permitted?(:attr)).to be true
       end
 
       it 'permits with arrays of symbols' do
-        expect(Permissions.new.permit([:prefix, :array], [:attr, :array]).permitted?([:prefix, :array], [:attr, :array])).to be true
+        expect(Permissions.new.permit([:attr, :array]).permitted?([:attr, :array])).to be true
       end
 
       it 'permits multiple at once' do
-        permissions = Permissions.new.permit([:prefix, :array], [:attr, :array], :attr2, :attr3)
-        expect(permissions.permitted?([:prefix, :array], :attr2)).to be true
-        expect(permissions.permitted?([:prefix, :array], [:attr, :array])).to be true
+        permissions = Permissions.new.permit([:another, :array], [:attr, :array], :attr2, :attr3)
+        expect(permissions.permitted?(:attr2)).to be true
+        expect(permissions.permitted?([:attr, :array])).to be true
       end
 
       it 'does not mutate arguments' do
-        prefix = [:pre, :fix]
         attrpaths = [[:attr, :path], :s]
-        Permissions.new.permit(prefixarg = prefix.dup, attrpathsarg = attrpaths.dup)
+        Permissions.new.permit(attrpathsarg = attrpaths.dup)
 
-        expect(prefixarg).to eq prefix
         expect(attrpathsarg).to eq attrpaths
       end
+
+      it 'permits specific path after wildcard' do
+        permissions = Permissions.new.permit([:prefix, :*])
+        expect(permissions.permitted?([:prefix, "specific".taint])).to be false
+        permissions.permit([:prefix, :specific])
+        expect(permissions.permitted?([:prefix, "specific".taint])).to be true
+      end
     end
 
     describe "#permitted?" do
       context 'with some attributes permitted' do
         before(:all) do
-          @permissions = Permissions.new.permit([:prefix, :array], [:attr, :array], :attr2, :attr3)
+          @permissions = Permissions.new.permit([:another, :array], [:attr, :array], :attr2, :attr3, [:a, :wildcard, :*], [:wild, :**])
+        end
+
+        it 'permits single wildcard' do
+          expect(@permissions.permitted?([:a, :wildcard, :irrelevant])).to be true
         end
 
-        it 'permits more specific paths' do
-          expect(@permissions.permitted?([:prefix, :array], [:attr2, :irrelevant])).to be true
+        it 'permits full wildcard' do
+          expect(@permissions.permitted?([:wild, :wildcard, :irrelevant])).to be true
+          expect(@permissions.permitted?([:wild, :irrelevant])).to be true
         end
 
         it 'does not permit un-prefixed path' do
-          expect(@permissions.permitted?(:attr2)).to be false
-          expect(@permissions.permitted?([:attr2, :irrelevant])).to be false
+          permissions = Permissions.new(@permissions, :attr)
+          expect(permissions.permitted?(:attr2)).to be false
+          expect(permissions.permitted?([:wild, :irrelevant])).to be false
         end
 
-        it 'permits changed prefix boundaries' do
-          expect(@permissions.permitted?([:prefix, :array, :attr2], [:irrelevant])).to be true
-          expect(@permissions.permitted?(:prefix, [:array, :attr2, :irrelevant])).to be true
-          expect(@permissions.permitted?([:prefix], [:array, :attr2, :irrelevant])).to be true
-          expect(@permissions.permitted?([], [:prefix, :array, :attr2, :irrelevant])).to be true
+        it 'permits with prefix' do
+          permissions = Permissions.new(@permissions, :attr)
+          expect(permissions.permitted?(:array)).to be true
         end
 
         it 'does not permit other attributes' do
-          expect(@permissions.permitted?([:prefix, :array], [:attr4, :irrelevant])).to be false
+          expect(@permissions.permitted?([:attr4, :irrelevant])).to be false
         end
 
         it 'does not permit shortened paths' do
-          expect(@permissions.permitted?([:prefix, :array], :attr)).to be false
+          expect(@permissions.permitted?(:attr)).to be false
         end
 
         it 'does not mutate arguments' do
-          prefix = [:pre, :fix]
           attrpaths = [[:attr, :path], :s, [:array, :attr2]]
 
-          @permissions.permitted?(prefixarg = prefix.dup, attrpathsarg = attrpaths.dup)
-          expect(prefixarg).to eq prefix
+          @permissions.permitted?(attrpathsarg = attrpaths.dup)
           expect(attrpathsarg).to eq attrpaths
 
           prefix = [:prefix]
-          @permissions.permitted?(prefixarg = prefix.dup, attrpathsarg = attrpaths.dup)
-          expect(prefixarg).to eq prefix
+          @permissions.permitted?(attrpathsarg = attrpaths.dup)
           expect(attrpathsarg).to eq attrpaths
         end
+
+        it 'is indifferent to strings' do
+          expect(@permissions.permitted?(["attr","array"])).to be true
+          expect(@permissions.permitted?("a/wildcard/irrelevant".split("/"))).to be true
+        end
+
+        it 'does not permit single wildcard if tainted' do
+          expect(@permissions.permitted?([:a, :wildcard, "irrelevant".taint])).to be false
+        end
+
+        it 'does not permit full wildcard if tainted' do
+          expect(@permissions.permitted?(["wild".taint, :wildcard, :irrelevant])).to be false
+          expect(@permissions.permitted?(["wild", "irrelevant"].taint)).to be false
+          expect(@permissions.permitted?("a/wildcard/irrelevant".taint.split("/"))).to be false
+        end
       end
 
       context 'with permit all' do
-        it 'everything is true' do
+        it 'all methods are true' do
           permissions = Permissions.new.permit_all!
           expect(permissions.permitted?(:a)).to be true
-          expect(permissions.permitted?([:a])).to be true
-          expect(permissions.permitted?([:a,:b])).to be true
-          expect(permissions.permitted?(:a,:b)).to be true
-          expect(permissions.permitted?([],:a)).to be true
-          expect(permissions.permitted?([],[:a])).to be true
-          expect(permissions.permitted?([:x,:y],[:a])).to be true
-          expect(permissions.permitted?([],[:a,:b])).to be true
+          expect(permissions.permitted?(:b)).to be true
+        end
+
+        it 'association methods are false' do
+          permissions = Permissions.new.permit_all!
+          expect(permissions.permitted?([:a,:a])).to be false
         end
       end
     end
     describe "#select_permitted" do
       context 'with some attributes permitted' do
         before(:all) do
-          @permissions = Permissions.new.permit([:prefix, :array], [:attr, :array], :attr2, :attr3)
-          @permissions.permit([], [:attr, :array], :attr2, :attr3)
+          @permissions = Permissions.new.permit([:another, :array], [:attr, :array, :*], :attr2, :attr3)
+          @permissions.permit([], [:attr, :arrays], :attr2, :attr3)
         end
 
         it 'can select something which is permitted' do
-          expect(@permissions.select_permitted([], :attr2)).to eq [[:attr2]]
-          expect(@permissions.select_permitted([:prefix], [:array, :attr2, :irrelevant])).to eq [[:array, :attr2, :irrelevant]]
-          expect(@permissions.select_permitted([:prefix, :array], [:attr2, :irrelevant])).to eq [[:attr2, :irrelevant]]
+          expect(@permissions.select_permitted(:attr2)).to eq [:attr2]
+          expect(@permissions.select_permitted([:attr, :array, :irrelevant])).to eq [[:attr, :array, :irrelevant]]
+          expect(@permissions.select_permitted([:another, :array])).to eq [[:another, :array]]
+        end
+
+        it 'does not select wildcard path without wildcard' do
+          expect(@permissions.select_permitted([:attr, :array])).to be_empty
         end
 
         it 'can select multiple permitted attributes' do
-          attribute_paths = [:attr2, :attr3, [:attr2, :irrelevant], [:attr, :array]]
-          permitted = @permissions.select_permitted([:prefix, :array], *attribute_paths)
+          attribute_paths = [[:attr2], :attr3, [:another, :array], [:attr, :array, :method]]
+          permitted = @permissions.select_permitted(*attribute_paths)
           attribute_paths.each do |attribute_path|
-            expect(permitted).to include Array(attribute_path)
+            expect(permitted).to include attribute_path
           end
         end
 
         it 'selects only permitted attributes in the original order' do
-          permitted_paths = [:attr2, :attr3, [:attr2, :irrelevant], [:attr, :array], [:attr3, :ir]]
-          unpermitted_paths = [:attr4, :attr5, [:attrk, :irrelevant], [:attr, :ar]]
+          permitted_paths = [:attr2, :attr3, [:attr, :arrays], [:attr, :array, :meth], [:attr3]]
+          unpermitted_paths = [:attr4, :attr5, [:attrk, :irrelevant], [:attr, :ar], [:attr, :arrays, :more]]
           attribute_paths = (unpermitted_paths + permitted_paths).shuffle
-          expect(@permissions.select_permitted([:prefix, :array], *attribute_paths)).to eq((attribute_paths & permitted_paths).map{|a|Array(a)})
+          expect(@permissions.select_permitted(*attribute_paths)).to eq((attribute_paths & permitted_paths))
         end
 
         it 'does not mutate arguments' do
-          prefix = [:pre, :fix]
           attrpaths = [[:attr, :path], :s, [:array, :attr2]]
 
-          @permissions.select_permitted(prefixarg = prefix.dup, attrpathsarg = attrpaths.dup)
-          expect(prefixarg).to eq prefix
+          @permissions.select_permitted(attrpathsarg = attrpaths.dup)
           expect(attrpathsarg).to eq attrpaths
 
-          prefix = [:prefix]
-          @permissions.select_permitted(prefixarg = prefix.dup, attrpathsarg = attrpaths.dup)
-          expect(prefixarg).to eq prefix
+          attrpaths = [[:attr, :array, :meth], :s, [:array, :attr2]]
+          @permissions.select_permitted(attrpathsarg = attrpaths.dup)
           expect(attrpathsarg).to eq attrpaths
         end
       end
@@ -148,37 +165,34 @@ module StrongPresenter
       context 'with permit all' do
         it 'everything is selected' do
           permissions = Permissions.new.permit_all!
-          attribute_paths = [:attr2, :attr3, [:attr2, :irrelevant], [:attr, :array]]
+          attribute_paths = [:attr2, :attr3, :attr2, :attr, :array]
           permitted = permissions.select_permitted([:prefix, :array], *attribute_paths)
-          expect(permitted).to eq(attribute_paths.map{|a|Array(a)})
+          expect(permitted).to eq(attribute_paths)
         end
       end
     end
     describe "#reject_permitted" do
       context 'with some attributes permitted' do
         before(:all) do
-          @permissions = Permissions.new.permit([:prefix, :array], [:attr, :array], :attr2, :attr3)
-          @permissions.permit([], [:attr, :array], :attr2, :attr3)
+          @permissions = Permissions.new.permit([:another, :array], [:attr, :array, :*], :attr2, :attr3)
+          @permissions.permit([], [:attr, :arrays], :attr2, :attr3)
         end
 
         it 'selects only unpermitted attributes in the original order' do
-          permitted_paths = [:attr2, :attr3, [:attr2, :irrelevant], [:attr, :array], [:attr3, :ir]]
-          unpermitted_paths = [:attr4, :attr5, [:attrk, :irrelevant], [:attr, :ar]]
+          permitted_paths = [:attr2, :attr3, [:attr, :arrays], [:attr, :array, :meth], [:attr3]]
+          unpermitted_paths = [:attr4, :attr5, [:attrk, :irrelevant], [:attr, :ar], [:attr, :arrays, :more]]
           attribute_paths = (unpermitted_paths + permitted_paths).shuffle
-          expect(@permissions.reject_permitted([:prefix, :array], *attribute_paths)).to eq((attribute_paths & unpermitted_paths).map{|a|Array(a)})
+          expect(@permissions.reject_permitted(*attribute_paths)).to eq((attribute_paths & unpermitted_paths))
         end
 
         it 'does not mutate arguments' do
-          prefix = [:pre, :fix]
           attrpaths = [[:attr, :path], :s, [:array, :attr2]]
 
-          @permissions.reject_permitted(prefixarg = prefix.dup, attrpathsarg = attrpaths.dup)
-          expect(prefixarg).to eq prefix
+          @permissions.reject_permitted(attrpathsarg = attrpaths.dup)
           expect(attrpathsarg).to eq attrpaths
 
-          prefix = [:prefix]
-          @permissions.reject_permitted(prefixarg = prefix.dup, attrpathsarg = attrpaths.dup)
-          expect(prefixarg).to eq prefix
+          attrpaths = [[:attr, :array, :meth], :s, [:array, :attr2]]
+          @permissions.reject_permitted(attrpathsarg = attrpaths.dup)
           expect(attrpathsarg).to eq attrpaths
         end
       end