curlybars 1.2.1 → 1.3.0

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA256:
-  metadata.gz: 0fbfe78e305b68cad9c83ab0deafe39a1814b519ede424de8459dfe8f096bee1
-  data.tar.gz: 7fb5ee604e9379a73ef24cd607aea3a847656a3ecc6f3fddbedd0c4031b398fc
+  metadata.gz: 3c5f1fe84620e10957d38e663d3883158c00b6db25395c61e9628ddd3d19d110
+  data.tar.gz: 5eac82875ef4fca6a4c0aa728626615c643089ed6cc24de91232d793753f8f5b
 SHA512:
-  metadata.gz: 1f3d779a0858270de68a2715f6badb08290cf977ad792ea019ee8d5b6f20ecc837371129d98a97f2a118df2edff352ec41d71023b4789b05321315fac5847526
-  data.tar.gz: baeb86fd6563d5baca979bcc6cdd08f3a3a66b75bc29692fcbf366b7b3518725e2bd1fbdd6afa6b66567d95436f6d2d241c3d4c1cb81c6315a337df0aa9fc0aa
+  metadata.gz: 3697082fceb22d1d868d4de0fcf1054d8facc0e8dee7da0e58704bf34bb303a0cd287b460baa5d40ffcbf17ed7d0e3235643b7d855e57f821ed63223f1d737e3
+  data.tar.gz: dfba149b55705dbc9567a763dbc12b3514296a43ec576a683642f83f727d6d7ec4c49ffc514a4c2a9a4d1ec91740365dd144d2a87bde96d59b2632b8c24ed4df

data/lib/curlybars/method_whitelist.rb

@@ -1,27 +1,55 @@
 module Curlybars
   module MethodWhitelist
-    def allow_methods(*methods, **methods_with_type)
-      methods_with_type.each do |(method_name, type)|
-        if type.is_a?(Array)
-          if type.size != 1 || !type.first.respond_to?(:dependency_tree)
-            raise "Invalid allowed method syntax for `#{method_name}`. Collections must be of one presenter class"
+    def allow_methods(*methods_without_type, **methods_with_type, &contextual_block)
+      methods_with_type_validator = lambda do |methods_to_validate|
+        methods_to_validate.each do |(method_name, type)|
+          if type.is_a?(Array)
+            if type.size != 1 || !type.first.respond_to?(:dependency_tree)
+              raise "Invalid allowed method syntax for `#{method_name}`. Collections must be of one presenter class"
+            end
           end
         end
       end
 
+      methods_with_type_validator.call(methods_with_type)
+
       define_method(:allowed_methods) do
-        methods_list = methods + methods_with_type.keys
+        methods_list = methods_without_type + methods_with_type.keys
+
+        # Adds methods to the list of allowed methods
+        method_adder = lambda do |*more_methods, **more_methods_with_type|
+          methods_with_type_validator.call(more_methods_with_type)
+
+          methods_list += more_methods
+          methods_list += more_methods_with_type.keys
+        end
+
+        contextual_block&.call(self, method_adder)
+
         defined?(super) ? super() + methods_list : methods_list
       end
 
-      define_singleton_method(:methods_schema) do |*args|
-        schema = methods.each_with_object({}) do |method, memo|
+      define_singleton_method(:methods_schema) do |context = nil|
+        all_methods_without_type = methods_without_type
+        all_methods_with_type = methods_with_type
+
+        # Adds methods to the schema
+        schema_adder = lambda do |*more_methods_without_type, **more_methods_with_type|
+          methods_with_type_validator.call(more_methods_with_type)
+
+          all_methods_without_type += more_methods_without_type
+          all_methods_with_type = all_methods_with_type.merge(more_methods_with_type)
+        end
+
+        contextual_block&.call(context, schema_adder)
+
+        schema = all_methods_without_type.each_with_object({}) do |method, memo|
           memo[method] = nil
         end
 
-        methods_with_type_resolved = methods_with_type.each_with_object({}) do |(method_name, type), memo|
+        methods_with_type_resolved = all_methods_with_type.each_with_object({}) do |(method_name, type), memo|
           memo[method_name] = if type.respond_to?(:call)
-            type.call(*args)
+            type.call(context)
           else
             type
           end
@@ -30,26 +58,26 @@ module Curlybars
         schema.merge!(methods_with_type_resolved)
 
         # Inheritance
-        schema.merge!(super(*args)) if defined?(super)
+        schema.merge!(super(context)) if defined?(super)
 
         # Included modules
         included_modules.each do |mod|
           next unless mod.respond_to?(:methods_schema)
-          schema.merge!(mod.methods_schema(*args))
+          schema.merge!(mod.methods_schema(context))
         end
 
         schema
       end
 
-      define_singleton_method(:dependency_tree) do |*args|
-        methods_schema(*args).each_with_object({}) do |method_with_type, memo|
+      define_singleton_method(:dependency_tree) do |context = nil|
+        methods_schema(context).each_with_object({}) do |method_with_type, memo|
           method_name = method_with_type.first
           type = method_with_type.last
 
           memo[method_name] = if type.respond_to?(:dependency_tree)
-            type.dependency_tree(*args)
+            type.dependency_tree(context)
           elsif type.is_a?(Array)
-            [type.first.dependency_tree(*args)]
+            [type.first.dependency_tree(context)]
           else
             type
           end

