dry-view 0.3.0 → 0.4.0

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA1:
-  metadata.gz: 350649d54605ecc359ddcfd199fe13fec79e4d47
-  data.tar.gz: 7655546ae79c8e42da84aa12df1698a0bdba7f24
+  metadata.gz: ba3055d4bb318adbf1cc7718433873c0f8726e26
+  data.tar.gz: 9e09c2f6cf9b340010dcda9319c23b6d78d48c61
 SHA512:
-  metadata.gz: 0c817743037231ab4455085be9521d0106d8781998fca1727d7c591183e98862349492567fc77ee1f6ea168feaef62055ce4fc6adf1cad881712a6b23c24b42a
-  data.tar.gz: dfe44787659b229484a65ff231d7afc5c61f6fb3a831e46e03026fefb3bd1f7a6be46e021a34cb02e9010e59a3838c174962bdf1284550d5a55bf74438d34577
+  metadata.gz: 0decd3ced65ee18f4f4bd95c18af6866c53fba4ed92c1e6a2774f8e8bdc787183ee90a260c5904c5a9b661cf106f822e60bd48ba4b4d89ff33fad630daf1eccc
+  data.tar.gz: 5b7792fd0b18d5c9dcd2c10d53d3f817fd643ee90e97d866f68e8920f543126d4fed444afa9e0cae1193fa7cde5794cb9d54a16d8d63a1f9314228bc23171308

data/.travis.yml

@@ -13,10 +13,9 @@ after_success:
     # Send coverage report from the job #1 == current MRI release
   - '[ "${TRAVIS_JOB_NUMBER#*.}" = "1" ] && [ "$TRAVIS_BRANCH" = "master" ] && bundle exec codeclimate-test-reporter'
 rvm:
-  - 2.4.0
-  - 2.3.3
-  - 2.2.6
-  - 2.1.10
+  - 2.4.2
+  - 2.3.5
+  - 2.2.8
   - jruby-9.1.6.0
 env:
   global:

data/CHANGELOG.md

@@ -1,3 +1,17 @@
+# 0.4.0 / 2017-11-01
+
+### Added
+
+- Raise a helpful error when trying to render a template or partial that cannot be found (GustavoCaso)
+- Raise a helpful error when trying to call a view controller with no template configured (timriley)
+- Allow a default to be specified for pass-through exposures with the `default:` option (GustavoCaso)
+
+### Changed
+
+- [BREAKING] Exposures specify the input data they require using keyword arguments. This includes support for providing default values (via the keyword argument) for keys that are missing from the input data (GustavoCaso)
+- Allow `Dry::View::Part` instances to be created without explicitly passing a `renderer`. This is helpful for unit testing view parts that don't need to render anything (dNitza)
+- Partials can be nested within additional sub-directories by rendering them their relative path as their name, e.g. `render(:"foo/bar")` will look for a `foo/_bar.html.slim` template within the normal template lookup paths (timriley)
+
 # 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.

data/CONTRIBUTING.md

