dry-view 0.2.2 → 0.3.0

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA1:
-  metadata.gz: 4320e5c4ceacedaf135a9a59ab73bb5cd316ac2f
-  data.tar.gz: 9ce48d97be8b9c84b3ac473171777783549725f1
+  metadata.gz: 350649d54605ecc359ddcfd199fe13fec79e4d47
+  data.tar.gz: 7655546ae79c8e42da84aa12df1698a0bdba7f24
 SHA512:
-  metadata.gz: 622277285a6cb325c191ce400acd1cf0f200dfef10eeb6c87c5f6bb758c028be6a50b743ac664ff9c9de271c4795df4443ed3a19bcf9aa82c52431c2922957f0
-  data.tar.gz: a1340d82a48e85e4a9208f139b9cc3d4c746c704ea7b3bd9e9eef98dc2b41e5010f10488b2bfe9b1b86af3115212a377bcfdf6f776a87ffce5585ed6f8c265d1
+  metadata.gz: 0c817743037231ab4455085be9521d0106d8781998fca1727d7c591183e98862349492567fc77ee1f6ea168feaef62055ce4fc6adf1cad881712a6b23c24b42a
+  data.tar.gz: dfe44787659b229484a65ff231d7afc5c61f6fb3a831e46e03026fefb3bd1f7a6be46e021a34cb02e9010e59a3838c174962bdf1284550d5a55bf74438d34577

data/CHANGELOG.md

@@ -1,3 +1,16 @@
+# 0.3.0 / 2017-05-14
+
+This release reintroduces view parts in a more helpful form. You can provide your own custom view part classes to encapsulate your view logic, as well as a  decorator for custom, shared behavior arouund view part wrapping.
+
+### Changed
+
+- [BREAKING] Partial rendering in templates requires an explicit `render` method call instead of method_missing behaviour usinig the partial's name (e.g. `<%= render :my_partial %>` instead of `<%= my_partial %>`)
+
+### Added
+
+- Wrap all values passed to the template in `Dry::View::Part` objects
+- Added a `decorator` config to `Dry::View::Controller`, with a default `Dry::View::Decorator` that wraps the exposure values in `Dry::View::Part` objects (as above). Provide your own part classes by passing an `:as` option to your exposures, e.g. `expose :user, as: MyApp::UserPart`
+
 # 0.2.2 / 2017-01-31
 
 ### Changed

data/Gemfile

@@ -2,6 +2,8 @@ source 'https://rubygems.org'
 
 gemspec
 
+gem 'inflecto'
+
 group :tools do
   gem 'pry'
 end

data/dry-view.gemspec

@@ -22,6 +22,7 @@ Gem::Specification.new do |spec|
   spec.required_ruby_version = '>= 2.1.0'
 
   spec.add_runtime_dependency "tilt", "~> 2.0"
+  spec.add_runtime_dependency "dry-core", "~> 0.2"
   spec.add_runtime_dependency "dry-configurable", "~> 0.1"
   spec.add_runtime_dependency "dry-equalizer", "~> 0.2"
 

data/lib/dry/view/controller.rb

@@ -4,6 +4,7 @@ require 'dry-equalizer'
 require 'dry/view/path'
 require 'dry/view/exposures'
 require 'dry/view/renderer'
+require 'dry/view/decorator'
 require 'dry/view/scope'
 
 module Dry
@@ -19,9 +20,10 @@ module Dry
 
       setting :paths
       setting :layout, false
-      setting :context, DEFAULT_CONTEXT
       setting :template
       setting :default_format, :html
+      setting :context, DEFAULT_CONTEXT
+      setting :decorator, Decorator.new
 
       attr_reader :config
       attr_reader :layout_dir
@@ -29,20 +31,24 @@ module Dry
       attr_reader :template_path
       attr_reader :exposures
 
+      # @api public
       def self.paths
         Array(config.paths).map { |path| Dry::View::Path.new(path) }
       end
 
+      # @api private
       def self.renderer(format)
         renderers.fetch(format) {
           renderers[format] = Renderer.new(paths, format: format)
         }
       end
 
+      # @api private
       def self.renderers
         @renderers ||= {}
       end
 
+      # @api public
       def self.expose(*names, **options, &block)
         if names.length == 1
           exposures.add(names.first, block, **options)
