hanami-view 2.0.0.alpha7 → 2.1.0.beta1

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA256:
-  metadata.gz: 5f1426ce046073c71aeffe9a171b0b0343704686bb92b75046526858ca82f9e8
-  data.tar.gz: 14a7f4078a42e3abd63e5411da1a2fa4b19fdfeaf405184c9c1f11bda7e78210
+  metadata.gz: 547759271a98bf19bed148a823827ddb668f8034ce9673a0db01a989f10d8b4a
+  data.tar.gz: 5fbab49653a3efd335a8b67ce8910a6a077023b57466b0f84f61a71ffc8cc328
 SHA512:
-  metadata.gz: 1a0f2cca15e556ee2c93396f730c6b68d3a7799ec0c2cbebc574b5c73c0315d2192c89ad8d85ad1b273d03b80132b3acf2348befab3c7f22fff28b1ef7e82667
-  data.tar.gz: 5032a5b1c0891a369bf518cf12d0baad00dcfb688ac41625dd61818b635b8ef6dea498a574c9558249a0beb2cd905553b253bb5a0a8b82245030664d0f7bd629
+  metadata.gz: 2f218ce967455774e6b00340a791b17e30accdee496c88f79c2b12721a97e2008d40341b8981f3144caba2a7bacb0eff9aa0e0c51b8f0c25b1406b55c0a68d18
+  data.tar.gz: 83cf8481266c6f0c8e4c76ec3c87b36b60e2e3035fc61db1ee9497675030008efde35fd5890e625a3560b9c6fc0b182956f55c9358e7752f5c6457ea5e4fb5a8

data/CHANGELOG.md

@@ -1,6 +1,44 @@
 # Hanami::View
+
 View layer for Hanami
 
