curlybars 0.9.13

data/lib/curlybars/processor/tilde.rb

@@ -0,0 +1,31 @@
+module Curlybars
+  module Processor
+    class Tilde
+      extend TokenFactory
+
+      class << self
+        def process!(tokens, identifier)
+          tokens.each_with_index do |token, index|
+            case token.type
+            when :TILDE_START
+              tokens[index] = create_token(:START, token.value, token.position)
+              next if index == 0
+              strip_token_if_text(tokens, index - 1, :rstrip)
+            when :TILDE_END
+              tokens[index] = create_token(:END, token.value, token.position)
+              next if index == (tokens.length - 1)
+              strip_token_if_text(tokens, index + 1, :lstrip)
+            end
+          end
+        end
+
+        def strip_token_if_text(tokens, index, strip_method)
+          token = tokens[index]
+          return if token.type != :TEXT
+          stripped_value = token.value.public_send(strip_method)
+          tokens[index] = create_token(token.type, stripped_value, token.position)
+        end
+      end
+    end
+  end
+end

data/lib/curlybars/processor/token_factory.rb

@@ -0,0 +1,9 @@
+module Curlybars
+  module Processor
+    module TokenFactory
+      def create_token(type, value, position)
+        RLTK::Token.new(type, value, position)
+      end
+    end
+  end
+end

data/lib/curlybars/railtie.rb

@@ -0,0 +1,18 @@
+require 'curlybars/template_handler'
+require 'curlybars/dependency_tracker'
+
+module Curlybars
+  class Railtie < Rails::Railtie
+    initializer 'curlybars.initialize_template_handler' do
+      ActionView::Template.register_template_handler(:hbs, Curlybars::TemplateHandler)
+    end
+
+    if defined?(CacheDigests::DependencyTracker)
+      CacheDigests::DependencyTracker.register_tracker :hbs, Curlybars::DependencyTracker
+    end
+
+    if defined?(ActionView::DependencyTracker)
+      ActionView::DependencyTracker.register_tracker :hbs, Curlybars::DependencyTracker
+    end
+  end
+end

data/lib/curlybars/rendering_support.rb