@@ -53,14 +59,17 @@ module Dry
         end
       end
 
-      def self.private_expose(*names, &block)
-        expose(*names, to_view: false, &block)
+      # @api public
+      def self.private_expose(*names, **options, &block)
+        expose(*names, **options.merge(private: true), &block)
       end
 
+      # @api private
       def self.exposures
         @exposures ||= Exposures.new
       end
 
+      # @api public
       def initialize
         @config = self.class.config
         @layout_dir = DEFAULT_LAYOUTS_DIR
@@ -69,18 +78,20 @@ module Dry
         @exposures = self.class.exposures.bind(self)
       end
 
-      def call(format: config.default_format, **input)
+      # @api public
+      def call(format: config.default_format, context: config.context, **input)
         renderer = self.class.renderer(format)
 
-        template_content = renderer.(template_path, template_scope(renderer, **input))
+        template_content = renderer.(template_path, template_scope(renderer, context, **input))
 
         return template_content unless layout?
 
-        renderer.(layout_path, layout_scope(renderer, **input)) do
+        renderer.(layout_path, layout_scope(renderer, context)) do
           template_content
         end
       end
 
+      # @api public
       def locals(locals: EMPTY_LOCALS, **input)
         exposures.locals(input).merge(locals)
       end
@@ -91,16 +102,41 @@ module Dry
         !!config.layout
       end
 
-      def layout_scope(renderer, context: config.context, **)
-        scope(renderer.chdir(layout_dir), EMPTY_LOCALS, context)
+      def layout_scope(renderer, context)
+        scope(renderer.chdir(layout_dir), context)
+      end
+
+      def template_scope(renderer, context, **input)
+        scope(renderer.chdir(template_path), context, locals(**input))
       end
 
-      def template_scope(renderer, context: config.context, **input)
-        scope(renderer.chdir(template_path), locals(**input), context)
+      def scope(renderer, context, locals = EMPTY_LOCALS)
+        Scope.new(
+          renderer: renderer,
+          context: context,
+          locals: decorated_locals(renderer, context, locals)
+        )
       end
 
-      def scope(renderer, locals, context)
-        Scope.new(renderer, locals, context)
+      def decorated_locals(renderer, context, locals)
+        decorator = self.class.config.decorator
+
+        locals.each_with_object({}) { |(key, val), result|
+          # Decorate truthy values only
+          if val
+            options = exposures.key?(key) ? exposures[key].options : {}
+
+            val = decorator.(
+              key,
+              val,
+              renderer: renderer,
+              context: context,
+              **options
+            )
+          end
+
+          result[key] = val
+        }
       end
     end
   end

data/lib/dry/view/decorator.rb

@@ -0,0 +1,45 @@
+require 'dry/core/inflector'
+require 'dry/view/part'
+
+module Dry
+  module View
+    class Decorator
+      attr_reader :config
+
+      # @api public
+      def call(name, value, renderer:, context:, **options)
+        klass = part_class(name, value, **options)
+
+        if value.respond_to?(:to_ary)
+          singular_name = Dry::Core::Inflector.singularize(name).to_sym
+          singular_options = singularize_options(options)
+
+          arr = value.to_ary.map { |obj|
+            call(singular_name, obj, renderer: renderer, context: context, **singular_options)
+          }
+
+          klass.new(name: name, value: arr, renderer: renderer, context: context)
+        else
+          klass.new(name: name, value: value, renderer: renderer, context: context)
+        end
+      end
+
+      # @api public
+      def part_class(name, value, **options)
+        if options[:as].is_a?(Hash)
+          options[:as].keys.first
+        else
+          options.fetch(:as) { Part }
+        end
+      end
+
+      private
+
+      # @api private
+      def singularize_options(**options)
+        options[:as] = options[:as].values.first if options[:as].is_a?(Hash)
+        options
+      end
+    end
+  end
+end

data/lib/dry/view/exposure.rb

@@ -1,29 +1,35 @@
+require 'dry-equalizer'
+
 module Dry
   module View
     class Exposure
+      include Dry::Equalizer(:name, :proc, :object, :options)
+
       SUPPORTED_PARAMETER_TYPES = [:req, :opt].freeze
 
       attr_reader :name
       attr_reader :proc
       attr_reader :object