data/lib/curlybars/version.rb

@@ -1,3 +1,3 @@
 module Curlybars
-  VERSION = '1.2.1'.freeze
+  VERSION = '1.3.0'.freeze
 end

data/spec/curlybars/method_whitelist_spec.rb

@@ -1,5 +1,30 @@
 describe Curlybars::MethodWhitelist do
-  let(:dummy_class) { Class.new { extend Curlybars::MethodWhitelist } }
+  let(:dummy_class) do
+    Class.new do
+      extend Curlybars::MethodWhitelist
+
+      # A method available in the context
+      def foo?
+        true
+      end
+
+      def qux?
+        false
+      end
+    end
+  end
+
+  let(:validation_context_class) do
+    Class.new do
+      def foo?
+        true
+      end
+
+      def qux?
+        false
+      end
+    end
+  end
 
   describe "#allowed_methods" do
     it "returns an empty array as default" do
@@ -21,6 +46,25 @@ describe Curlybars::MethodWhitelist do
       expect(dummy_class.new.allowed_methods).to eq([:cook, :link, :article])
     end
 
+    it "supports adding more methods for validation" do
+      dummy_class.class_eval do
+        allow_methods do |context, allow_method|
+          if context.foo?
+            allow_method.call(:bar)
+          end
+
+          if context.qux?
+            allow_method.call(:quux)
+          end
+        end
+      end
+
+      aggregate_failures "test both allowed_methods and allows_method?" do
+        expect(dummy_class.new.allowed_methods).to eq([:bar])
+        expect(dummy_class.new.allows_method?(:bar)).to eq(true)
+      end
+    end
+
     it "raises when collection is not of presenters" do
       expect do
         dummy_class.class_eval { allow_methods :cook, links: ["foobar"] }
@@ -79,6 +123,68 @@ describe Curlybars::MethodWhitelist do
           wave: nil
         )
     end
+
+    context "with context dependent methods" do
+      let(:base_presenter) do
+        stub_const("LinkPresenter", Class.new)
+
+        Class.new do
+          extend Curlybars::MethodWhitelist
+          allow_methods :cook, link: LinkPresenter do |context, allow_method|
+            if context.foo?
+              allow_method.call(:bar)
+            end
+          end
+
+          def foo?
+            true
+          end
+        end
+      end
+
+      let(:helpers) do
+        Module.new do
+          extend Curlybars::MethodWhitelist
+          allow_methods :form do |context, allow_method|
+            if context.foo?
+              allow_method.call(foo_bar: :helper)
+            end
+          end
+
+          def foo?
+            true
+          end
+        end
+      end
+
+      let(:post_presenter) do
+        Class.new(base_presenter) do
+          extend Curlybars::MethodWhitelist
+          include Helpers
+          allow_methods :wave
+        end
+      end
+
+      before do
+        stub_const("Helpers", helpers)
+      end
+
+      it "allows context methods from inheritance and composition" do
+        expect(post_presenter.new.allowed_methods).to eq([:cook, :link, :bar, :form, :foo_bar, :wave])
+      end
+
+      it "returns a dependency_tree with inheritance and composition with context" do
+        expect(post_presenter.dependency_tree(validation_context_class.new)).
+          to eq(
+            cook: nil,
+            link: LinkPresenter,
+            form: nil,
+            wave: nil,
+            bar: nil,
+            foo_bar: :helper
+          )
+      end
+    end
   end
 
   describe ".methods_schema" do
@@ -110,16 +216,22 @@ describe Curlybars::MethodWhitelist do
       expect(dummy_class.methods_schema).to eq(links: [LinkPresenter])
     end
 
-    it "supports procs in schema" do
-      dummy_class.class_eval { allow_methods settings: -> { { color_1: nil } } }
+    it "supports procs with context in schema" do
+      dummy_class.class_eval { allow_methods settings: ->(context) { context.foo? ? Hash[:background_color, nil] : nil } }
 
-      expect(dummy_class.methods_schema).to eq(settings: { color_1: nil })
+      expect(dummy_class.methods_schema(validation_context_class.new)).to eq(settings: { background_color: nil })
     end
 
-    it "supports procs with arguments in schema" do
-      dummy_class.class_eval { allow_methods settings: ->(name) { Hash[name, nil] } }
+    it "supports context methods" do
+      dummy_class.class_eval do
+        allow_methods do |context, allow_method|
+          if context.foo?
+            allow_method.call(:bar)
+          end
+        end
+      end
 
-      expect(dummy_class.methods_schema(:background_color)).to eq(settings: { background_color: nil })
+      expect(dummy_class.methods_schema(validation_context_class.new)).to eq(bar: nil)
     end
   end
 

metadata

@@ -1,7 +1,7 @@
 --- !ruby/object:Gem::Specification
 name: curlybars
 version: !ruby/object:Gem::Version
-  version: 1.2.1
+  version: 1.3.0
 platform: ruby
 authors:
 - Libo Cannici
@@ -13,7 +13,7 @@ authors:
 autorequire: 
 bindir: bin
 cert_chain: []
-date: 2019-11-14 00:00:00.000000000 Z
+date: 2019-12-17 00:00:00.000000000 Z
 dependencies:
 - !ruby/object:Gem::Dependency
   name: actionpack