dry-view 0.2.0 → 0.2.1

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA1:
-  metadata.gz: 5cf179c08c3deb29086bc87197420a301595a70f
-  data.tar.gz: 1c6eccdfb39502b559748c8c75d4c4b127b16019
+  metadata.gz: f4a41e09f937605f77be24092d9da6ff653da34d
+  data.tar.gz: 5bde51853d38d892bbbba62f42acacfebcfd71b4
 SHA512:
-  metadata.gz: 390c86f0b801d44bfe8a5958a982da88a52030dbfbf4403380af90c82c1279d3603a0f4376d1b2f349f3e42f36628c3a551b37e3fe8d2d75874b77d1e4d1efb3
-  data.tar.gz: cfdc7df2e7d8b63cda8611d203d9ec39da0a31d9237e742a00e861244556b2cfc5854b09a312abb358f77c572d4102b56d707d74ee27a61154fb7d6c44952756
+  metadata.gz: b5121bec86b8fa020f4e46dd12beae722fee4eb135a000efff37926061e376206ca507aaea6a3334707df618d9368ca5201af041581fe6f4fedc626ed643df0e
+  data.tar.gz: 422541634a6634adfdac9cb2fa8e82e0b8cc35efc8aaf9dfe669a08394020ead0ce776a5564bb5819c701a43959f95c8d638a51d4ba389433c7b1fc09f88a3c7

data/CHANGELOG.md

@@ -1,3 +1,9 @@
+# 0.2.1 / 2017-01-30
+
+### Fixed
+
+- Exposure blocks now have access to the view controller instance when they're called (timriley)
+
 # 0.2.0 / 2017-01-30
 
 This release is a major reorientation for dry-view, and it should allow for more natural, straightforward template authoring.

data/lib/dry/view/controller.rb

@@ -48,7 +48,7 @@ module Dry
           exposures.add(names.first, block, **options)
         else
           names.each do |name|
-            exposures.add(name, nil, **options)
+            exposures.add(name, **options)
           end
         end
       end

data/lib/dry/view/exposure.rb

@@ -5,28 +5,30 @@ module Dry
 
       attr_reader :name
       attr_reader :proc
+      attr_reader :object
       attr_reader :to_view
 
-      def initialize(name, proc = nil, to_view: true)
-        ensure_proc_parameters(proc) if proc
-
+      def initialize(name, proc = nil, object = nil, to_view: true)
         @name = name
-        @proc = proc
+        @proc = prepare_proc(proc, object)
+        @object = object
         @to_view = to_view
       end
 
       def bind(obj)
-        proc ? self : with_default_proc(obj)
+        self.class.new(name, proc, obj, to_view: to_view)
       end
 
       def dependencies
-        proc.parameters.map(&:last)
+        proc ? proc.parameters.map(&:last) : []
       end
 
       alias_method :to_view?, :to_view
 
       def call(input, locals = {})
-        params = dependencies.map.with_index { |name, position|
+        return input.fetch(name) unless proc
+
+        args = dependencies.map.with_index { |name, position|
           if position.zero?
             locals.fetch(name) { input }
           else
@@ -34,26 +36,24 @@ module Dry
           end
         }
 
-        proc.(*params)
+        call_proc(*args)
       end
 
       private
 
-      def with_default_proc(obj)
-        self.class.new(name, build_default_proc(obj), to_view: to_view)
-      end
-
-      def build_default_proc(obj)
-        if obj.respond_to?(name, _include_private = true)
-          obj.method(name)
+      def call_proc(*args)
+        if proc.is_a?(Method)
+          proc.(*args)
         else
-          -> input { input.fetch(name) }
+          object.instance_exec(*args, &proc)
         end
       end
 
-      def ensure_proc_parameters(proc)
-        if proc.parameters.any? { |type, _| !SUPPORTED_PARAMETER_TYPES.include?(type) }
-          raise ArgumentError, "+proc+ must take positional arugments only"
+      def prepare_proc(proc, object)
+        if proc
+          proc
+        elsif object.respond_to?(name, _include_private = true)
+          object.method(name)
         end
       end
     end

data/lib/dry/view/version.rb

@@ -1,5 +1,5 @@
 module Dry
   module View
-    VERSION = '0.2.0'.freeze
+    VERSION = '0.2.1'.freeze
   end
 end

data/spec/integration/exposures_spec.rb

@@ -1,7 +1,7 @@
 RSpec.describe 'exposures' do
   let(:context) { Struct.new(:title, :assets).new('dry-view rocks!', -> input { "#{input}.jpg" }) }
 
-  it 'uses exposures to build view locals' do
+  it 'uses exposures with blocks to build view locals' do
     vc = Class.new(Dry::View::Controller) do
       configure do |config|
         config.paths = SPEC_ROOT.join('fixtures/templates')
@@ -27,7 +27,40 @@ RSpec.describe 'exposures' do
     )
   end
 