-      attr_reader :to_view
+      attr_reader :options
 
-      def initialize(name, proc = nil, object = nil, to_view: true)
+      def initialize(name, proc = nil, object = nil, **options)
         @name = name
         @proc = prepare_proc(proc, object)
         @object = object
-        @to_view = to_view
+        @options = options
       end
 
       def bind(obj)
-        self.class.new(name, proc, obj, to_view: to_view)
+        self.class.new(name, proc, obj, **options)
       end
 
       def dependencies
         proc ? proc.parameters.map(&:last) : []
       end
 
-      alias_method :to_view?, :to_view
+      def private?
+        options.fetch(:private) { false }
+      end
 
       def call(input, locals = {})
         return input[name] unless proc

data/lib/dry/view/exposures.rb

@@ -12,6 +12,10 @@ module Dry
         @exposures = exposures
       end
 
+      def key?(name)
+        exposures.key?(name)
+      end
+
       def [](name)
         exposures[name]
       end
@@ -21,9 +25,9 @@ module Dry
       end
 
       def bind(obj)
-        bound_exposures = Hash[exposures.map { |name, exposure|
-          [name, exposure.bind(obj)]
-        }]
+        bound_exposures = exposures.each_with_object({}) { |(name, exposure), memo|
+          memo[name] = exposure.bind(obj)
+        }
 
         self.class.new(bound_exposures)
       end
@@ -32,7 +36,7 @@ module Dry
         tsort.each_with_object({}) { |name, memo|
           memo[name] = self[name].(input, memo) if exposures.key?(name)
         }.each_with_object({}) { |(name, val), memo|
-          memo[name] = val if self[name].to_view?
+          memo[name] = val unless self[name].private?
         }
       end
 

data/lib/dry/view/part.rb

@@ -0,0 +1,67 @@
+require 'dry-equalizer'
+require 'dry/view/scope'
+
+module Dry
+  module View
+    class Part
+      CONVENIENCE_METHODS = %i[
+        context
+        render
+        value
+      ].freeze
+
+      include Dry::Equalizer(:_name, :_value, :_context, :_renderer)
+
+      attr_reader :_name
+
+      attr_reader :_value
+
+      attr_reader :_context
+
+      attr_reader :_renderer
+
+      def initialize(name:, value:, renderer:, context: nil)
+        @_name = name
+        @_value = value
+        @_context = context
+        @_renderer = renderer
+      end
+
+      def _render(partial_name, as: _name, **locals, &block)
+        _renderer.render(
+          _partial(partial_name),
+          _render_scope(as, **locals),
+          &block
+        )
+      end
+
+      def to_s
+        _value.to_s
+      end
+
+      private
+
+      def method_missing(name, *args, &block)
+        if _value.respond_to?(name)
+          _value.public_send(name, *args, &block)
+        elsif CONVENIENCE_METHODS.include?(name)
+          __send__(:"_#{name}", *args, &block)
+        else
+          super
+        end
+      end
+
+      def _partial(name)
+        _renderer.lookup("_#{name}")
+      end
+
+      def _render_scope(name, **locals)
+        Scope.new(
+          locals: locals.merge(name => self),
+          context: _context,
+          renderer: _renderer,
+        )
+      end
+    end
+  end
+end

data/lib/dry/view/scope.rb

@@ -3,51 +3,47 @@ require 'dry-equalizer'
 module Dry
   module View
     class Scope
-      include Dry::Equalizer(:_renderer, :_data)
+      include Dry::Equalizer(:_locals, :_context, :_renderer)
 
-      attr_reader :_renderer
-      attr_reader :_data
+      attr_reader :_locals
       attr_reader :_context
+      attr_reader :_renderer
 
-      def initialize(renderer, data, context = nil)
-        @_renderer = renderer
-        @_data = data.to_hash
+      def initialize(renderer:, context: nil, locals: {})
+        @_locals = locals
         @_context = context
+        @_renderer = renderer
       end
 
-      def respond_to_missing?(name, include_private = false)
-        _template?(name) || _data.key?(name) || _context.respond_to?(name)
+      def render(partial_name, **locals, &block)
+        _renderer.render(
+          __partial(partial_name),
+          __render_scope(**locals),
+          &block
+        )
       end
 
       private
 
       def method_missing(name, *args, &block)
