dry-view 0.5.3 → 0.6.0

data/spec/unit/exposures_spec.rb

@@ -1,103 +0,0 @@
-RSpec.describe Dry::View::Exposures do
-  subject(:exposures) { described_class.new }
-
-  describe "#exposures" do
-    it "is empty by defalut" do
-      expect(exposures.exposures).to be_empty
-    end
-  end
-
-  describe "#add" do
-    it "creates and adds an exposure" do
-      proc = -> **input { "hi" }
-      exposures.add :hello, proc
-
-      expect(exposures[:hello].name).to eq :hello
-      expect(exposures[:hello].proc).to eq proc
-    end
-  end
-
-  describe "#bind" do
-    subject(:bound_exposures) { exposures.bind(object) }
-
-    let(:object) do
-      Class.new do
-        def hello(input)
-          "hi"
-        end
-      end.new
-    end
-
-    before do
-      exposures.add(:hello)
-    end
-
-    it "binds each of the exposures" do
-      expect(bound_exposures[:hello].proc).to eq object.method(:hello)
-    end
-
-    it "returns a new copy of the exposures" do
-      expect(exposures.exposures).not_to eql(bound_exposures.exposures)
-    end
-  end
-
-  describe "#locals" do
-    before do
-      exposures.add(:greeting, -> greeting: { greeting.upcase })
-      exposures.add(:farewell, -> greeting { "#{greeting} and goodbye" })
-    end
-
-    subject(:locals) { exposures.locals(greeting: "hello") }
-
-    it "returns the values from the exposures' procs" do
-      expect(locals).to eq(greeting: "HELLO", farewell: "HELLO and goodbye")
-    end
-
-    it "does not return any values from private exposures" do
-      exposures.add(:hidden, -> **input { "shh" }, private: true)
-
-      expect(locals).to include(:greeting, :farewell)
-      expect(locals).not_to include(:hidden)
-    end
-  end
-
-  describe "#locals default value" do
-    it "returns 'default_value' from exposure" do
-      exposures.add(:name, default: 'John')
-      locals = exposures.locals({})
-
-      expect(locals).to eq(:name=>"John")
-    end
-
-    it "returns values from arguments" do
-      exposures.add(:name, default: 'John')
-      locals = exposures.locals(name: 'William')
-
-      expect(locals).to eq(:name=>"William")
-    end
-
-    it "returns values from arguments even when value is nil" do
-      exposures.add(:name, default: 'John')
-      locals = exposures.locals(name: nil)
-
-      expect(locals).to eq(:name=>nil)
-    end
-
-    it "returns value from proc" do
-      exposures.add(:name, -> name: { name.upcase }, default: 'John')
-      locals = exposures.locals(name: 'William')
-
-      expect(locals).to eq(:name=>"WILLIAM")
-    end
-  end
-
-  describe "#import" do
-    it "imports a exposure to the exposures" do
-      exposures_b = described_class.new
-      exposures.add(:name, -> name: { name.upcase }, default: 'John')
-      exposures_b.import(:name, exposures[:name])
-
-      expect(exposures_b[:name]).to eq(exposures[:name])
-    end
-  end
-end

data/spec/unit/part_spec.rb

@@ -1,104 +0,0 @@
-RSpec::Matchers.define :template_scope do |locals|
-  match do |actual|
-    locals == locals.map { |k,v| [k, actual.send(k)] }.to_h
-  end
-end
-
-RSpec.describe Dry::View::Part do
-  context 'with a renderer' do
-    subject(:part) { described_class.new(name: name, value: value, renderer: renderer, context: context) }
-
-    let(:name) { :user }
-    let(:value) { double(:value) }
-    let(:context) { double(:context) }
-    let(:renderer) { spy(:renderer) }
-
-    describe '#render' do
-      it 'renders a partial with the part available in its scope' do
-        part.render(:info)
-        expect(renderer).to have_received(:partial).with(:info, template_scope(user: part))
-      end
-
-      it 'allows the part to be made available on a different name' do
-        part.render(:info, as: :admin)
-        expect(renderer).to have_received(:partial).with(:info, template_scope(admin: part))
-      end
-
-      it 'includes extra locals in the scope' do
-        part.render(:info, extra_local: "hello")
-        expect(renderer).to have_received(:partial).with(:info, template_scope(user: part, extra_local: "hello"))
-      end
-    end
-
-    describe '#to_s' do
-      before do
-        allow(value).to receive(:to_s).and_return 'to_s on the value'
-      end
-
-      it 'delegates to the wrapped value' do
-        expect(part.to_s).to eq 'to_s on the value'
-      end
-    end
-
-    describe '#new' do
-      it 'preserves decorator, renderer, and context' do
-        new_part = part.new(value: 'new value')
-
-        expect(new_part._decorator).to eql part._decorator
-        expect(new_part._renderer).to eql part._renderer
-        expect(new_part._context).to eql part._context
-      end
-    end
-
-    describe '#method_missing' do
-      let(:value) { double(greeting: 'hello from value') }
-
-      it 'calls a matching method on the value' do
-        expect(part.greeting).to eq 'hello from value'
-      end
-
-      it 'forwards all arguments to the method' do
-        blk = -> { }
-        part.greeting 'args', &blk
-
-        expect(value).to have_received(:greeting).with('args', &blk)
-      end
-
-      it 'raises an error if no metho matches' do
-        expect { part.farewell }.to raise_error(NoMethodError)
-      end
-    end
-
-    describe '#respond_to_missing?' do
-      let(:value) { double(greeting: 'hello from value') }
-
-      it 'handles convenience methods' do
-        expect(part).to respond_to(:context)
-        expect(part).to respond_to(:render)
-        expect(part).to respond_to(:value)
-      end
-
-      it 'handles value methods' do
-        expect(part).to respond_to(:greeting)
-      end
-    end
-  end
-
-  context 'without a renderer' do
-    subject(:part) { described_class.new(name: name, value: value, context: context) }
-
-    let(:name) { :user }
-    let(:value) { double('value') }
-    let(:context) { double('context') }
-
-    describe '#initialize' do
-      it 'can be initialized' do
-        expect(part).to be_an_instance_of(Dry::View::Part)
-      end
-
-      it 'raises an exception when render is called' do
-        expect { part.render(:info) }.to raise_error(Dry::View::MissingRendererError).with_message('No renderer provided')
-      end
-    end
-  end
-end