-  it 'supports both blocks and instance methods as exposures' do
+  it 'gives the exposure blocks access to the view controller instance' do
+    vc = Class.new(Dry::View::Controller) do
+      configure do |config|
+        config.paths = SPEC_ROOT.join('fixtures/templates')
+        config.layout = 'app'
+        config.template = 'users'
+        config.default_format = :html
+      end
+
+      attr_reader :prefix
+
+      def initialize
+        super
+        @prefix = "My friend "
+      end
+
+      expose :users do |input|
+        input.fetch(:users).map { |user|
+          user.merge(name: prefix + user[:name])
+        }
+      end
+    end.new
+
+    users = [
+      { name: 'Jane', email: 'jane@doe.org' },
+      { name: 'Joe', email: 'joe@doe.org' }
+    ]
+
+    expect(vc.(users: users, context: context)).to eql(
+      '<!DOCTYPE html><html><head><title>dry-view rocks!</title></head><body><div class="users"><table><tbody><tr><td>My friend Jane</td><td>jane@doe.org</td></tr><tr><td>My friend Joe</td><td>joe@doe.org</td></tr></tbody></table></div><img src="mindblown.jpg" /></body></html>'
+    )
+  end
+
+  it 'supports instance methods as exposures' do
     vc = Class.new(Dry::View::Controller) do
       configure do |config|
         config.paths = SPEC_ROOT.join('fixtures/templates')

data/spec/unit/exposure_spec.rb

@@ -1,7 +1,8 @@
 RSpec.describe Dry::View::Exposure do
-  subject(:exposure) { described_class.new(:hello, proc) }
+  subject(:exposure) { described_class.new(:hello, proc, object) }
 
   let(:proc) { -> input { "hi" } }
+  let(:object) { nil }
 
   describe "initialization and attributes" do
     describe "#name" do
@@ -18,18 +19,17 @@ RSpec.describe Dry::View::Exposure do
       it "allows a nil proc" do
         expect(described_class.new(:hello).proc).to be_nil
       end
+    end
 
-      it "allows proc to take no arguments" do
-        proc = -> { "hi" }
-        expect { described_class.new(:hello, proc) }.not_to raise_error
-      end
+    describe "#object" do
+      let(:object) { Object.new }
 
-      it "requires proc to take positional arguments only" do
-        proc = -> a: "a" { "hi" }
-        expect { described_class.new(:hello, proc) }.to raise_error ArgumentError
+      it "accepts an object" do
+        expect(exposure.object).to eq object
+      end
 
-        proc = -> input, a: "a" { "hi" }
-        expect { described_class.new(:hello, proc) }.to raise_error ArgumentError
+      it "allows a nil object" do
+        expect(described_class.new(:hello).object).to be_nil
       end
     end
 
@@ -45,25 +45,29 @@ RSpec.describe Dry::View::Exposure do
   end
 
   describe "#bind" do
-    context "proc provided" do
-      subject(:bound_exposure) { exposure.bind(Object.new) }
+    subject(:bound_exposure) { exposure.bind(bind_object) }
 
-      it "returns itself" do
-        expect(bound_exposure).to eql exposure
-      end
+    let(:bind_object) { Object.new }
 
-      it "retains the same proc" do
+    it "returns a new object" do
+      expect(bound_exposure).not_to eql exposure
+    end
+
+    it "retains the bind object" do
+      expect(bound_exposure.object).to eq bind_object
+    end
+
+    context "proc is set" do
+      it "retains the existing proc" do
         expect(bound_exposure.proc).to eql proc
       end
     end
 
-    context "no proc provided" do
-      subject(:bound_exposure) { exposure.bind(object) }
-
-      let(:exposure) { described_class.new(:hello) }
+    context "proc is nil" do
+      let(:proc) { nil }
 
       context "matching instance method" do
-        let(:object) do
+        let(:bind_object) do
           Class.new do
             def hello(input)
               "hi there, #{input.fetch(:name)}"
@@ -71,75 +75,108 @@ RSpec.describe Dry::View::Exposure do
           end.new
         end
 