@@ -0,0 +1,222 @@
+module Curlybars
+  class RenderingSupport
+    def initialize(timeout, contexts, variables, file_name, global_helpers_providers = [], cache = ->(key, &block) { block.call })
+      @timeout = timeout
+      @start_time = Time.now
+
+      @contexts = contexts
+      @variables = variables
+      @file_name = file_name
+      @cached_calls = {}
+      @cache = cache
+
+      @global_helpers = {}
+
+      global_helpers_providers.each do |provider|
+        provider.allowed_methods.each do |global_helper_name|
+          symbol = global_helper_name.to_sym
+          @global_helpers[symbol] = provider.method(symbol)
+        end
+      end
+    end
+
+    def check_timeout!
+      return unless timeout.present?
+      return unless (Time.now - start_time) > timeout
+      message = "Rendering took too long (> #{timeout} seconds)"
+      raise ::Curlybars::Error::Render.new('timeout', message, nil)
+    end
+
+    def check_context_is_presenter(context, path, position)
+      return if presenter?(context)
+      message = "`#{path}` is not a context type object"
+      raise Curlybars::Error::Render.new('context_is_not_a_presenter', message, position)
+    end
+
+    def check_context_is_hash_or_enum_of_presenters(collection, path, position)
+      return if presenter_collection?(collection)
+
+      message = "`#{path}` is not an array of presenters or a hash of such"
+      raise Curlybars::Error::Render.new('context_is_not_an_array_of_presenters', message, position)
+    end
+
+    def to_bool(condition)
+      condition != false &&
+        condition != [] &&
+        condition != {} &&
+        condition != 0 &&
+        condition != '' &&
+        !condition.nil?
+    end
+
+    def variable(variable_path, position)
+      check_traverse_not_too_deep(variable_path, position)
+
+      variable_split_by_slashes = variable_path.split('/')
+      variable = variable_split_by_slashes.last.to_sym
+      backward_steps_on_variables = variable_split_by_slashes.count - 1
+      variables_position = variables.length - backward_steps_on_variables
+      scope = variables.first(variables_position).reverse.find do |vars|
+        vars.key? variable
+      end
+      return scope[variable] if scope
+    end
+
+    def path(path, position)
+      return global_helpers[path.to_sym] if global_helpers.key?(path.to_sym)
+
+      check_traverse_not_too_deep(path, position)
+
+      path_split_by_slashes = path.split('/')
+      backward_steps_on_contexts = path_split_by_slashes.count - 1
+      base_context_position = contexts.length - backward_steps_on_contexts
+
+      return -> {} unless base_context_position > 0
+
+      base_context_index = base_context_position - 1
+      base_context = contexts[base_context_index]
+
+      dotted_path_side = path_split_by_slashes.last
+      chain = dotted_path_side.split('.')
+      method_to_return = chain.pop
+
+      resolved = chain.inject(base_context) do |context, meth|
+        next context if meth == 'this'
+        next context.count if meth == 'length' && presenter_collection?(context)
+        raise_if_not_traversable(context, meth, position)
+        outcome = instrument(context.method(meth)) { context.public_send(meth) }
+        return -> {} if outcome.nil?
+        outcome
+      end
+
+      return -> { resolved } if method_to_return == 'this'
+
+      if method_to_return == 'length' && presenter_collection?(resolved)
+        return -> { resolved.count }
+      end
+
+      raise_if_not_traversable(resolved, method_to_return, position)
+      resolved.method(method_to_return.to_sym)
+    end
+
+    def cached_call(meth)
+      return cached_calls[meth] if cached_calls.key? meth
+      instrument(meth) { cached_calls[meth] = meth.call }
+    end
+
+    def call(helper, helper_path, helper_position, arguments, options, &block)
+      parameters = helper.parameters
+      parameter_types = parameters.map(&:first)
+
+      # parameters has value [[:rest]] when the presenter is using method_missing to catch all calls
+      has_invalid_parameters = parameter_types.map { |type| type != :req }.any? && parameter_types != [:rest]
+      if has_invalid_parameters
+        source_location = helper.source_location
+
+        file_path = source_location ? source_location.first : "n/a"
+        line_number = source_location ? helper.source_location.last : "n/a"
+
+        message = "#{file_path}:#{line_number} - `#{helper_path}` bad signature "
+        message << "for #{helper} - helpers must have only required parameters"
+        raise Curlybars::Error::Render.new('invalid_helper_signature', message, helper_position)
+      end
+
+      instrument(helper) do
+        helper.call(*arguments_for_signature(helper, arguments, options), &block)
+      end
+    end
+
+    def position(line_number, line_offset)
+      Curlybars::Position.new(file_name, line_number, line_offset)
+    end
+
+    def coerce_to_hash!(collection, path, position)
+      check_context_is_hash_or_enum_of_presenters(collection, path, position)
+      if collection.is_a?(Hash)
+        collection
+      elsif collection.respond_to? :each_with_index
+        collection.each_with_index.map { |value, index| [index, value] }.to_h
+      else
+        raise "Collection is not coerceable to hash"
+      end
+    end
+
+    def presenter?(context)
+      context.respond_to? :allows_method?
+    end
+
+    def presenter_collection?(collection)
+      collection = collection.values if collection.is_a?(Hash)
+
+      collection.respond_to?(:each) && collection.all? do |presenter|
+        presenter?(presenter)
+      end
+    end
+
+    def optional_presenter_cache(presenter, template_cache_key, buffer)
+      presenter_cache_key = presenter.respond_to?(:cache_key) ? presenter.cache_key : nil
+
+      if presenter_cache_key
+        cache_key = "#{presenter_cache_key}/#{template_cache_key}"
+
+        buffer << cache.call(cache_key) do
+          # Output from the block must be isolated from the main output buffer
+          SafeBuffer.new.tap do |cache_buffer|
+            yield cache_buffer
+          end
+        end
+      else
+        yield buffer
+      end
+    end
+
+    private
+
+    attr_reader :contexts, :variables, :cached_calls, :file_name, :global_helpers, :start_time, :timeout, :cache
+
+    def instrument(meth, &block)
+      # Instruments only callables that give enough details (eg. methods)
+      return yield unless meth.respond_to?(:name) && meth.respond_to?(:owner)
+
+      payload = { presenter: meth.owner, method: meth.name }
+      ActiveSupport::Notifications.instrument("call_to_presenter.curlybars", payload, &block)
+    end
+
+    def arguments_for_signature(helper, arguments, options)
+      return [] if helper.parameters.empty?
+      return arguments if helper.parameters.map(&:first) == [:rest]
+
+      number_of_parameters_available_for_arguments = helper.parameters.length - 1
+      arguments_that_can_fit = arguments.first(number_of_parameters_available_for_arguments)
+      nil_padding_length = number_of_parameters_available_for_arguments - arguments_that_can_fit.length
+      nil_padding = Array.new(nil_padding_length)
+
+      [arguments_that_can_fit, nil_padding, options].flatten(1)
+    end
+
+    def raise_if_not_traversable(context, meth, position)
+      check_context_is_presenter(context, meth, position)
+      check_context_allows_method(context, meth, position)
+      check_context_has_method(context, meth, position)
+    end
+
+    def check_context_allows_method(context, meth, position)
+      return if context.allows_method?(meth.to_sym)
+      message = "`#{meth}` is not available - "
+      message += "add `allow_methods :#{meth}` to #{context.class} to allow this path"
+      raise Curlybars::Error::Render.new('unallowed_path', message, position, meth: meth.to_sym)
+    end
+
+    def check_context_has_method(context, meth, position)
+      return if context.respond_to?(meth.to_sym)
+      message = "`#{meth}` is not available in #{context.class}"
+      raise Curlybars::Error::Render.new('unallowed_path', message, position)
+    end
+
+    def check_traverse_not_too_deep(traverse, position)
+      return unless traverse.count('.') > Curlybars.configuration.traversing_limit
+      message = "`#{traverse}` too deep"
+      raise Curlybars::Error::Render.new('traverse_too_deep', message, position)
+    end
+  end
+end