@@ -0,0 +1,29 @@
+# Issue Guidelines
+
+## Reporting bugs
+
+If you found a bug, report an issue and describe what's the expected behavior versus what actually happens. If the bug causes a crash, attach a full backtrace. If possible, a reproduction script showing the problem is highly appreciated.
+
+## Reporting feature requests
+
+Report a feature request **only after discussing it first on [discourse.dry-rb.org](https://discourse.dry-rb.org)** where it was accepted. Please provide a concise description of the feature, don't link to a discussion thread, and instead summarize what was discussed.
+
+## Reporting questions, support requests, ideas, concerns etc.
+
+**PLEASE DON'T** - use [discourse.dry-rb.org](http://discourse.dry-rb.org) instead.
+
+# Pull Request Guidelines
+
+A Pull Request will only be accepted if it addresses a specific issue that was reported previously, or fixes typos, mistakes in documentation etc.
+
+Other requirements:
+
+1) Do not open a pull request if you can't provide tests along with it. If you have problems writing tests, ask for help in the related issue.
+2) Follow the style conventions of the surrounding code. In most cases, this is standard ruby style.
+3) Add API documentation if it's a new feature
+4) Update API documentation if it changes an existing feature
+5) Bonus points for sending a PR to [github.com/dry-rb/dry-rb.org](github.com/dry-rb/dry-rb.org) which updates user documentation and guides
+
+# Asking for help
+
+If these guidelines aren't helpful, and you're stuck, please post a message on [discourse.dry-rb.org](https://discourse.dry-rb.org).

data/Gemfile

@@ -5,11 +5,10 @@ gemspec
 gem 'inflecto'
 
 group :tools do
-  gem 'pry'
+  gem 'pry-byebug', platform: :mri
 end
 
 group :test do
-  gem 'byebug', platform: :mri
   gem 'rack', '>= 1.0.0', '<= 2.0.0'
   gem 'slim'
 

data/dry-view.gemspec

@@ -19,7 +19,7 @@ Gem::Specification.new do |spec|
   spec.test_files    = spec.files.grep(%r{^(test|spec|features)/})
   spec.require_paths = ["lib"]
 
-  spec.required_ruby_version = '>= 2.1.0'
+  spec.required_ruby_version = '>= 2.2.0'
 
   spec.add_runtime_dependency "tilt", "~> 2.0"
   spec.add_runtime_dependency "dry-core", "~> 0.2"

data/lib/dry/view/controller.rb

@@ -10,6 +10,8 @@ require 'dry/view/scope'
 module Dry
   module View
     class Controller
+      UndefinedTemplateError = Class.new(StandardError)
+
       DEFAULT_LAYOUTS_DIR = 'layouts'.freeze
       DEFAULT_CONTEXT = Object.new.freeze
       EMPTY_LOCALS = {}.freeze
@@ -51,17 +53,17 @@ module Dry
       # @api public
       def self.expose(*names, **options, &block)
         if names.length == 1
-          exposures.add(names.first, block, **options)
+          exposures.add(names.first, block, options)
         else
           names.each do |name|
-            exposures.add(name, **options)
+            exposures.add(name, options)
           end
         end
       end
 
       # @api public
       def self.private_expose(*names, **options, &block)
-        expose(*names, **options.merge(private: true), &block)
+        expose(*names, **options, private: true, &block)
       end
 
       # @api private
@@ -80,13 +82,15 @@ module Dry
 
       # @api public
       def call(format: config.default_format, context: config.context, **input)
+        raise UndefinedTemplateError, "no +template+ configured" unless template_path
+
         renderer = self.class.renderer(format)
 
-        template_content = renderer.(template_path, template_scope(renderer, context, **input))
+        template_content = renderer.template(template_path, template_scope(renderer, context, input))
 
         return template_content unless layout?
 
-        renderer.(layout_path, layout_scope(renderer, context)) do
+        renderer.template(layout_path, layout_scope(renderer, context)) do
           template_content
         end
       end
@@ -107,7 +111,7 @@ module Dry
       end
 
       def template_scope(renderer, context, **input)
-        scope(renderer.chdir(template_path), context, locals(**input))
+        scope(renderer.chdir(template_path), context, locals(input))
       end
 
       def scope(renderer, context, locals = EMPTY_LOCALS)

data/lib/dry/view/decorator.rb

@@ -8,7 +8,7 @@ module Dry
 
       # @api public
       def call(name, value, renderer:, context:, **options)
-        klass = part_class(name, value, **options)
+        klass = part_class(name, value, options)
 
         if value.respond_to?(:to_ary)
           singular_name = Dry::Core::Inflector.singularize(name).to_sym

data/lib/dry/view/exposure.rb

@@ -5,7 +5,8 @@ module Dry
     class Exposure
       include Dry::Equalizer(:name, :proc, :object, :options)
 
-      SUPPORTED_PARAMETER_TYPES = [:req, :opt].freeze
+      EXPOSURE_DEPENDENCY_PARAMETER_TYPES = [:req, :opt].freeze
+      INPUT_PARAMETER_TYPES = [:key, :keyreq, :keyrest].freeze
 
       attr_reader :name
       attr_reader :proc
@@ -20,34 +21,50 @@ module Dry
       end
 
       def bind(obj)
-        self.class.new(name, proc, obj, **options)
+        self.class.new(name, proc, obj, options)
       end
 
-      def dependencies
-        proc ? proc.parameters.map(&:last) : []
+      def dependency_names
+        if proc
+          proc.parameters.each_with_object([]) { |(type, name), names|
+            names << name if EXPOSURE_DEPENDENCY_PARAMETER_TYPES.include?(type)
+          }
+        else
+          []
+        end
+      end
+
+      def input_keys
+        if proc
+          proc.parameters.each_with_object([]) { |(type, name), keys|
+            keys << name if INPUT_PARAMETER_TYPES.include?(type)
+          }
+        else
+          []
+        end
       end
 
       def private?
         options.fetch(:private) { false }
       end
 
-      def call(input, locals = {})
-        return input[name] unless proc
-
-        args = dependencies.map.with_index { |name, position|
-          if position.zero?
-            locals.fetch(name) { input }
-          else
-            locals.fetch(name)
-          end
-        }
+      def default_value
+        options[:default]
+      end
 
-        call_proc(*args)
+      def call(input, locals = {})
+        if proc
+          call_proc(input, locals)
+        else
+          input.fetch(name) { default_value }
+        end
       end
 
       private
 
-      def call_proc(*args)
+      def call_proc(input, locals)
+        args = proc_args(input, locals)
+
         if proc.is_a?(Method)
           proc.(*args)
         else
@@ -55,6 +72,27 @@ module Dry
         end
       end
 
+      def proc_args(input, locals)
+        dependency_args = proc_dependency_args(locals)
+        input_args = proc_input_args(input)
+
+        if input_args.any?
+          dependency_args << input_args
+        else
+          dependency_args
+        end
+      end
+
+      def proc_dependency_args(locals)
+        dependency_names.map { |name| locals.fetch(name) }
+      end
+
+      def proc_input_args(input)
+        input_keys.each_with_object({}) { |key, args|
+          args[key] = input[key] if input.key?(key)
+        }
+      end
+
       def prepare_proc(proc, object)
         if proc
           proc

data/lib/dry/view/exposures.rb

@@ -21,7 +21,7 @@ module Dry
       end
 
       def add(name, proc = nil, **options)
-        exposures[name] = Exposure.new(name, proc, **options)
+        exposures[name] = Exposure.new(name, proc, options)
       end
 
       def bind(obj)
@@ -47,7 +47,7 @@ module Dry
       end
 
       def tsort_each_child(name, &block)
-        self[name].dependencies.each(&block) if exposures.key?(name)
+        self[name].dependency_names.each(&block) if exposures.key?(name)
       end
     end
   end

data/lib/dry/view/missing_renderer.rb

@@ -0,0 +1,15 @@
+module Dry
+  module View
+    class MissingRendererError < StandardError
+      def initialize(message = "No renderer provided")
+        super
+      end
+    end
+
+    class MissingRenderer
+      def method_missing(name, *args, &block)
+        raise MissingRendererError
+      end
+    end
+  end
+end

data/lib/dry/view/part.rb

@@ -1,5 +1,6 @@
 require 'dry-equalizer'
 require 'dry/view/scope'
+require 'dry/view/missing_renderer'
 
 module Dry
   module View
@@ -20,7 +21,7 @@ module Dry
 
       attr_reader :_renderer
 
-      def initialize(name:, value:, renderer:, context: nil)
+      def initialize(name:, value:, renderer: MissingRenderer.new, context: nil)
         @_name = name
         @_value = value
         @_context = context
@@ -28,11 +29,7 @@ module Dry
       end
 
       def _render(partial_name, as: _name, **locals, &block)
-        _renderer.render(
-          _partial(partial_name),
-          _render_scope(as, **locals),
-          &block
-        )
+        _renderer.partial(partial_name, _render_scope(as, locals), &block)
       end
 
       def to_s
@@ -51,10 +48,6 @@ module Dry
         end
       end
 
-      def _partial(name)
-        _renderer.lookup("_#{name}")
-      end
-
       def _render_scope(name, **locals)
         Scope.new(
           locals: locals.merge(name => self),

data/lib/dry/view/renderer.rb

@@ -4,6 +4,9 @@ require 'dry-equalizer'
 module Dry
   module View
     class Renderer
+      PARTIAL_PREFIX = "_".freeze
+      PATH_DELIMITER = "/".freeze
+
       include Dry::Equalizer(:paths, :format)
 
       TemplateNotFoundError = Class.new(StandardError)
@@ -20,17 +23,21 @@ module Dry
         @tilts = self.class.tilts
       end
 
-      def call(template, scope, &block)
-        path = lookup(template)
+      def template(name, scope, &block)
+        path = lookup(name)
 
         if path
           render(path, scope, &block)
         else
-          msg = "Template #{template.inspect} could not be found in paths:\n#{paths.map { |pa| "- #{pa.to_s}" }.join("\n")}"
+          msg = "Template #{name.inspect} could not be found in paths:\n#{paths.map { |pa| "- #{pa.to_s}" }.join("\n")}"
           raise TemplateNotFoundError, msg
         end
       end
 
+      def partial(name, scope, &block)
+        template(name_for_partial(name), scope, &block)
+      end
+
       def render(path, scope, &block)
         tilt(path).render(scope, &block)
       end
@@ -49,6 +56,11 @@ module Dry
 
       private
 
+      def name_for_partial(name)
+        name_segments = name.to_s.split(PATH_DELIMITER)
+        partial_name = name_segments[0..-2].push("#{PARTIAL_PREFIX}#{name_segments[-1]}").join(PATH_DELIMITER)
+      end
+
       # TODO: make default_encoding configurable
       def tilt(path)
         tilts.fetch(path) {

data/lib/dry/view/scope.rb

@@ -16,11 +16,7 @@ module Dry
       end
 
       def render(partial_name, **locals, &block)
-        _renderer.render(
-          __partial(partial_name),
-          __render_scope(**locals),
-          &block
-        )
+        _renderer.partial(partial_name, __render_scope(locals), &block)
       end
 
       private
@@ -35,10 +31,6 @@ module Dry
         end
       end
 
-      def __partial(name)
-        _renderer.lookup("_#{name}")
-      end
-
       def __render_scope(**locals)
         if locals.any?
           self.class.new(renderer: _renderer, context: _context, locals: locals)

data/lib/dry/view/version.rb

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

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

@@ -0,0 +1 @@
+h1 Partial hello

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

@@ -0,0 +1,11 @@
+h1 Edit
+
+- if errors.any?
+  - errors.each do |error|
+    p.error #{error}
+- else
+  p
+    | No Errors
+
+p
+ = pretty_id

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

@@ -0,0 +1,2 @@
+p
+  = greeting

data/spec/integration/exposures_spec.rb

@@ -10,8 +10,8 @@ RSpec.describe 'exposures' do
         config.default_format = :html
       end
 
-      expose :users do |input|
-        input.fetch(:users).map { |user|
+      expose :users do |users:|
+        users.map { |user|
           user.merge(name: user[:name].upcase)
         }
       end
@@ -43,8 +43,8 @@ RSpec.describe 'exposures' do
         @prefix = "My friend "
       end
 
-      expose :users do |input|
-        input.fetch(:users).map { |user|
+      expose :users do |users:|
+        users.map { |user|
           user.merge(name: prefix + user[:name])
         }
       end
@@ -73,8 +73,8 @@ RSpec.describe 'exposures' do
 
       private
 
-      def users(input)
-        input.fetch(:users).map { |user|
+      def users(users:)
+        users.map { |user|
           user.merge(name: user[:name].upcase)
         }
       end
@@ -112,6 +112,40 @@ RSpec.describe 'exposures' do
     )
   end
 
+  it 'using default values' 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
+
+      expose :users, default: [{name: 'John', email: 'john@william.org'}]
+    end.new
+
+    expect(vc.(context: context)).to eql(
+      '<!DOCTYPE html><html><head><title>dry-view rocks!</title></head><body><div class="users"><table><tbody><tr><td>John</td><td>john@william.org</td></tr></tbody></table></div><img src="mindblown.jpg" /></body></html>'
+    )
+  end
+
+  it 'having default values but passing nil as value for exposure' do
+    vc = Class.new(Dry::View::Controller) do
+      configure do |config|
+        config.paths = SPEC_ROOT.join('fixtures/templates')
+        config.layout = 'app'
+        config.template = 'greeting'
+        config.default_format = :html
+      end
+
+      expose :greeting, default: 'Hello Dry-rb'
+    end.new
+
+    expect(vc.(greeting: nil, context: context)).to eql(
+      '<!DOCTYPE html><html><head><title>dry-view rocks!</title></head><body><p></p></body></html>'
+    )
+  end
+
   it 'allows exposures to depend on each other' do
     vc = Class.new(Dry::View::Controller) do
       configure do |config|
@@ -121,11 +155,9 @@ RSpec.describe 'exposures' do
         config.default_format = :html
       end
 
-      expose :users do |input|
-        input.fetch(:users)
-      end
+      expose :users
 
-      expose :users_count do |users|
+      expose :users_count do |users:|
         "#{users.length} users"
       end
     end.new
@@ -140,6 +172,75 @@ RSpec.describe 'exposures' do
     )
   end
 
+  it 'allows exposures to depend on each other and access keywords args from input' do
+    vc = Class.new(Dry::View::Controller) do
+      configure do |config|
+        config.paths = SPEC_ROOT.join('fixtures/templates')
+        config.layout = 'app'
+        config.template = 'greeting'
+        config.default_format = :html
+      end
+
+      expose :greeting do |prefix, greeting:|
+        "#{prefix} #{greeting}"
+      end
+
+      expose :prefix do
+        'Hello'
+      end
+    end.new
+
+    expect(vc.(greeting: 'From dry-view internals', context: context)).to eql(
+      '<!DOCTYPE html><html><head><title>dry-view rocks!</title></head><body><p>Hello From dry-view internals</p></body></html>'
+    )
+  end
+
+  it 'set default values for keyword arguments' do
+    vc = Class.new(Dry::View::Controller) do
+      configure do |config|
+        config.paths = SPEC_ROOT.join('fixtures/templates')
+        config.layout = 'app'
+        config.template = 'greeting'
+        config.default_format = :html
+      end
+
+      expose :greeting do |prefix, greeting: 'From the defaults'|
+        "#{prefix} #{greeting}"
+      end
+
+      expose :prefix do
+        'Hello'
+      end
+    end.new
+
+    expect(vc.(context: context)).to eql(
+      '<!DOCTYPE html><html><head><title>dry-view rocks!</title></head><body><p>Hello From the defaults</p></body></html>'
+    )
+  end
+
+  it 'only pass keywords arguments that are needit in the block and allow for default values' do
+    vc = Class.new(Dry::View::Controller) do
+      configure do |config|
+        config.paths = SPEC_ROOT.join('fixtures/templates')
+        config.layout = 'app'
+        config.template = 'edit'
+        config.default_format = :html
+      end
+
+      expose :pretty_id do |id:|
+        "Beautiful #{id}"
+      end
+
+      expose :errors do |errors: []|
+        errors
+      end
+    end.new
+
+    expect(vc.(id: 1, context: context)).to eql(
+      '<!DOCTYPE html><html><head><title>dry-view rocks!</title></head><body><h1>Edit</h1><p>No Errors</p><p>Beautiful 1</p></body></html>'
+    )
+  end
+
   it 'supports defining multiple exposures at once' do
     vc = Class.new(Dry::View::Controller) do
       configure do |config|
@@ -153,11 +254,7 @@ RSpec.describe 'exposures' do
 
       private
 
-      def users(input)
-        input.fetch(:users)
-      end
-
-      def users_count(users)
+      def users_count(users:)
         "#{users.length} users"
       end
     end.new
@@ -185,11 +282,9 @@ RSpec.describe 'exposures' do
         "COUNT: "
       end
 
-      expose :users do |input|
-        input.fetch(:users)
-      end
+      expose :users
 
-      expose :users_count do |prefix, users|
+      expose :users_count do |prefix, users:|
         "#{prefix}#{users.length} users"
       end
     end.new

data/spec/spec_helper.rb

@@ -6,7 +6,7 @@ if RUBY_ENGINE == 'ruby'
 end
 
 begin
-  require 'byebug'
+  require 'pry-byebug'
 rescue LoadError; end
 
 SPEC_ROOT = Pathname(__FILE__).dirname

data/spec/unit/controller_spec.rb

@@ -1,18 +1,13 @@
 RSpec.describe Dry::View::Controller do
-  subject(:layout) { layout_class.new }
-
-  let(:layout_class) do
-    klass = Class.new(Dry::View::Controller)
-
-    klass.configure do |config|
-      config.paths = SPEC_ROOT.join('fixtures/templates')
-      config.layout = 'app'
-      config.template = 'user'
-      config.default_format = :html
-    end
-
-    klass
-  end
+  subject(:controller) {
+    Class.new(Dry::View::Controller) do
+      configure do |config|
+        config.paths = SPEC_ROOT.join('fixtures/templates')
+        config.layout = 'app'
+        config.template = 'user'
+      end
+    end.new
+  }
 
   let(:page) do
     double(:page, title: 'Test')
@@ -22,15 +17,21 @@ RSpec.describe Dry::View::Controller do
     { context: page, locals: { user: { name: 'Jane' }, header: { title: 'User' } } }
   end
 
-  let(:renderer) do
-    layout.class.renderers[:html]
-  end
-
   describe '#call' do
     it 'renders template within the layout' do
-      expect(layout.(options)).to eql(
+      expect(controller.(options)).to eql(
         '<!DOCTYPE html><html><head><title>Test</title></head><body><h1>User</h1><p>Jane</p></body></html>'
       )
     end
+
+    it 'provides a meaningful error if the template name is missing' do
+      controller = Class.new(Dry::View::Controller) do
+        configure do |config|
+          config.paths = SPEC_ROOT.join('fixtures/templates')
+        end
+      end.new
+
+      expect { controller.(options) }.to raise_error Dry::View::Controller::UndefinedTemplateError
+    end
   end
 end

data/spec/unit/exposure_spec.rb

@@ -1,8 +1,9 @@
 RSpec.describe Dry::View::Exposure do
-  subject(:exposure) { described_class.new(:hello, proc, object) }
+  subject(:exposure) { described_class.new(:hello, proc, object, **options) }
 
   let(:proc) { -> input { "hi" } }
   let(:object) { nil }
+  let(:options) { {} }
 
   describe "initialization and attributes" do
     describe "#name" do
@@ -42,6 +43,17 @@ RSpec.describe Dry::View::Exposure do
         expect(described_class.new(:hello, private: true)).to be_private
       end
     end
+
+    describe "#default_value" do
+      it "is nil by default" do
+        expect(exposure.default_value).to be_nil
+      end
+
+      it "can be set on initialization" do
+        exposuse = described_class.new(:hello, default: 'Hi !')
+        expect(exposuse.default_value).to eq('Hi !')
+      end
+    end
   end
 
   describe "#bind" do
@@ -90,12 +102,12 @@ RSpec.describe Dry::View::Exposure do
     end
   end
 
-  describe "#dependencies" do
+  describe "#dependency_names" do
     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]
+        expect(exposure.dependency_names).to eql [:input, :foo, :bar]
       end
     end
 
@@ -111,7 +123,7 @@ RSpec.describe Dry::View::Exposure do
       end
 
       it "returns an array of exposure dependencies derived from the instance method's argument names" do
-        expect(exposure.dependencies).to eql [:input, :bar, :baz]
+        expect(exposure.dependency_names).to eql [:input, :bar, :baz]
       end
     end
 
@@ -119,28 +131,56 @@ RSpec.describe Dry::View::Exposure do
       let(:proc) { nil }
 
       it "returns no dependencies" do
-        expect(exposure.dependencies).to eql []
+        expect(exposure.dependency_names).to eql []
       end
     end
   end
 
   describe "#call" do
-    let(:input) { "input" }
+    let(:input) { {name: "Jane"} }
 
     context "proc expects input only" do
-      let(:proc) { -> input { input } }
+      let(:proc) { -> name: { name } }
 
       it "sends the input to the proc" do
-        expect(exposure.(input)).to eql "input"
+        expect(exposure.(input)).to eql "Jane"
       end
     end
 
     context "proc expects input and dependencies" do
-      let(:proc) { -> input, greeting { "#{greeting}, #{input}" } }
+      let(:proc) { -> greeting, name: { "#{greeting}, #{name}" } }
       let(:locals) { {greeting: "Hola"} }
 
       it "sends the input and dependency values to the proc" do
-        expect(exposure.(input, locals)).to eq "Hola, input"
+        expect(exposure.(input, locals)).to eq "Hola, Jane"
+      end
+    end
+
+    context "Default value" do
+      let(:options) { { default: "John" } }
+
+      context "use default value" do
+        let(:proc) { nil }
+
+        it "use the default value" do
+          expect(exposure.({})).to eq "John"
+        end
+      end
+
+      context "use input value instead of default" do
+        let(:proc) { nil }
+
+        it "use the default value" do
+          expect(exposure.({hello: "Jane"})).to eq "Jane"
+        end
+      end
+
+      context "use input value over default even when input is nil" do
+        let(:proc) { nil }
+
+        it "use the default value" do
+          expect(exposure.({hello: nil})).to eq nil
+        end
       end
     end
 
@@ -154,20 +194,20 @@ RSpec.describe Dry::View::Exposure do
     end
 
     context "proc accesses object instance" do
-      let(:proc) { -> input { "#{input} from #{name}" } }
+      let(:proc) { -> name: { "My name is #{name} but call me #{title} #{name}" } }
 
       let(:object) do
         Class.new do
-          attr_reader :name
+          attr_reader :title
 
-          def initialize(name)
-            @name = name
+          def initialize(title)
+            @title = title
           end
-        end.new("Jane")
+        end.new("Dr")
       end
 
       it "makes the instance available as self" do
-        expect(exposure.(input)).to eq "input from Jane"
+        expect(exposure.(input)).to eq "My name is Jane but call me Dr Jane"
       end
     end
 

data/spec/unit/exposures_spec.rb

@@ -9,7 +9,7 @@ RSpec.describe Dry::View::Exposures do
 
   describe "#add" do
     it "creates and adds an exposure" do
-      proc = -> input { "hi" }
+      proc = -> **input { "hi" }
       exposures.add :hello, proc
 
       expect(exposures[:hello].name).to eq :hello
@@ -43,7 +43,7 @@ RSpec.describe Dry::View::Exposures do
 
   describe "#locals" do
     before do
-      exposures.add(:greeting, -> input { input.fetch(:greeting).upcase })
+      exposures.add(:greeting, -> greeting: { greeting.upcase })
       exposures.add(:farewell, -> greeting { "#{greeting} and goodbye" })
     end
 
@@ -54,10 +54,40 @@ RSpec.describe Dry::View::Exposures do
     end
 
     it "does not return any values from private exposures" do
-      exposures.add(:hidden, -> input { "shh" }, private: true)
+      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
 end

data/spec/unit/part_spec.rb

@@ -5,61 +5,76 @@ RSpec::Matchers.define :template_scope do |locals|
 end
 
 RSpec.describe Dry::View::Part do
-  subject(:part) { described_class.new(name: name, value: value, renderer: renderer, context: context) }
+  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) { double('renderer') }
+    let(:name) { :user }
+    let(:value) { double(:value) }
+    let(:context) { double(:context) }
+    let(:renderer) { spy(:renderer) }
 
-  describe '#render' do
-    before do
-      allow(renderer).to receive(:lookup).with('_info').and_return '_info.html.erb'
-      allow(renderer).to receive(:render)
-    end
+    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 '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(:partial).with(:info, template_scope(admin: 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))
+      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
 
-    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
 
-  describe '#to_s' do
-    before do
-      allow(value).to receive(:to_s).and_return 'to_s on the value'
+      it 'delegates to the wrapped value' do
+        expect(part.to_s).to eq 'to_s on the value'
+      end
     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') }
 
-  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 '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
 
-    it 'forwards all arguments to the method' do
-      blk = -> { }
-      part.greeting 'args', &blk
+        expect(value).to have_received(:greeting).with('args', &blk)
+      end
 
-      expect(value).to have_received(:greeting).with('args', &blk)
+      it 'raises an error if no metho matches' do
+        expect { part.farewell }.to raise_error(NoMethodError)
+      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 '#new' do
+      it 'can be initialized' do
+        expect(part).to be_an_instance_of(Dry::View::Part)
+      end
 
-    it 'raises an error if no metho matches' do
-      expect { part.farewell }.to raise_error(NoMethodError)
+      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

@@ -3,28 +3,55 @@ 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')
+    Dry::View::Renderer.new(
+      [Dry::View::Path.new(SPEC_ROOT.join('fixtures/templates'))],
+      format: 'html'
+    )
   end
 
   let(:scope) { double(:scope) }
 
-  describe '#call' do
-    it 'renders template' do
-      expect(renderer.('hello', scope)).to eql('<h1>Hello</h1>')
+  describe '#template' do
+    it 'renders template in current directory' do
+      expect(renderer.template(:hello, scope)).to eql('<h1>Hello</h1>')
     end
 
-    it 'looks up shared template in current dir' do
-      expect(renderer.('_shared_hello', scope)).to eql('<h1>Hello</h1>')
+    it 'renders template in shared/ subdirectory' do
+      expect(renderer.template(:_shared_hello, scope)).to eql('<h1>Hello</h1>')
     end
 
-    it 'looks up shared template in upper dir' do
-      expect(renderer.chdir('greetings').('_shared_hello', scope)).to eql('<h1>Hello</h1>')
+    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 was not found' do
+    it 'raises error when template cannot be found' do
       expect {
-        renderer.('not_found', scope)
-      }.to raise_error(Dry::View::Renderer::TemplateNotFoundError, /not_found/)
+        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

@@ -2,25 +2,20 @@ 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) { double('renderer') }
+  let(:context) { double(:context) }
+  let(:renderer) { spy(: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 itself as the scope' do
       scope.render(:info)
-      expect(renderer).to have_received(:render).with('_info.html.erb', scope)
+      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(:render).with('_info.html.erb', scope_with_locals)
+      expect(renderer).to have_received(:partial).with(:info, scope_with_locals)
     end
   end
 

metadata

@@ -1,7 +1,7 @@
 --- !ruby/object:Gem::Specification
 name: dry-view
 version: !ruby/object:Gem::Version
-  version: 0.3.0
+  version: 0.4.0
 platform: ruby
 authors:
 - Piotr Solnica
@@ -9,7 +9,7 @@ authors:
 autorequire: 
 bindir: exe
 cert_chain: []
-date: 2017-05-14 00:00:00.000000000 Z
+date: 2017-11-01 00:00:00.000000000 Z
 dependencies:
 - !ruby/object:Gem::Dependency
   name: tilt
@@ -121,6 +121,7 @@ files:
 - ".rspec"
 - ".travis.yml"
 - CHANGELOG.md
+- CONTRIBUTING.md
 - Gemfile
 - LICENSE.md
 - README.md
@@ -135,13 +136,17 @@ files:
 - lib/dry/view/decorator.rb
 - lib/dry/view/exposure.rb
 - lib/dry/view/exposures.rb
+- lib/dry/view/missing_renderer.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/_hello.html.slim
 - spec/fixtures/templates/decorated_parts.html.slim
+- spec/fixtures/templates/edit.html.slim
 - spec/fixtures/templates/empty.html.slim
+- spec/fixtures/templates/greeting.html.slim
 - spec/fixtures/templates/hello.html.slim
 - spec/fixtures/templates/layouts/app.html.slim
 - spec/fixtures/templates/layouts/app.txt.erb
@@ -180,7 +185,7 @@ required_ruby_version: !ruby/object:Gem::Requirement
   requirements:
   - - ">="
     - !ruby/object:Gem::Version
-      version: 2.1.0
+      version: 2.2.0
 required_rubygems_version: !ruby/object:Gem::Requirement
   requirements:
   - - ">="
@@ -188,13 +193,16 @@ required_rubygems_version: !ruby/object:Gem::Requirement
       version: '0'
 requirements: []
 rubyforge_project: 
-rubygems_version: 2.6.10
+rubygems_version: 2.6.11
 signing_key: 
 specification_version: 4
 summary: Functional view rendering system
 test_files:
+- spec/fixtures/templates/_hello.html.slim
 - spec/fixtures/templates/decorated_parts.html.slim
+- spec/fixtures/templates/edit.html.slim
 - spec/fixtures/templates/empty.html.slim
+- spec/fixtures/templates/greeting.html.slim
 - spec/fixtures/templates/hello.html.slim
 - spec/fixtures/templates/layouts/app.html.slim
 - spec/fixtures/templates/layouts/app.txt.erb