dry-view 0.1.1 → 0.2.0

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA1:
-  metadata.gz: f3b4e09263f41a0b0972c1270fa32e5911ad028b
-  data.tar.gz: b7787ff1b20f6fae7c4c67461ac7e2c1cf51e498
+  metadata.gz: 5cf179c08c3deb29086bc87197420a301595a70f
+  data.tar.gz: 1c6eccdfb39502b559748c8c75d4c4b127b16019
 SHA512:
-  metadata.gz: d79d4a61109cce4b3885d5c0bba544563ebd8d253465acb33c1022f62a61f369de0c972a2ea6657d1d6fb76841a4e4e5baaea7d5df16864e6f2f0b43e54ae881
-  data.tar.gz: 84a995bd47ddd4909cc8658bb2af52dc369b96b9c37d4f74add32a8fc21ce682837fbb7226c16aab164c0389197b5d9183b3bc82009ed608c7fb2d6c9002c3dc
+  metadata.gz: 390c86f0b801d44bfe8a5958a982da88a52030dbfbf4403380af90c82c1279d3603a0f4376d1b2f349f3e42f36628c3a551b37e3fe8d2d75874b77d1e4d1efb3
+  data.tar.gz: cfdc7df2e7d8b63cda8611d203d9ec39da0a31d9237e742a00e861244556b2cfc5854b09a312abb358f77c572d4102b56d707d74ee27a61154fb7d6c44952756

data/.travis.yml

@@ -1,25 +1,29 @@
 language: ruby
+dist: trusty
 sudo: false
 cache: bundler
 bundler_args: --without tools benchmarks
+before_install:
+  - gem update --system
+  - rvm @global do gem uninstall bundler -a -x
+  - rvm @global do gem install bundler -v 1.13.7
 script:
-  - bundle exec rake spec
+  - bundle exec rake
+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.0
-  - 2.1
-  - 2.2
-  - 2.3.0
-  - rbx
-  - jruby-9000
-  - ruby-head
-  - jruby-head
+  - 2.4.0
+  - 2.3.3
+  - 2.2.6
+  - 2.1.10
+  - jruby-9.1.6.0
 env:
   global:
     - JRUBY_OPTS='--dev -J-Xmx1024M'
 matrix:
   allow_failures:
-    - rvm: ruby-head
-    - rvm: jruby-head
+    - rvm: jruby-9.1.6.0
 notifications:
   email: false
   webhooks:

data/CHANGELOG.md

@@ -1,7 +1,30 @@
+# 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.
+
+### Changed
+
+- [BREAKING] `Dry::View::Layout` renamed to `Dry::View::Controller`. The "view controller" name better represents this object's job: to  (timriley)
+- [BREAKING] `Dry::View::Controller`'s `name` setting is replaced by `template`, which also supports falsey values to disable layout rendering entirely (timriley)
+- [BREAKING] `Dry::View::Controller`'s `formats` setting is replaced by `default_format`, which expects a simple string or symbol. The default value is `:html`. (timriley)
+- [BREAKING] `Dry::View::Controller`'s `root` setting is replaced by `paths`, which can now accept an array of one or more directories. These will be searched for templates in order, with the first match winning (timriley)
+- [BREAKING] `Dry::View::Controller`'s `scope` setting is removed and replaced by `context`, which will be made available to all templates rendered from a view controller (layouts and partials inculded), not just the layout (timriley)
+- [BREAKING] View parts have been replaced by a simple `Scope`. Data passed to the templates can be accessed directly, rather than wrapped up in a view part. (timriley)
+- [BREAKING] With view parts removed, partials can only be rendered by top-level method calls within templates (timriley)
+- Ruby version 2.1.0 is now the earliest supported version (timriley)
+
+### Added
+
+- Will render templates using any Tilt-supported engine, based on the template's final file extension (e.g. `hello.html.slim` will use Slim). For thread-safety, be sure to explicitly require any engine gems you intend to use. (timriley)
+- `expose` (and `expose_private`) `Dry::View::Controller` class methods allow you to more easily declare and prepare the data for your template (timriley)
+- Added `Dry::View::Scope`, which is the scope used for rendering templates. This includes the data from the exposures along with the context object (timriley)
+
 # 0.1.1 / 2016-07-07
 
 ### Changed
 
+- Wrap `page` object exposed to layout templates in a part object, so it offers behaviour that is consistent with the part objects that template authors work with on other templates (timriley)
+- Render template content first, before passing that content to the layout. This makes "content_for"-style behaviours possible, where the template stores some data that the layout can then use later (timriley)
 - Configure default template encoding to be UTF-8, fixing some issues with template rendering on deployed sites (gotar)
 
 # 0.1.0 / 2016-03-28

data/Gemfile

@@ -2,16 +2,17 @@ source 'https://rubygems.org'
 
 gemspec
 