-        if _data.key?(name)
-          _data[name]
+        if _locals.key?(name)
+          _locals[name]
         elsif _context.respond_to?(name)
           _context.public_send(name, *args, &block)
-        elsif (template_path = _template?(name))
-          _render(template_path, *args, &block)
         else
           super
         end
       end
 
-      def _template?(name)
+      def __partial(name)
         _renderer.lookup("_#{name}")
       end
 
-      def _render(path, *args, &block)
-        _renderer.render(path, _render_args(*args), &block)
-      end
-
-      def _render_args(*args)
-        if args.empty?
-          self
-        elsif args.length == 1 && args.first.respond_to?(:to_hash)
-          self.class.new(_renderer, args.first, _context)
+      def __render_scope(**locals)
+        if locals.any?
+          self.class.new(renderer: _renderer, context: _context, locals: locals)
         else
-          raise ArgumentError, "render argument must be a Hash"
+          self
         end
       end
     end

data/lib/dry/view/version.rb

@@ -1,5 +1,5 @@
 module Dry
   module View
-    VERSION = '0.2.2'.freeze
+    VERSION = '0.3.0'.freeze
   end
 end

data/spec/fixtures/templates/decorated_parts.html.slim

@@ -0,0 +1,4 @@
+- customs.each do |custom|
+  p = custom
+p = custom
+p = ordinary

data/spec/fixtures/templates/parts_with_args.html.slim

@@ -1,3 +1,3 @@
 .users
   - users.each do |user|
-    == box user: user, label: "Nombre"
+    == user.render :box, label: "Nombre"

data/spec/fixtures/templates/users.html.slim

@@ -1,5 +1,5 @@
 .users
-  == index_table do
-    == tbody
+  == render :index_table do
+    == render :tbody
 
 img src=assets["mindblown"]

data/spec/fixtures/templates/users/_tbody.html.slim

@@ -1,5 +1,5 @@
 tbody
   - users.each do |user|
-    == row do
+    == render :row do
       td = user[:name]
       td = user[:email]

data/spec/fixtures/templates_override/users.html.slim

@@ -1,5 +1,5 @@
 h1 OVERRIDE
 
 .users
-  == index_table do
-    == tbody
+  == render :index_table do
+    == render :tbody

data/spec/integration/decorator_spec.rb

@@ -0,0 +1,80 @@
+RSpec.describe 'decorator' do
+  before do
+    module Test
+      class CustomPart < Dry::View::Part
+        def to_s
+          "Custom part wrapping #{_value}"
+        end
+      end
+
+      class CustomArrayPart < Dry::View::Part
+        def each(&block)
+          (_value * 2).each(&block)
+        end
+      end
+    end
+  end
+
+  describe 'default decorator' do
+    it 'supports wrapping array memebers in custom part classes provided to exposure :as option' do
+      vc = Class.new(Dry::View::Controller) do
+        configure do |config|
+          config.paths = SPEC_ROOT.join('fixtures/templates')
+          config.layout = nil
+          config.template = 'decorated_parts'
+        end
+
+        expose :customs, as: Test::CustomPart
+        expose :custom, as: Test::CustomPart
+        expose :ordinary
+      end.new
+
+      expect(vc.(customs: ['many things'], custom: 'custom thing', ordinary: 'ordinary thing')).to eql(
+        '<p>Custom part wrapping many things</p><p>Custom part wrapping custom thing</p><p>ordinary thing</p>'
+      )
+    end
+
+    it 'supports wrapping an array and its members in custom part classes provided to exposure :as option as a hash' do
+      vc = Class.new(Dry::View::Controller) do
+        configure do |config|
+          config.paths = SPEC_ROOT.join('fixtures/templates')
+          config.layout = nil
+          config.template = 'decorated_parts'
+        end
+
+        expose :customs, as: {Test::CustomArrayPart => Test::CustomPart}
+        expose :custom, as: Test::CustomPart
+        expose :ordinary
+      end.new
+
+      expect(vc.(customs: ['many things'], custom: 'custom thing', ordinary: 'ordinary thing')).to eql(
+        '<p>Custom part wrapping many things</p><p>Custom part wrapping many things</p><p>Custom part wrapping custom thing</p><p>ordinary thing</p>'
+      )
+    end
+  end
+
+  describe 'custom decorator and part classes' do
+    it 'supports wrapping in custom parts based on exposure names' do
+      decorator = Class.new(Dry::View::Decorator) do
+        def part_class(name, value, **options)
+          name == :custom ? Test::CustomPart : super
+        end
+      end.new
+
+      vc = Class.new(Dry::View::Controller) do
+        configure do |config|
+          config.decorator = decorator
+          config.paths = SPEC_ROOT.join('fixtures/templates')
+          config.layout = nil
+          config.template = 'decorated_parts'
+        end
+
+        expose :customs, :custom, :ordinary
+      end.new
+
+      expect(vc.(customs: ['many things'], custom: 'custom thing', ordinary: 'ordinary thing')).to eql(
+        '<p>Custom part wrapping many things</p><p>Custom part wrapping custom thing</p><p>ordinary thing</p>'
+      )
+    end
+  end
+end