+## v2.1.0.beta1 - 2023-06-29
+
+### Added
+- [Tim Riley] Introduce new ERB engine, `Hanami::View::ERB`, now used by default for ERB templates;
+  the erbse gem is no longer a requirement (#226)
+- [Tim Riley] Introduce `Hanami::View::HTML::SafeString`, returned when calling `String#html_safe`,
+  also introduced via a `Hanami::View::HTML::StringExtensions` module prepended onto `String`. (#226)
+- [Tim Riley] Auto-escape HTML based on whether it is `#html_safe?` in ERB, Haml and Slim templates (#226)
+- [Tim Riley] Add `part_class` and `scope_class` settings, used by the standard `part_builder` and
+  `scope_builder` as the default class to use when no value-specific part or scope classes can be
+  found. These settings default to `Hanami::View::Part` and `Hanami::View::Scope` respectively (#227)
+- [Tim Riley] Introduce `Hanami::View::Helpers::EscapeHelper`, `Hanami::View::Helpers::TagHelper`,
+  `Hanami::View::Helpers::LinkToHelper`, `Hanami::View::Helpers::NumberFormattingHelper`. These
+  helper modules may optionally be mixed into your Part and Scope classes to provide additional
+  conveniences when authoring your views. To do this by default, create your own
+  `Hanaim::View::Part` and `Hanami::View::Scope` subclasses that include these modules, and then
+  configure these as the `part_class` and `scope_class` for your views. (#229)
+
+### Changed
+- [Tim Riley] Use Zeitwerk for code loading; you should now require `require "hanami/view"` just
+  once (#233)
+- [Tim Riley] Change `Context` interface: custom context subclasses now have complete control over
+  their `#initialize` (no longer need to receive `**options` or call `super`); though any mutable
+  ivars should be duped in a custom `#initialize_copy` as required. (#223)
+- [Tim Riley] Change `PartBuilder` and `ScopeBuilder` interfaces to consist of static methods only (#223)
+- [Tim Riley] Finalize the view class config when calling `.new` for the first time (#223)
+- [Tim Riley] Consolidate all internal caches to a single `View.cache` (#223)
+- [Tim Riley] [Internal] Various refactorings to improve rendering performance (#223)
+
+## v2.0.0.alpha8 - 2022-05-19
+
+### Added
+- [Tim Riley] Access a hash of template locals via accessing `locals` inside any template
+
+### Changed
+- [Tim Riley] Removed automatic integration of `Hanami::View` subclasses with their surrounding Hanami application. View base classes within Hanami apps should inherit from `Hanami::Application::View` instead.
+
 ## v2.0.0.alpha7 - 2022-03-08
 
 ### Added

data/README.md

@@ -33,7 +33,7 @@ __Hanami::view__ supports Ruby (MRI) 3.0+
 Add this line to your application's Gemfile:
 
 ```ruby
-gem "hanami/view"
+gem "hanami-view"
 ```
 
 And then execute:
@@ -48,6 +48,18 @@ Or install it yourself as:
 $ gem install hanami-view
 ```
 
-## License
+## Versioning
 
-See `LICENSE` file.
+__Hanami::View__ uses [Semantic Versioning 2.0.0](http://semver.org)
+
+## Contributing
+
+1. Fork it
+2. Create your feature branch (`git checkout -b my-new-feature`)
+3. Commit your changes (`git commit -am 'Add some feature'`)
+4. Push to the branch (`git push origin my-new-feature`)
+5. Create new Pull Request
+
+## Copyright
+
+Copyright © 2014 Hanami Team – Released under MIT License

data/hanami-view.gemspec

@@ -28,10 +28,12 @@ Gem::Specification.new do |spec|
   spec.required_ruby_version = ">= 3.0"
 
   spec.add_runtime_dependency "concurrent-ruby", "~> 1.0"
-  spec.add_runtime_dependency "dry-configurable", "~> 0.13", ">= 0.13.0"
-  spec.add_runtime_dependency "dry-core", "~> 0.5", ">= 0.5"
-  spec.add_runtime_dependency "dry-inflector", "~> 0.1"
+  spec.add_runtime_dependency "dry-configurable", "~> 1.0"
+  spec.add_runtime_dependency "dry-core", "~> 1.0"
+  spec.add_runtime_dependency "dry-inflector", "~> 1.0", "< 2"
+  spec.add_runtime_dependency "temple", "~> 0.10.0", ">= 0.10.2"
   spec.add_runtime_dependency "tilt", "~> 2.0", ">= 2.0.6"
+  spec.add_runtime_dependency "zeitwerk", "~> 2.6"
 
   spec.add_development_dependency "bundler"
   spec.add_development_dependency "rake"

data/lib/hanami/view/cache.rb

@@ -0,0 +1,16 @@
+# frozen_string_literal: true
+
+require "dry/core/cache"
+
+module Hanami
+  class View
+    # @api private
+    class Cache
+      extend Dry::Core::Cache
+
+      def self.clear
+        cache.clear
+      end
+    end
+  end
+end

data/lib/hanami/view/context.rb

@@ -1,9 +1,5 @@
 # frozen_string_literal: true
 
-require "dry/core/equalizer"
-require_relative "application_context"
-require_relative "decorated_attributes"
-
 module Hanami
   class View
     # Provides a baseline environment across all the templates, parts and scopes
@@ -14,84 +10,30 @@ module Hanami
     #
     # @api public
     class Context
-      include Dry::Equalizer(:_options)
       include DecoratedAttributes
 
-      attr_reader :_render_env, :_options
-
-      def self.inherited(subclass)
-        super
-
-        # When inheriting within an Hanami app, add application context behavior
-        provider = application_provider(subclass)
-        if provider
-          subclass.include ApplicationContext.new(provider)
-        end
-      end
+      # @api private
+      attr_reader :_rendering
 
-      def self.application_provider(subclass)
-        if Hanami.respond_to?(:application?) && Hanami.application?
-          Hanami.application.component_provider(subclass)
+      # @api private
+      def self.new(rendering: RenderingMissing.new, **args)
+        allocate.tap do |obj|
+          obj.instance_variable_set(:@_rendering, rendering)
+          obj.send(:initialize, **args)
         end
       end
-      private_class_method :application_provider
 
       # Returns a new instance of Context
       #
-      # In subclasses, you should include an `**options` parameter and pass _all
-      # arguments_ to `super`. This allows Context to make copies of itself
-      # while preserving your dependencies.
-      #
-      # @example
-      #   class MyContext < Hanami::View::Context
-      #     # Injected dependency
-      #     attr_reader :assets
-      #
-      #     def initialize(assets:, **options)
-      #       @assets = assets
-      #       super
-      #     end
-      #   end
-      #
       # @api public
-      def initialize(render_env: nil, **options)
-        @_render_env = render_env
-        @_options = options
+      def initialize(**)
       end
 
       # @api private
-      def for_render_env(render_env)
-        return self if render_env == _render_env
-
-        self.class.new(**_options.merge(render_env: render_env))
-      end
-
-      # Returns a copy of the Context with new options merged in.
-      #
-      # This may be useful to supply values for dependencies that are _optional_
-      # when initializing your custom Context subclass.
-      #
-      # @example
-      #   class MyContext < Hanami::View::Context
-      #     # Injected dependencies (request is optional)
-      #     attr_reader :assets, :request
-      #
-      #     def initialize(assets:, request: nil, **options)
-      #       @assets = assets
-      #       @request = reuqest
-      #       super
-      #     end
-      #   end
-      #
-      #   my_context = MyContext.new(assets: assets)
-      #   my_context_with_request = my_context.with(request: request)
-      #
-      # @api public
-      def with(**new_options)
-        self.class.new(
-          render_env: _render_env,
-          **_options.merge(new_options)
-        )
+      def dup_for_rendering(rendering)
+        dup.tap do |obj|
+          obj.instance_variable_set(:@_rendering, rendering)
+        end
       end
     end
   end

data/lib/hanami/view/context_helpers/content_helpers.rb

@@ -2,20 +2,20 @@ module Hanami
   class View
     module ContextHelpers
       module ContentHelpers
-        def initialize(content: {}, **options)
+        def initialize(**)
+          @content_for = {}
           super
         end
 
         def content_for(key, value = nil, &block)
-          content = _options[:content]
           output = nil
 
           if block
-            content[key] = yield
+            @content_for[key] = yield
           elsif value
-            content[key] = value
+            @content_for[key] = value
           else
-            output = content[key]
+            output = @content_for[key]
           end
 
           output

data/lib/hanami/view/decorated_attributes.rb

@@ -63,8 +63,8 @@ module Hanami
               define_method name do
                 attribute = super()
 
-                if _render_env && attribute
-                  _render_env.part(name, attribute, **options)
+                if _rendering && attribute
+                  _rendering.part(name, attribute, **options)
                 else
                   attribute
                 end

data/lib/hanami/view/erb/engine.rb

@@ -0,0 +1,27 @@
+# frozen_string_literal: true
+
+require "temple"
+
+module Hanami
+  class View
+    module ERB
+      # Hanami::View ERB engine.
+      #
+      # @api private
+      # @since 2.0.0
+      class Engine < Temple::Engine
+        define_options capture_generator: Hanami::View::HTMLSafeStringBuffer
+
+        use Parser
+        use Filters::Block
+        use Filters::Trimming
+        filter :Escapable, use_html_safe: true
+        filter :StringSplitter
+        filter :StaticAnalyzer
+        filter :MultiFlattener
+        filter :StaticMerger
+        generator :ArrayBuffer
+      end
+    end
+  end
+end

data/lib/hanami/view/erb/filters/block.rb

@@ -0,0 +1,44 @@
+# frozen_string_literal: true
+
+module Hanami
+  class View
+    module ERB
+      module Filters
+        # Implicitly captures and outputs the content inside blocks opened in ERB expression tags,
+        # such as `<%= form_for(:post) do %>`.
+        #
+        # Inspired by Slim's Slim::Controls::Filter#on_slim_output.
+        #
+        # @since 2.0.0
+        # @api private
+        class Block < Temple::Filter
+          END_LINE_RE = /\bend\b/
+
+          def on_erb_block(escape, code, content)
+            tmp = unique_name
+
+            # Remove the last `end` :code sexp, since this is technically "outside" the block
+            # contents, which we want to capture separately below. This `end` is added back after
+            # capturing the content below.
+            case content.last
+            in [:code, c] if c =~ END_LINE_RE
+              content.pop
+            end
+
+            [:multi,
+              # Capture the result of the code in a variable. We can't do `[:dynamic, code]` because
+              # it's probably not a complete expression (which is a requirement for Temple).
+              [:code, "#{tmp} = #{code}"],
+              # Capture the content of a block in a separate buffer. This means that `yield` will
+              # not output the content to the current buffer, but rather return the output.
+              [:capture, unique_name, compile(content)],
+              [:code, "end"],
+              # Output the content.
+              [:escape, escape, [:dynamic, tmp]]
+            ]
+          end
+        end
+      end
+    end
+  end
+end

data/lib/hanami/view/erb/filters/trimming.rb

@@ -0,0 +1,42 @@
+# frozen_string_literal: true
+
+# Based on Temple::ERB::Trimming, also released under the MIT licence.
+#
+# Copyright (c) 2010-2023 Magnus Holm.
+
+module Hanami
+  class View
+    module ERB
+      module Filters
+        # Trims spurious spaces from ERB-generated text.
+        #
+        # Deletes spaces around "<% %>" and leave spaces around "<%= %>".
+        #
+        # This is a copy of Temple::ERB::Trimming, with the one difference being that it descends
+        # into the sexp-tree by running `compile(e)` for any non-`:static` sexps. This is necessary
+        # for our implementation of ERB, because we capture block content by creating additional
+        # `:multi` sexps with their own nested content.
+        #
+        # @api private
+        # @since 2.0.0
+        class Trimming < Temple::Filter
+          define_options trim: true
+
+          def on_multi(*exps)
+            exps = exps.each_with_index.map do |e,i|
+              if e.first == :static && i > 0 && exps[i-1].first == :code
+                [:static, e.last.lstrip]
+              elsif e.first == :static && i < exps.size-1 && exps[i+1].first == :code
+                [:static, e.last.rstrip]
+              else
+                compile(e)
+              end
+            end if options[:trim]
+
+            [:multi, *exps]
+          end
+        end
+      end
+    end
+  end
+end

data/lib/hanami/view/erb/parser.rb

@@ -0,0 +1,161 @@
+# frozen_string_literal: true
+
+# Hanami::View::ERB is based on Temple::ERB::Parser, also released under the MIT licence.
+#
+# Copyright (c) 2010-2023 Magnus Holm.
+
+require "temple"
+
+module Hanami
+  class View
+    module ERB
+      # ERB parser for Hanami views.
+      #
+      # This is a [Temple][temple] parser that prepares a Temple [s-expression][expression] (sexp)
+      # for later generating as HTML via {ERB::Engine}.
+      #
+      # [temple]: https://github.com/judofyr/temple
+      # [expressions]: https://github.com/judofyr/temple/blob/master/EXPRESSIONS.md
+      #
+      # The key features of this parser are:
+      #
+      # - Auto-escaping any non-`html_safe?` values given to `<%=` ERB expression tags, with
+      #   auto-escaping disabled when using `<%==` tags.
+      # - Implicitly capturing and correctly outputting block content without the need for special
+      #   helpers. This allows helpers like `<%= form_for(:post) do %>` to be used, with the
+      #   `form_for` helper itself doing nothing more special than a `yield`.
+      #
+      # To support implicit block capture, this parser differs somewhat from Temple's example ERB
+      # parser, as well as most other Temple parsers. Typical parsers prepare a single `result` sexp
+      # up front, like so:
+      #
+      #   result = [:multi]
+      #
+      # As parsing occurs, new Temple sexps are then pushed onto this `result`.
+      #
+      # In this parser, however, we prepare a _stack_ of results:
+      #
+      #   results = [[:multi]]
+      #
+      # The first item in the stack (`[:multi]`) is the final result that will be returned at the
+      # end of parsing. Every sexp that is generated during parsing will still be added to this
+      # result, directly or indirectly.
+      #
+      # How this happens is that during parsing, every new sexp is push to the _last_ result in this
+      # stack, representing the "current" result.
+      #
+      # The nature of stack becomes important when we encounter an ERB expression tag that opens a
+      # code block, such as `<%= form_for(:post) do %>`.
+      #
+      # In this case, we push an `[:erb, :block, ..., [:multi]]` sexp to the last result, with its
+      # `[:multi]` representing the _contents_ of that code block. We then also push this particular
+      # `[:multi]` onto the `results` stack, so that any subsequent sexps are added to the block's
+      # own contents.
+      #
+      # Then, when we encounter the `<% end %>` closing tag for that block, we pop the block's
+      # `[:multi]` off the results stack. This `[:multi]` isn't lost, however, because it is still
+      # referenced inside the `[:erb, :block, ..., [:multi]]` sexp.
+      #
+      # Taking this approach (along with the `on_erb_block` sexp-handling code in
+      # `Hanami::View::ERB::Filters::Block`) allows us to implicitly capture the contents of the
+      # block and output it in place. This means that helpers that expect blocks do not need to
+      # explicitly call a `capture` helper (or similar) internally. Instead they can just `yield`,
+      # per idiomatic Ruby.
+      #
+      # In fact, we pop a result off the stack _every_ time we encounter an `<% end %>` tag. To
+      # acount for this, every time we encounter an ERB code tag that will have a matching closing
+      # tag (such as `<% if some_cond %>` or `<% 5.times do %>`), we push another reference to the
+      # _current_ last result onto the `results` stack. This allows subsequent sexps to be added to
+      # the same item on the stack (they need no special handling; the special handling is for
+      # blocks with ERB expression tags only) while still allowing it to be popped again when the
+      # matching `<% end %>` is encountered.
+      #
+      # In this way, this stack of results will grow every time a new scope requiring an `end` is
+      # opened, and then will shrink again as each `end` is encountered; think of it as matching the
+      # level of LHS indentation if you were writing such code by hand. This allows each new
+      # generated sexp to be pushed onto `results.last`, knowing that it will go into the right
+      # place in the overall sexp tree. By the time we finish parsing, just a single result will
+      # remain, which is the value returned.
+      #
+      # @api private
+      # @since 2.0.0
+      class Parser < Temple::Parser
+        ERB_PATTERN = /(\n|<%%|%%>)|<%(==?|\#)?(.*?)?-?%>/m
+
+        IF_UNLESS_CASE_LINE_RE = /\A\s*(if|unless|case)\b/
+        BLOCK_LINE_RE = /\s*((\s+|\))do|\{)(\s*\|[^|]*\|)?\s*\Z/
+        END_LINE_RE = /\bend\b/
+
+        def call(input)
+          results = [[:multi]]
+          pos = 0
+
+          input.scan(ERB_PATTERN) do |token, indicator, code|
+            # Capture any text between the last ERB tag and the current one, and update the position
+            # to match the end of the current tag for the next iteration of text collection.
+            text = input[pos...$~.begin(0)]
+            pos  = $~.end(0)
+
+            if token
+              # First, handle certain static tokens picked up by our ERB_PATTERN regexp. These are
+              # newlines as well as the special codes for literal `<%` and `%>` values.
+              case token
+              when "\n"
+                results.last << [:static, "#{text}\n"] << [:newline]
+              when "<%%", "%%>"
+                results.last << [:static, text] unless text.empty?
+                token.slice!(1)
+                results.last << [:static, token]
+              end
+            else
+              # Next, handle actual ERB tags. Start by adding any static text between this match and
+              # the last.
+              results.last << [:static, text] unless text.empty?
+
+              case indicator
+              when "#"
+                # Comment tags: <%# this is a comment %>
+                results.last << [:code, "\n" * code.count("\n")]
+              when %r{=}
+                # Expression tags: <%= "hello (auto-escaped)" %> or <%== "hello (not escaped)" %>
+                if code =~ BLOCK_LINE_RE
+                  # See Hanami::View::Erb::Filters::Block for the processing of `:erb, :block` sexps
+                  block_node = [:erb, :block, indicator.size == 1, code, (block_content = [:multi])]
+                  results.last << block_node
+
+                  # For blocks opened in ERB expression tags, push this `[:multi]` sexp
+                  # (representing the content of the block) onto the stack of resuts. This allows
+                  # subsequent results to be appropriately added inside the block, until its closing
+                  # tag is encountered, and this `block_content` multi is subsequently popped off
+                  # the results stack.
+                  results << block_content
+                else
+                  results.last << [:escape, indicator.size == 1, [:dynamic, code]]
+                end
+              else
+                # Code tags: <% if some_cond %>
+                if code =~ BLOCK_LINE_RE || code =~ IF_UNLESS_CASE_LINE_RE
+                  results.last << [:code, code]
+
+                  # For ERB code tags that will result in a matching `end`, push the last result
+                  # back onto the stack of results. This might seem redundant, but it allows
+                  # subsequent sexps to continue to be pushed onto the same result while also
+                  # allowing it to be safely popped again when the matching `end` is encountered.
+                  results << results.last
+                elsif code =~ END_LINE_RE
+                  results.last << [:code, code]
+                  results.pop
+                else
+                  results.last << [:code, code]
+                end
+              end
+            end
+          end
+
+          # Add any text after the final ERB tag
+          results.last << [:static, input[pos..-1]]
+        end
+      end
+    end
+  end
+end

data/lib/hanami/view/erb/template.rb

@@ -0,0 +1,30 @@
+# frozen_string_literal: true
+
+require "temple"
+require_relative "engine"
+
+module Hanami
+  class View
+    # Hanami::View ERB template renderer for Tilt.
+    #
+    # The key features of this ERB implementation are:
+    #
+    # - Auto-escaping any non-`html_safe?` values given to `<%=` ERB expression tags, with
+    #   auto-escaping disabled when using `<%==` tags.
+    # - Implicitly capturing and correctly outputting block content without the need for special
+    #   helpers. This allows helpers like `<%= form_for(:post) do %>` to be used, with the
+    #   `form_for` helper itself doing nothing more special than a `yield`.
+    #
+    # See [Tilt](https://github.com/rtomayko/tilt) for rendering options.
+    #
+    # @example
+    #   Hanami::View::ERB::Template.new { "<%= 'Hello, world!' %>" }.render
+    #
+    # @api private
+    # @since 2.0.0
+    module ERB
+      # ERB Template class
+      Template = Temple::Templates::Tilt(Engine)
+    end
+  end
+end

data/lib/hanami/view/errors.rb

@@ -21,9 +21,9 @@ module Hanami
     #
     # @api private
     class TemplateNotFoundError < StandardError
-      def initialize(template_name, lookup_paths)
+      def initialize(template_name, format, lookup_paths)
         msg = [
-          "Template +#{template_name}+ could not be found in paths:",
+          "Template `#{template_name}' for format `#{format}' could not be found in paths:",
           lookup_paths.map { |path| " - #{path}" }
         ].join("\n\n")
 
@@ -46,11 +46,9 @@ module Hanami
       end
     end
 
-    # @since 2.0.0
-    # @api public
-    class MissingProviderError < Error
-      def initialize(provider)
-        super("#{provider.inspect} is missing")
+    class RenderingMissingError < Error
+      def message
+        "a +rendering+ must be provided"
       end
     end
   end

data/lib/hanami/view/exposure.rb

@@ -30,35 +30,41 @@ module Hanami
       end
 
       def dependency_names
-        if proc
-          proc.parameters.each_with_object([]) { |(type, name), names|
-            names << name if EXPOSURE_DEPENDENCY_PARAMETER_TYPES.include?(type)
-          }
-        else
-          []
-        end
+        @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 dependencies?
+        !dependency_names.empty?
       end
 
       def input_keys
-        if proc
-          proc.parameters.each_with_object([]) { |(type, name), keys|
-            keys << name if INPUT_PARAMETER_TYPES.include?(type)
-          }
-        else
-          []
-        end
+        @input_keys ||=
+          if proc
+            proc.parameters.each_with_object([]) { |(type, name), keys|
+              keys << name if INPUT_PARAMETER_TYPES.include?(type)
+            }
+          else
+            []
+          end
       end
 
       def for_layout?
-        options.fetch(:layout) { false }
+        options.fetch(:layout, false)
       end
 
       def decorate?
-        options.fetch(:decorate) { true }
+        options.fetch(:decorate, true)
       end
 
       def private?
-        options.fetch(:private) { false }
+        options.fetch(:private, false)
       end
 
       def default_value