+group :tools do
+  gem 'pry'
+end
+
 group :test do
   gem 'byebug', platform: :mri
   gem 'rack', '>= 1.0.0', '<= 2.0.0'
   gem 'slim'
 
-  gem 'codeclimate-test-reporter', platform: :rbx
-end
-
-group :tools do
-  gem 'pry'
+  gem 'simplecov'
+  gem 'codeclimate-test-reporter'
 end
 
 group :benchmarks do

data/README.md

@@ -12,4 +12,11 @@
 [![Test Coverage](https://img.shields.io/codeclimate/coverage/github/dry-rb/dry-view.svg)][code_climate]
 [![API Documentation Coverage](http://inch-ci.org/github/dry-rb/dry-view.svg)][inch]
 
-Data-oriented view rendering system.
+
+A simple, standalone view rendering system built around functional view
+controllers and templates. dry-view allows you to model your views as stateless
+transformations, accepting user input and returning your rendered view.
+
+## Links
+
+* [Documentation](http://dry-rb.org/gems/dry-view)

data/benchmarks/view.rb

@@ -12,14 +12,13 @@ class ActionRender
 end
 
 action_renderer = ActionRender.new
-rodakase_renderer = Dry::View::Renderer.new(Pathname(__FILE__).dirname.join('templates'), engine: :erb)
-
-template = rodakase_renderer.dir.join('button.erb')
+dry_view_renderer = Dry::View::Renderer.new(Pathname(__FILE__).dirname.join('templates'), format: :html)
 
+template = Pathname(__FILE__).dirname.join('templates').join('button.html.erb')
 SCOPE = {}
 
 Benchmark.ips do |x|
   x.report('actionview') { action_renderer.button }
-  x.report('rodakase') { rodakase_renderer.render(template, SCOPE) }
+  x.report('dry-view') { dry_view_renderer.render(template, SCOPE) }
   x.compare!
 end

data/bin/console

@@ -0,0 +1,7 @@
+#!/usr/bin/env ruby
+
+require "bundler/setup"
+require "dry-view"
+
+require "pry"
+Pry.start

data/dry-view.gemspec

@@ -6,19 +6,21 @@ require 'dry/view/version'
 Gem::Specification.new do |spec|
   spec.name          = "dry-view"
   spec.version       = Dry::View::VERSION
-  spec.authors       = ["Piotr Solnica"]
-  spec.email         = ["piotr.solnica@gmail.com"]
-  spec.summary       = "Lightweight web application stack on top of Roda"
+  spec.authors       = ["Piotr Solnica", "Tim Riley"]
+  spec.email         = ["piotr.solnica@gmail.com", "tim@icelab.com.au"]
+  spec.summary       = "Functional view rendering system"
   spec.description   = spec.summary
   spec.homepage      = "https://github.com/dry-rb/dry-view"
   spec.license       = "MIT"
 
   spec.files         = `git ls-files -z`.split("\x0")
-  spec.executables   = spec.files.grep(%r{^bin/}) { |f| File.basename(f) }
+  spec.bindir        = "exe"
+  spec.executables   = spec.files.grep(%r{^exe/}) { |f| File.basename(f) }
   spec.test_files    = spec.files.grep(%r{^(test|spec|features)/})
   spec.require_paths = ["lib"]
 
-  spec.add_runtime_dependency "inflecto", "~> 0"
+  spec.required_ruby_version = '>= 2.1.0'
+
   spec.add_runtime_dependency "tilt", "~> 2.0"
   spec.add_runtime_dependency "dry-configurable", "~> 0.1"
   spec.add_runtime_dependency "dry-equalizer", "~> 0.2"
@@ -26,5 +28,4 @@ Gem::Specification.new do |spec|
   spec.add_development_dependency "bundler", "~> 1.7"
   spec.add_development_dependency "rake", "~> 10.0"
   spec.add_development_dependency "rspec", "~> 3.1"
-  spec.add_development_dependency "capybara", "~> 2.5"
 end

data/lib/dry/view/controller.rb

@@ -0,0 +1,107 @@
+require 'dry-configurable'
+require 'dry-equalizer'
+
+require 'dry/view/path'
+require 'dry/view/exposures'
+require 'dry/view/renderer'
+require 'dry/view/scope'
+
+module Dry
+  module View
+    class Controller
+      DEFAULT_LAYOUTS_DIR = 'layouts'.freeze
+      DEFAULT_CONTEXT = Object.new.freeze
+      EMPTY_LOCALS = {}.freeze
+
+      include Dry::Equalizer(:config)
+
+      extend Dry::Configurable
+
+      setting :paths
+      setting :layout, false
+      setting :context, DEFAULT_CONTEXT
+      setting :template
+      setting :default_format, :html
+
+      attr_reader :config
+      attr_reader :layout_dir
+      attr_reader :layout_path
+      attr_reader :template_path
+      attr_reader :exposures
+
+      def self.paths
+        Array(config.paths).map { |path| Dry::View::Path.new(path) }
+      end
+
+      def self.renderer(format)
+        renderers.fetch(format) {
+          renderers[format] = Renderer.new(paths, format: format)
+        }
+      end
+
+      def self.renderers
+        @renderers ||= {}
+      end
+
+      def self.expose(*names, **options, &block)
+        if names.length == 1
+          exposures.add(names.first, block, **options)
+        else
+          names.each do |name|
+            exposures.add(name, nil, **options)
+          end
+        end
+      end
+
+      def self.private_expose(*names, &block)
+        expose(*names, to_view: false, &block)
+      end
+
+      def self.exposures
+        @exposures ||= Exposures.new
+      end
+
+      def initialize
+        @config = self.class.config
+        @layout_dir = DEFAULT_LAYOUTS_DIR
+        @layout_path = "#{layout_dir}/#{config.layout}"
+        @template_path = config.template
+        @exposures = self.class.exposures.bind(self)
+      end
+
+      def call(format: config.default_format, **input)
+        renderer = self.class.renderer(format)
+
+        template_content = renderer.(template_path, template_scope(renderer, **input))
+
+        return template_content unless layout?
+
+        renderer.(layout_path, layout_scope(renderer, **input)) do
+          template_content
+        end
+      end
+
+      def locals(locals: EMPTY_LOCALS, **input)
+        exposures.locals(input).merge(locals)
+      end
+
+      private
+
+      def layout?
+        !!config.layout
+      end
+
+      def layout_scope(renderer, context: config.context, **)
+        scope(renderer.chdir(layout_dir), EMPTY_LOCALS, context)
+      end
+
+      def template_scope(renderer, context: config.context, **input)
+        scope(renderer.chdir(template_path), locals(**input), context)
+      end
+
+      def scope(renderer, locals, context)
+        Scope.new(renderer, locals, context)
+      end
+    end
+  end
+end

data/lib/dry/view/exposure.rb

@@ -0,0 +1,61 @@
+module Dry
+  module View
+    class Exposure
+      SUPPORTED_PARAMETER_TYPES = [:req, :opt].freeze
+
+      attr_reader :name
+      attr_reader :proc
+      attr_reader :to_view
+
+      def initialize(name, proc = nil, to_view: true)
+        ensure_proc_parameters(proc) if proc
+
+        @name = name
+        @proc = proc
+        @to_view = to_view
+      end
+
+      def bind(obj)
+        proc ? self : with_default_proc(obj)
+      end
+
+      def dependencies
+        proc.parameters.map(&:last)
+      end
+
+      alias_method :to_view?, :to_view
+
+      def call(input, locals = {})
+        params = dependencies.map.with_index { |name, position|
+          if position.zero?
+            locals.fetch(name) { input }
+          else
+            locals.fetch(name)
+          end
+        }
+
+        proc.(*params)
+      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)
+        else
+          -> input { input.fetch(name) }
+        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"
+        end
+      end
+    end
+  end
+end

data/lib/dry/view/exposures.rb

@@ -0,0 +1,50 @@
+require "tsort"
+require "dry/view/exposure"
+
+module Dry
+  module View
+    class Exposures
+      include TSort
+
+      attr_reader :exposures
+
+      def initialize(exposures = {})
+        @exposures = exposures
+      end
+
+      def [](name)
+        exposures[name]
+      end
+
+      def add(name, proc = nil, **options)
+        exposures[name] = Exposure.new(name, proc, **options)
+      end
+
+      def bind(obj)
+        bound_exposures = Hash[exposures.map { |name, exposure|
+          [name, exposure.bind(obj)]
+        }]
+
+        self.class.new(bound_exposures)
+      end
+
+      def locals(input)
+        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?
+        }
+      end
+
+      private
+
+      def tsort_each_node(&block)
+        exposures.each_key(&block)
+      end
+
+      def tsort_each_child(name, &block)
+        self[name].dependencies.each(&block) if exposures.key?(name)
+      end
+    end
+  end
+end

data/lib/dry/view/path.rb

@@ -0,0 +1,40 @@
+require "pathname"
+
+module Dry
+  module View
+    class Path
+      include Dry::Equalizer(:dir, :root)
+
+      attr_reader :dir, :root
+
+      def initialize(dir, options = {})
+        @dir = Pathname(dir)
+        @root = Pathname(options.fetch(:root, dir))
+      end
+
+      def lookup(name, format)
+        template?(name, format) || template?("shared/#{name}", format) || !root? && chdir('..').lookup(name, format)
+      end
+
+      def chdir(dirname)
+        self.class.new(dir.join(dirname), root: root)
+      end
+
+      def to_s
+        dir
+      end
+
+      private
+
+      def root?
+        dir == root
+      end
+
+      # Search for a template using a wildcard for the engine extension
+      def template?(name, format)
+        glob = dir.join("#{name}.#{format}.*")
+        Dir[glob].first
+      end
+    end
+  end
+end

data/lib/dry/view/renderer.rb

@@ -4,21 +4,19 @@ require 'dry-equalizer'
 module Dry
   module View
     class Renderer
-      include Dry::Equalizer(:dir, :root, :engine)
+      include Dry::Equalizer(:paths, :format)
 
       TemplateNotFoundError = Class.new(StandardError)
 
-      attr_reader :dir, :root, :format, :engine, :tilts
+      attr_reader :paths, :format, :engine, :tilts
 
       def self.tilts
         @__engines__ ||= {}
       end
 
-      def initialize(dir, options = {})
-        @dir = dir
-        @root = options.fetch(:root, dir)
-        @format = options[:format]
-        @engine = options[:engine]
+      def initialize(paths, format:)
+        @paths = paths
+        @format = format
         @tilts = self.class.tilts
       end
 
@@ -28,7 +26,8 @@ module Dry
         if path
           render(path, scope, &block)
         else
-          raise TemplateNotFoundError, "Template #{template} could not be looked up within #{root}"
+          msg = "Template #{template.inspect} could not be found in paths:\n#{paths.map { |pa| "- #{pa.to_s}" }.join("\n")}"
+          raise TemplateNotFoundError, msg
         end
       end
 
@@ -36,32 +35,25 @@ module Dry
         tilt(path).render(scope, &block)
       end
 
-      def tilt(path)
-        tilts.fetch(path) { tilts[path] = Tilt[engine].new(path, nil, default_encoding: "utf-8") }
-      end
-
-      def lookup(name)
-        template?(name) || template?("shared/#{name}") || !root? && chdir('..').lookup(name)
-      end
+      def chdir(dirname)
+        new_paths = paths.map { |path| path.chdir(dirname) }
 
-      def root?
-        dir == root
+        self.class.new(new_paths, format: format)
       end
 
-      def template?(name)
-        template_path = path(name)
-
-        if File.exist?(template_path)
-          template_path
-        end
+      def lookup(name)
+        paths.inject(false) { |result, path|
+          result || path.lookup(name, format)
+        }
       end
 
-      def path(name)
-        dir.join("#{name}.#{format}.#{engine}")
-      end
+      private
 
-      def chdir(dirname)
-        self.class.new(dir.join(dirname), engine: engine, format: format, root: root)
+      # TODO: make default_encoding configurable
+      def tilt(path)
+        tilts.fetch(path) {
+          tilts[path] = Tilt.new(path, nil, default_encoding: "utf-8")
+        }
       end
     end
   end

data/lib/dry/view/scope.rb

@@ -0,0 +1,55 @@
+require 'dry-equalizer'
+
+module Dry
+  module View
+    class Scope
+      include Dry::Equalizer(:_renderer, :_data)
+
+      attr_reader :_renderer
+      attr_reader :_data
+      attr_reader :_context
+
+      def initialize(renderer, data, context = nil)
+        @_renderer = renderer
+        @_data = data.to_hash
+        @_context = context
+      end
+
+      def respond_to_missing?(name, include_private = false)
+        _template?(name) || _data.key?(name) || _context.respond_to?(name)
+      end
+
+      private
+
+      def method_missing(name, *args, &block)
+        if _data.key?(name)
+          _data[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)
+        _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)
+        else
+          raise ArgumentError, "render argument must be a Hash"
+        end
+      end
+    end
+  end
+end

data/lib/dry/view/version.rb

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

data/lib/dry/view.rb

@@ -1,2 +1,2 @@
 require 'dry/view/renderer'
-require 'dry/view/layout'
+require 'dry/view/controller'

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

@@ -0,0 +1 @@
+p This is a view with no locals.

data/spec/fixtures/templates/layouts/app.html.slim

@@ -1,6 +1,6 @@
 doctype html
 html
   head
-    title == page.title
+    title == title
   body
     == yield

data/spec/fixtures/templates/layouts/app.txt.erb

@@ -1,3 +1,3 @@
-# <%= page.title %>
+# <%= title %>
 
 <%= yield %>

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

@@ -0,0 +1,3 @@
+div.box
+  h2 = label
+  = user[:name]

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

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

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

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

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

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

data/spec/fixtures/templates/users.txt.erb

@@ -1,5 +1,3 @@
-## <%= subtitle %>
-
 <% users.each do |user| %>
 * <%= user[:name] %> (<%= user[:email] %>)
 <% end %>

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

@@ -0,0 +1,5 @@
+ul
+  - users.each do |user|
+    li = "#{user[:name]} (#{user[:email]})"
+
+.count = users_count

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

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