-        it "returns a new object" do
-          expect(bound_exposure).not_to eql exposure
-        end
-
         it "sets the proc to the method on the object matching the exposure's name" do
-          expect(bound_exposure.proc).to eql object.method(:hello)
+          expect(bound_exposure.proc).to eql bind_object.method(:hello)
         end
       end
 
       context "no matching instance method" do
         let(:object) { Object.new }
 
-        it "returns a new object" do
-          expect(bound_exposure).not_to eql exposure
-        end
-
-        it "builds a proc that passes through data from a matching key in the input" do
-          expect(bound_exposure.proc.(hello: "hello in input")).to eq "hello in input"
+        it "leaves proc as nil" do
+          expect(bound_exposure.proc).to be_nil
         end
       end
     end
   end
 
   describe "#dependencies" do
-    let(:proc) { -> input, foo, bar { "hi" } }
+    context "proc provided" do
+      let(:proc) { -> input, foo, bar { "hi" } }
 
-    it "returns an array of exposure dependencies derived from the proc's argument names" do
-      expect(exposure.dependencies).to eql [:input, :foo, :bar]
+      it "returns an array of exposure dependencies derived from the proc's argument names" do
+        expect(exposure.dependencies).to eql [:input, :foo, :bar]
+      end
     end
-  end
 
-  describe "#call" do
-    let(:input) { double("input") }
+    context "matching instance method" do
+      let(:proc) { nil }
+
+      let(:object) do
+        Class.new do
+          def hello(input, bar, baz)
+            "hi there, #{input.fetch(:name)}"
+          end
+        end.new
+      end
 
-    before do
-      allow(proc).to receive(:call)
+      it "returns an array of exposure dependencies derived from the instance method's argument names" do
+        expect(exposure.dependencies).to eql [:input, :bar, :baz]
+      end
     end
 
+    context "proc is nil" do
+      let(:proc) { nil }
+
+      it "returns no dependencies" do
+        expect(exposure.dependencies).to eql []
+      end
+    end
+  end
+
+  describe "#call" do
+    let(:input) { "input" }
+
     context "proc expects input only" do
-      it "sends the input to the proc" do
-        exposure.(input)
+      let(:proc) { -> input { input } }
 
-        expect(proc).to have_received(:call).with(input)
+      it "sends the input to the proc" do
+        expect(exposure.(input)).to eql "input"
       end
     end
 
     context "proc expects input and dependencies" do
-      let(:proc) { -> input, greeting { "#{greeting}, #{input.fetch(:name)}" } }
+      let(:proc) { -> input, greeting { "#{greeting}, #{input}" } }
       let(:locals) { {greeting: "Hola"} }
 
-      before do
-        exposure.(input, locals)
-      end
-
       it "sends the input and dependency values to the proc" do
-        expect(proc).to have_received(:call).with(input, "Hola")
+        expect(exposure.(input, locals)).to eq "Hola, input"
       end
     end
 
     context "proc expects dependencies only" do
-      let(:proc) { -> greeting, farewell { "#{greeting}, #{input.fetch(:name)}" } }
+      let(:proc) { -> greeting, farewell { "#{greeting}, #{farewell}" } }
       let(:locals) { {greeting: "Hola", farewell: "Adios"} }
 
-      before do
-        exposure.(input, locals)
+      it "sends the dependency values to the proc" do
+        expect(exposure.(input, locals)).to eq "Hola, Adios"
       end
+    end
 
-      it "sends the dependency values to the proc" do
-        expect(proc).to have_received(:call).with "Hola", "Adios"
+    context "proc accesses object instance" do
+      let(:proc) { -> input { "#{input} from #{name}" } }
+
+      let(:object) do
+        Class.new do
+          attr_reader :name
+
+          def initialize(name)
+            @name = name
+          end
+        end.new("Jane")
+      end
+
+      it "makes the instance available as self" do
+        expect(exposure.(input)).to eq "input from Jane"
+      end
+    end
+
+    context "no proc" do
+      let(:proc) { nil }
+      let(:input) { {hello: "hi there"} }
+
+      it "returns a matching key from the input" do
+        expect(exposure.(input)).to eq "hi there"
       end
     end
   end

metadata

@@ -1,7 +1,7 @@
 --- !ruby/object:Gem::Specification
 name: dry-view
 version: !ruby/object:Gem::Version
-  version: 0.2.0
+  version: 0.2.1
 platform: ruby
 authors:
 - Piotr Solnica