data/spec/spec_helper.rb

@@ -20,11 +20,21 @@ Tilt.register 'erb', Tilt::ERBTemplate
 
 require 'dry-view'
 
+module Test
+  def self.remove_constants
+    constants.each(&method(:remove_const))
+  end
+end
+
 RSpec.configure do |config|
   config.disable_monkey_patching!
 
   config.order = :random
   Kernel.srand config.seed
+
+  config.after do
+    Test.remove_constants
+  end
 end
 
 RSpec::Matchers.define :part_including do |data|

data/spec/unit/decorator_spec.rb

@@ -0,0 +1,61 @@
+RSpec.describe Dry::View::Decorator do
+  subject(:decorator) { described_class.new }
+
+  describe '#call' do
+    let(:value) { double('value') }
+    let(:renderer) { double('renderer') }
+    let(:context) { double('context') }
+    let(:options) { {} }
+
+    describe 'returning a part value' do
+      subject(:part) { decorator.('user', value, renderer: renderer, context: context, **options) }
+
+      context 'no options provided' do
+        it 'returns a Part' do
+          expect(part).to be_a Dry::View::Part
+        end
+
+        it 'wraps the value' do
+          expect(part._value).to eq value
+        end
+      end
+
+      context 'part class provided via `:as` option' do
+        let(:options) { {as: Test::CustomPart} }
+
+        before do
+          module Test
+            CustomPart = Class.new(Dry::View::Part)
+          end
+        end
+
+        it 'returns an instance of the provided class' do
+          expect(part).to be_a Test::CustomPart
+        end
+
+        it 'wraps the value' do
+          expect(part._value).to eq value
+        end
+      end
+
+      context 'value is an array' do
+        let(:child_a) { double('child a') }
+        let(:child_b) { double('child a') }
+        let(:value) { [child_a, child_b] }
+
+        it 'returns a part wrapping the array' do
+          expect(part).to be_a Dry::View::Part
+          expect(part._value).to be_an Array
+        end
+
+        it 'wraps the elements within the array' do
+          expect(part[0]).to be_a Dry::View::Part
+          expect(part[0]._value).to eq child_a
+
+          expect(part[1]).to be_a Dry::View::Part
+          expect(part[1]._value).to eq child_b
+        end
+      end
+    end
+  end
+end

data/spec/unit/exposure_spec.rb

@@ -33,13 +33,13 @@ RSpec.describe Dry::View::Exposure do
       end
     end
 
-    describe "#to_view" do
-      it "is true by default" do
-        expect(exposure.to_view).to be true
+    describe "#private?" do
+      it "is false by default" do
+        expect(exposure).not_to be_private
       end
 
-      it "can be set to false on initialization" do
-        expect(described_class.new(:hello, to_view: false).to_view).to be false
+      it "can be set on initialization" do
+        expect(described_class.new(:hello, private: true)).to be_private
       end
     end
   end

data/spec/unit/exposures_spec.rb

@@ -54,7 +54,7 @@ RSpec.describe Dry::View::Exposures do
     end
 
     it "does not return any values from private exposures" do
-      exposures.add(:hidden, -> input { "shh" }, to_view: false)
+      exposures.add(:hidden, -> input { "shh" }, private: true)
 
       expect(locals).to include(:greeting, :farewell)
       expect(locals).not_to include(:hidden)

data/spec/unit/part_spec.rb