data/lib/curlybars/safe_buffer.rb

@@ -0,0 +1,11 @@
+module Curlybars
+  class SafeBuffer < ActiveSupport::SafeBuffer
+    def concat(buffer)
+      if (length + buffer.length) > Curlybars.configuration.output_limit
+        message = "Output too long (> %s bytes)" % Curlybars.configuration.output_limit
+        raise Curlybars::Error::Render.new('output_too_long', message, nil)
+      end
+      super
+    end
+  end
+end

data/lib/curlybars/template_handler.rb

@@ -0,0 +1,93 @@
+require 'active_support'
+require 'action_view'
+require 'curlybars'
+require 'curlybars/error/presenter/not_found'
+
+module Curlybars
+  class TemplateHandler
+    class << self
+      # Handles a Curlybars template, compiling it to Ruby code. The code will be
+      # evaluated in the context of an ActionView::Base instance, having access
+      # to a number of variables.
+      #
+      # template - The ActionView::Template template that should be compiled.
+      #
+      # Returns a String containing the Ruby code representing the template.
+      def call(template)
+        instrument(template) do
+          compile(template)
+        end
+      end
+
+      def cache_if_key_is_not_nil(context, presenter)
+        key = presenter.cache_key
+        if key.present?
+          presenter_key = if presenter.class.respond_to?(:cache_key)
+            presenter.class.cache_key
+          end
+
+          cache_options = presenter.cache_options || {}
+          cache_options[:expires_in] ||= presenter.cache_duration
+
+          # Curlybars doesn't allow Rails to handle the template digest.
+          # So, we disable it.
+          cache_options[:skip_digest] = true
+
+          context.cache([key, presenter_key].compact, cache_options) do
+            yield
+          end
+        else
+          yield
+        end
+      end
+
+      private
+
+      def compile(template)
+        # Template is empty, so there's no need to initialize a presenter.
+        return %("") if template.source.empty?
+
+        path = template.virtual_path
+        presenter_class = Curlybars::Presenter.presenter_for_path(path)
+
+        raise Curlybars::Error::Presenter::NotFound.new(path) if presenter_class.nil?
+
+        # For security reason, we strip the encoding directive in order to avoid
+        # potential issues when rendering the template in another character
+        # encoding.
+        safe_source = template.source.gsub(/\A#{ActionView::ENCODING_FLAG}/, '')
+
+        source = Curlybars.compile(safe_source, template.identifier)
+
+        <<-RUBY
+          if local_assigns.empty?
+            options = assigns
+          else
+            options = local_assigns
+          end
+
+          provider_classes = ::Curlybars.configuration.global_helpers_provider_classes
+          global_helpers_providers = provider_classes.map { |klass| klass.new(self) }
+
+          presenter = ::#{presenter_class}.new(self, options)
+          presenter.setup!
+
+          @output_buffer = output_buffer || ::ActiveSupport::SafeBuffer.new
+
+          ::Curlybars::TemplateHandler.cache_if_key_is_not_nil(self, presenter) do
+            safe_concat begin
+              #{source}
+            end
+          end
+
+          @output_buffer
+        RUBY
+      end
+
+      def instrument(template, &block)
+        payload = { path: template.virtual_path }
+        ActiveSupport::Notifications.instrument("compile.curlybars", payload, &block)
+      end
+    end
+  end
+end

data/lib/curlybars/version.rb

@@ -0,0 +1,3 @@
+module Curlybars
+  VERSION = '0.9.13'.freeze
+end

data/spec/acceptance/application_layout_spec.rb

@@ -0,0 +1,60 @@
+describe "Using Curlybars for the application layout", type: :request do
+  example "A simple layout view in Curlybars" do
+    get '/'
+
+    expect(body).to eq(<<-HTML.strip_heredoc)
+      <html>
+      <head>
+        <title>Dummy app</title>
+      </head>
+      <body>
+      <h1>Dashboard</h1>
+      <p>Hello, World!</p>
+      <p>Welcome!</p>
+
+      </body>
+      </html>
+    HTML
+  end
+
+  describe "Curlybars" do
+    before do
+      Curlybars.configure do |config|
+        config.presenters_namespace = 'curlybars_presenters'
+      end
+    end
+
+    after do
+      Curlybars.reset
+    end
+
+    example "A simple layout view in Curlybars with html safe logic" do
+      get '/articles/1'
+
+      expect(body).to eq(<<-HTML.strip_heredoc)
+        <html>
+        <head>
+          <title>Dummy app</title>
+        </head>
+        <body>
+        <p>Hi Admin</p>
+
+        <h1>Article: The Prince</h1>
+
+        <p>This is <strong>important</strong>!</p>
+
+        <p>&lt;script&gt;alert(&#39;bad&#39;)&lt;/script&gt;</p>
+
+
+        <p>
+          author Nicolò
+          <img src="http://example.com/foo.png" />
+        </p>
+
+
+        </body>
+        </html>
+      HTML
+    end
+  end
+end