Merge pull request #89 from dry-rb/decorated-attributes-in-context

Add base Context class with support for decorated attributes

lib/dry/view/context.rb

@@ -0,0 +1,59 @@
+module Dry
+  module View
+    class Context
+      attr_reader :_options, :_part_builder, :_renderer
+
+      def initialize(part_builder: nil, renderer: nil, **options)
+        @_part_builder = part_builder
+        @_renderer = renderer
+        @_options = options
+      end
+
+      def bind(part_builder:, renderer:)
+        self.class.new(
+          **_options.merge(
+            part_builder: part_builder,
+            renderer: renderer,
+          )
+        )
+      end
+
+      def bound?
+        !!(_part_builder && _renderer)
+      end
+
+      def self.decorate(*names, **options)
+        mod = DecoratedAttributes.new(names) do
+          names.each do |name|
+            define_method name do
+              attribute = super()
+
+              return attribute unless bound? || !attribute
+
+              _part_builder.(
+                name: name,
+                value: attribute,
+                renderer: _renderer,
+                context: self,
+                **options,
+              )
+            end
+          end
+        end
+
+        prepend mod
+      end
+
+      class DecoratedAttributes < Module
+        def initialize(names, &block)
+          @names = names
+          super(&block)
+        end
+
+        def inspect
+          %(#<#{self.class.name}#{@names.inspect}>)
+        end
+      end
+    end
+  end
+end

lib/dry/view/controller.rb

@@ -2,6 +2,7 @@
 require 'dry/equalizer'
 require 'dry/inflector'
 
+require_relative 'context'
 require_relative 'exposures'
 require_relative 'part_builder'
 require_relative 'path'
@@ -15,7 +16,7 @@ class Controller
       UndefinedTemplateError = Class.new(StandardError)
 
       DEFAULT_LAYOUTS_DIR = 'layouts'.freeze
-      DEFAULT_CONTEXT = Object.new.freeze
+      DEFAULT_CONTEXT = Context.new
       DEFAULT_RENDERER_OPTIONS = {default_encoding: 'utf-8'.freeze}.freeze
       EMPTY_LOCALS = {}.freeze
 
@@ -112,6 +113,7 @@ def call(format: config.default_format, context: config.default_context, **input
         raise UndefinedTemplateError, "no +template+ configured" unless template_path
 
         renderer = self.class.renderer(format)
+        context = context.bind(part_builder: part_builder, renderer: renderer)
 
         locals = locals(renderer.chdir(template_path), context, input)
 

spec/fixtures/integration/context/decorated_attributes.html.slim

@@ -0,0 +1,3 @@
+== assets.image_tag("hello.png")
+.user
+  == user.image_tag

spec/integration/context_spec.rb

@@ -0,0 +1,65 @@
+require "dry/view/context"
+require "dry/view/controller"
+require "dry/view/part"
+
+RSpec.describe "Context" do
+  it "Provides decorated attributes for use in templates and parts" do
+    module Test
+      class Assets
+        def [](path)
+          "hashed/path/to/#{path}"
+        end
+      end
+
+      class Context < Dry::View::Context
+        attr_reader :assets
+        decorate :assets
+
+        def initialize(assets:, **options)
+          @assets = assets
+          super
+        end
+      end
+
+      module Parts
+        class Assets < Dry::View::Part
+          def image_tag(path)
+            <<~HTML
+              <img src="#{value[path]}">
+            HTML
+          end
+        end
+
+        class User < Dry::View::Part
+          def image_tag
+            value[:image_url] || context.assets.image_tag("default.png")
+          end
+        end
+      end
+    end
+
+    vc = Class.new(Dry::View::Controller) do
+      configure do |config|
+        config.paths = FIXTURES_PATH.join("integration/context")
+        config.template = "decorated_attributes"
+        config.part_namespace = Test::Parts
+      end
+
+      expose :user
+    end.new
+
+    context = Test::Context.new(assets: Test::Assets.new)
+
+    output = vc.(
+      user: {image_url: nil},
+      context: context,
+    ).to_s
+
+    expect(output.gsub("\n", "")).to eq <<~HTML.gsub("\n", "")
+      <img src="hashed/path/to/hello.png">
+      <div class="user">
+      <img src="hashed/path/to/default.png">
+      </div>
+    HTML
+  end
+end

spec/integration/exposures_spec.rb

@@ -1,8 +1,19 @@
+require 'dry/view/context'
 require 'dry/view/controller'
 require 'dry/view/part'
 
 RSpec.describe 'exposures' do
-  let(:context) { Struct.new(:title, :assets).new('dry-view rocks!', -> input { "#{input}.jpg" }) }
+  let(:context) {
+    Class.new(Dry::View::Context) do
+      def title
+        'dry-view rocks!'
+      end
+
+      def assets
+        -> input { "#{input}.jpg" }
+      end
+    end.new
+  }
 
   it 'uses exposures with blocks to build view locals' do
     vc = Class.new(Dry::View::Controller) do

spec/integration/view_spec.rb

@@ -17,9 +17,17 @@
     end
   end
 
-  let(:context) do
-    Struct.new(:title, :assets).new('dry-view rocks!', -> input { "#{input}.jpg" })
-  end
+  let(:context) {
+    Class.new(Dry::View::Context) do
+      def title
+        'dry-view rocks!'
+      end
+
+      def assets
+        -> input { "#{input}.jpg" }
+      end
+    end.new
+  }
 
   it 'renders within a layout and makes the provided context available everywhere' do
     vc = vc_class.new

spec/spec_helper.rb

@@ -10,6 +10,7 @@
 rescue LoadError; end
 
 SPEC_ROOT = Pathname(__FILE__).dirname
+FIXTURES_PATH = SPEC_ROOT.join("fixtures")
 
 require 'erb'
 require 'slim'

spec/unit/context_spec.rb

@@ -0,0 +1,58 @@
+require "dry/view/context"
+require "dry/view/part"
+require "dry/view/part_builder"
+
+RSpec.describe Dry::View::Context do
+  let(:context_class) {
+    Class.new(Dry::View::Context) do
+      attr_reader :assets
+
+      decorate :assets, :invalid_attribute
+
+      def initialize(assets:, **options)
+        @assets = assets
+        super
+      end
+    end
+  }
+
+  let(:assets) { double(:assets) }
+  let(:renderer) { double(:renderer) }
+  let(:part_builder) { Dry::View::PartBuilder.new }
+
+  it "provides a helpful #inspect on the generated decorated attributes module" do
+    expect(context_class.ancestors[0].inspect).to eq "#<Dry::View::Context::DecoratedAttributes[:assets, :invalid_attribute]>"
+  end
+
+  context "unbound" do
+    subject(:context) { context_class.new(assets: assets) }
+
+    it { is_expected.not_to be_bound }
+
+    it "returns its attributes" do
+      expect(context.assets).to eql assets
+    end
+
+    it "raises NoMethodError when an invalid attribute is decorated" do
+      expect { context.invalid_attribute }.to raise_error(NoMethodError)
+    end
+  end
+
+  context "bound" do
+    subject(:context) {
+      context_class.new(assets: assets).
+        bind(renderer: renderer, part_builder: part_builder)
+    }
+
+    it { is_expected.to be_bound }
+
+    it "returns its assets decorated in view parts" do
+      expect(context.assets).to be_a Dry::View::Part
+      expect(context.assets.value).to eql assets
+    end
+
+    it "raises NoMethodError when an invalid attribute is decorated" do
+      expect { context.invalid_attribute }.to raise_error(NoMethodError)
+    end
+  end
+end

spec/unit/controller_spec.rb

@@ -18,7 +18,11 @@
   }
 
   let(:context) do
-    double(:page, title: 'Test')
+    Class.new(Dry::View::Context) do
+      def title
+        'Test'
+      end
+    end.new
   end
 
   describe '#call' do
@@ -52,24 +56,30 @@
       end.new
     }
 
-    subject(:context) {
-      Class.new do
-        def self.form(action:, &blk)
-          new(action, &blk)
-        end
+    before do
+      module Test
+        class Form
+          def initialize(action, &block)
+            @buf = eval('@__buf__', block.binding)
 
-        def initialize(action, &blk)
-          @buf = eval('@__buf__', blk.binding)
+            @buf << "<form action=\"#{action}\" method=\"post\">"
+            block.(self)
+            @buf << '</form>'
+          end
 
-          @buf << "<form action=\"#{action}\" method=\"post\">"
-          blk.(self)
-          @buf << '</form>'
+          def text(name)
+            "<input type=\"text\" name=\"#{name}\" />"
+          end
         end
+      end
+    end
 
-        def text(name)
-          "<input type=\"text\" name=\"#{name}\" />"
+    subject(:context) {
+      Class.new(Dry::View::Context) do
+        def form(action:, &blk)
+          Test::Form.new(action, &blk)
         end
-      end
+      end.new
     }
 
     it 'uses default encoding' do