@@ -0,0 +1,65 @@
+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
+  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) { double('renderer') }
+
+  describe '#render' do
+    before do
+      allow(renderer).to receive(:lookup).with('_info').and_return '_info.html.erb'
+      allow(renderer).to receive(:render)
+    end
+
+    it 'renders a partial with the part available in its scope' do
+      part.render(:info)
+      expect(renderer).to have_received(:render).with('_info.html.erb', 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(:render).with('_info.html.erb', template_scope(admin: part))
+    end
+
+    it 'includes extra locals in the scope' do
+      part.render(:info, extra_local: "hello")
+      expect(renderer).to have_received(:render).with('_info.html.erb', 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 '#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
+end

data/spec/unit/scope_spec.rb

@@ -1,97 +1,57 @@
-require 'dry/view/scope'
-
 RSpec.describe Dry::View::Scope do
-  subject(:scope) {
-    described_class.new(renderer, data, context)
-  }
+  subject(:scope) { described_class.new(renderer: renderer, context: context, locals: locals) }
 
-  let(:renderer) { double("renderer") }
-  let(:data) { {} }
-  let(:context) { Object.new }
+  let(:locals) { {} }
+  let(:context) { double('context') }
+  let(:renderer) { double('renderer') }
 
-  describe "missing method behavior" do
+  describe '#render' do
     before do
-      allow(renderer).to receive(:lookup).and_return false
+      allow(renderer).to receive(:lookup).with('_info').and_return '_info.html.erb'
       allow(renderer).to receive(:render)
     end
 
-    describe "accessing data" do
-      let(:data) { {user_name: "Jane Doe", current_user: "data's current_user"} }
-      let(:context) {
-        Class.new do
-          def current_user
-            "context's current_user"
-          end
-        end.new
-      }
-
-      before do
-        allow(renderer).to receive(:lookup).with('_current_user').and_return '_current_user.html.slim'
-      end
-
-      it "returns matching scope data" do
-        expect(scope.user_name).to eq "Jane Doe"
-      end
-
-      it "raises an error when no data matches" do
-        expect { scope.missing }.to raise_error(NoMethodError)
-      end
-
-      it "returns data in favour of both context methods and partials" do
-        expect(scope.current_user).to eq "data's current_user"
-      end
+    it 'renders a partial with itself as the scope' do
+      scope.render(:info)
+      expect(renderer).to have_received(:render).with('_info.html.erb', scope)
     end
 
-    describe "accessing context" do
-      let(:context) {
-        Class.new do
-          def current_user
-            "context's current_user"
-          end
-
-          def asset(name)
-            "#{name}.jpg"
-          end
-        end.new
-      }
+    it 'renders a partial with provided locals' do
+      scope_with_locals = described_class.new(renderer: renderer, context: context, locals: {foo: 'bar'})
 
-      before do
-        allow(renderer).to receive(:lookup).with('_current_user').and_return '_current_user.html.slim'
-      end
+      scope.render(:info, foo: 'bar')
+      expect(renderer).to have_received(:render).with('_info.html.erb', scope_with_locals)
+    end
+  end
 
-      it "forwards to matching methods on the context in favour of partials" do
-        expect(scope.current_user).to eq "context's current_user"
-      end
+  describe '#method_missing' do
+    context 'matching locals' do
+      let(:locals) { {greeting: 'hello from locals'} }
+      let(:context) { double('context', greeting: 'hello from context') }
 
-      it "allows arguments to be passed to those methods as normal" do
-        expect(scope.asset("mindblown")).to eq "mindblown.jpg"
-      end
-
-      it "raises an error when no method matches" do
-        expect { scope.missing }.to raise_error(NoMethodError)
+      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
 
-    describe "rendering" do
-      before do
-        allow(renderer).to receive(:lookup).with('_list').and_return '_list.html.slim'
-      end
-
-      it "renders a matching partial using the existing scope" do
-        scope.list
+    context 'matching context' do
+      let(:context) { double('context', greeting: 'hello from context') }
 
-        expect(renderer).to have_received(:render).with('_list.html.slim', scope)
+      it 'calls the matching method on the context' do
+        expect(scope.greeting).to eq 'hello from context'
       end
 
-      it "renders a matching partial using a scope based on arguments passed" do
-        scope.list(something: 'else')
+      it 'forwards all arguments to the method' do
+        blk = -> { }
+        scope.greeting 'args', &blk
 
-        expect(renderer).to have_received(:render)
-          .with('_list.html.slim', described_class.new(renderer, something: 'else'))
+        expect(context).to have_received(:greeting).with('args', &blk)
       end
+    end
 
-      it "raises an error if arguments passed are not a hash" do
-        expect { scope.list('hi') }.to raise_error(ArgumentError)
+    describe 'no matches' do
+      it 'raises an error' do
+        expect { scope.greeting }.to raise_error(NoMethodError)
       end
     end
   end

metadata

@@ -1,7 +1,7 @@
 --- !ruby/object:Gem::Specification
 name: dry-view
 version: !ruby/object:Gem::Version
-  version: 0.2.2
+  version: 0.3.0
 platform: ruby
 authors:
 - Piotr Solnica
@@ -9,7 +9,7 @@ authors:
 autorequire: 
 bindir: exe
 cert_chain: []
-date: 2017-01-31 00:00:00.000000000 Z
+date: 2017-05-14 00:00:00.000000000 Z
 dependencies:
 - !ruby/object:Gem::Dependency
   name: tilt
@@ -25,6 +25,20 @@ dependencies:
     - - "~>"
       - !ruby/object:Gem::Version
         version: '2.0'
+- !ruby/object:Gem::Dependency
+  name: dry-core
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: '0.2'
+  type: :runtime
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: '0.2'
 - !ruby/object:Gem::Dependency
   name: dry-configurable
   requirement: !ruby/object:Gem::Requirement
@@ -118,12 +132,15 @@ files:
 - lib/dry-view.rb
 - lib/dry/view.rb
 - lib/dry/view/controller.rb
+- lib/dry/view/decorator.rb
 - lib/dry/view/exposure.rb
 - lib/dry/view/exposures.rb
+- lib/dry/view/part.rb
 - lib/dry/view/path.rb
 - lib/dry/view/renderer.rb
 - lib/dry/view/scope.rb
 - lib/dry/view/version.rb
+- spec/fixtures/templates/decorated_parts.html.slim
 - spec/fixtures/templates/empty.html.slim
 - spec/fixtures/templates/hello.html.slim
 - spec/fixtures/templates/layouts/app.html.slim
@@ -140,12 +157,15 @@ files:
 - spec/fixtures/templates/users/_tbody.html.slim
 - spec/fixtures/templates/users_with_count.html.slim
 - spec/fixtures/templates_override/users.html.slim
+- spec/integration/decorator_spec.rb
 - spec/integration/exposures_spec.rb
 - spec/integration/view_spec.rb
 - spec/spec_helper.rb
 - spec/unit/controller_spec.rb
+- spec/unit/decorator_spec.rb
 - spec/unit/exposure_spec.rb
 - spec/unit/exposures_spec.rb
+- spec/unit/part_spec.rb
 - spec/unit/renderer_spec.rb
 - spec/unit/scope_spec.rb
 homepage: https://github.com/dry-rb/dry-view
@@ -168,11 +188,12 @@ required_rubygems_version: !ruby/object:Gem::Requirement
       version: '0'
 requirements: []
 rubyforge_project: 
-rubygems_version: 2.6.8
+rubygems_version: 2.6.10
 signing_key: 
 specification_version: 4
 summary: Functional view rendering system
 test_files:
+- spec/fixtures/templates/decorated_parts.html.slim
 - spec/fixtures/templates/empty.html.slim
 - spec/fixtures/templates/hello.html.slim
 - spec/fixtures/templates/layouts/app.html.slim
@@ -189,11 +210,14 @@ test_files:
 - spec/fixtures/templates/users/_tbody.html.slim
 - spec/fixtures/templates/users_with_count.html.slim
 - spec/fixtures/templates_override/users.html.slim
+- spec/integration/decorator_spec.rb
 - spec/integration/exposures_spec.rb
 - spec/integration/view_spec.rb
 - spec/spec_helper.rb
 - spec/unit/controller_spec.rb
+- spec/unit/decorator_spec.rb
 - spec/unit/exposure_spec.rb
 - spec/unit/exposures_spec.rb
+- spec/unit/part_spec.rb
 - spec/unit/renderer_spec.rb
 - spec/unit/scope_spec.rb