data/spec/unit/renderer_spec.rb

@@ -1,57 +0,0 @@
-require 'dry/view/path'
-require 'dry/view/renderer'
-
-RSpec.describe Dry::View::Renderer do
-  subject(:renderer) do
-    Dry::View::Renderer.new(
-      [Dry::View::Path.new(SPEC_ROOT.join('fixtures/templates'))],
-      format: 'html'
-    )
-  end
-
-  let(:scope) { double(:scope) }
-
-  describe '#template' do
-    it 'renders template in current directory' do
-      expect(renderer.template(:hello, scope)).to eql('<h1>Hello</h1>')
-    end
-
-    it 'renders template in shared/ subdirectory' do
-      expect(renderer.template(:_shared_hello, scope)).to eql('<h1>Hello</h1>')
-    end
-
-    it 'renders template in upper directory' do
-      expect(renderer.chdir('nested').template(:_shared_hello, scope)).to eql('<h1>Hello</h1>')
-    end
-
-    it 'raises error when template cannot be found' do
-      expect {
-        renderer.template(:missing_template, scope)
-      }.to raise_error(Dry::View::Renderer::TemplateNotFoundError, /missing_template/)
-    end
-  end
-
-  describe '#partial' do
-    it 'renders partial in current directory' do
-      expect(renderer.partial(:hello, scope)).to eql('<h1>Partial hello</h1>')
-    end
-
-    it 'renders partial in shared/ subdirectory' do
-      expect(renderer.partial(:shared_hello, scope)).to eql('<h1>Hello</h1>')
-    end
-
-    it 'renders partial in upper directory' do
-      expect(renderer.chdir('nested').partial(:hello, scope)).to eql('<h1>Partial hello</h1>')
-    end
-
-    it 'renders partial in upper shared/ subdirectory' do
-      expect(renderer.chdir('nested').partial(:shared_hello, scope)).to eql('<h1>Hello</h1>')
-    end
-
-    it 'raises error when partial cannot be found' do
-      expect {
-        renderer.partial(:missing_partial, scope)
-      }.to raise_error(Dry::View::Renderer::TemplateNotFoundError, /_missing_partial/)
-    end
-  end
-end

data/spec/unit/scope_spec.rb

@@ -1,53 +0,0 @@
-RSpec.describe Dry::View::Scope do
-  subject(:scope) { described_class.new(renderer: renderer, context: context, locals: locals) }
-
-  let(:locals) { {} }
-  let(:context) { double(:context) }
-  let(:renderer) { spy(:renderer) }
-
-  describe '#render' do
-    it 'renders a partial with itself as the scope' do
-      scope.render(:info)
-      expect(renderer).to have_received(:partial).with(:info, scope)
-    end
-
-    it 'renders a partial with provided locals' do
-      scope_with_locals = described_class.new(renderer: renderer, context: context, locals: {foo: 'bar'})
-
-      scope.render(:info, foo: 'bar')
-      expect(renderer).to have_received(:partial).with(:info, scope_with_locals)
-    end
-  end
-
-  describe '#method_missing' do
-    context 'matching locals' do
-      let(:locals) { {greeting: 'hello from locals'} }
-      let(:context) { double('context', greeting: 'hello from context') }
-
-      it 'returns a matching value from the locals, in favour of a matching method on the context' do
-        expect(scope.greeting).to eq 'hello from locals'
-      end
-    end
-
-    context 'matching context' do
-      let(:context) { double('context', greeting: 'hello from context') }
-
-      it 'calls the matching method on the context' do
-        expect(scope.greeting).to eq 'hello from context'
-      end
-
-      it 'forwards all arguments to the method' do
-        blk = -> { }
-        scope.greeting 'args', &blk
-
-        expect(context).to have_received(:greeting).with('args', &blk)
-      end
-    end
-
-    describe 'no matches' do
-      it 'raises an error' do
-        expect { scope.greeting }.to raise_error(NoMethodError)
-      end
-    end
-  end
-end