curlybars 0.9.13

data/lib/curlybars/node/root.rb

@@ -0,0 +1,29 @@
+module Curlybars
+  module Node
+    Root = Struct.new(:template, :position) do
+      def compile
+        # NOTE: the following is a heredoc string, representing the ruby code fragment
+        # outputted by this node.
+        <<-RUBY
+          contexts = [presenter]
+          variables = [{}]
+          rendering = ::Curlybars::RenderingSupport.new(
+            ::Curlybars.configuration.rendering_timeout,
+            contexts,
+            variables,
+            #{position.file_name.inspect},
+            global_helpers_providers,
+            ::Curlybars.configuration.cache
+          )
+          buffer = ::Curlybars::SafeBuffer.new
+          #{template.compile}
+          buffer
+        RUBY
+      end
+
+      def validate(branches)
+        template.validate(branches)
+      end
+    end
+  end
+end

data/lib/curlybars/node/string.rb

@@ -0,0 +1,24 @@
+module Curlybars
+  module Node
+    String = Struct.new(:string) do
+      def compile
+        # NOTE: the following is a heredoc string, representing the ruby code fragment
+        # outputted by this node.
+        <<-RUBY
+          ->() { #{string.inspect} }
+        RUBY
+      end
+
+      def validate(branches)
+        # Nothing to validate here.
+      end
+
+      def cache_key
+        [
+          string,
+          self.class.name
+        ].join("/")
+      end
+    end
+  end
+end

data/lib/curlybars/node/template.rb

@@ -0,0 +1,32 @@
+module Curlybars
+  module Node
+    Template = Struct.new(:items, :position) do
+      def compile
+        compiled_items = items.map(&:compile).join("\n")
+
+        # NOTE: the following is a heredoc string, representing the ruby code fragment
+        # outputted by this node.
+        <<-RUBY
+          ::Module.new do
+            def self.exec(contexts, rendering, variables, buffer)
+              unless contexts.length < ::Curlybars.configuration.nesting_limit
+                message = "Nesting too deep"
+                position = rendering.position(#{position.line_number}, #{position.line_offset})
+                raise ::Curlybars::Error::Render.new('nesting_too_deep', message, position)
+              end
+              #{compiled_items}
+            end
+          end.exec(contexts, rendering, variables, buffer)
+        RUBY
+      end
+
+      def validate(branches)
+        items.map { |item| item.validate(branches) }
+      end
+
+      def cache_key
+        Digest::MD5.hexdigest(items.map(&:cache_key).join("/"))
+      end
+    end
+  end
+end

data/lib/curlybars/node/text.rb

@@ -0,0 +1,24 @@
+module Curlybars
+  module Node
+    Text = Struct.new(:text) do
+      def compile
+        # NOTE: the following is a heredoc string, representing the ruby code fragment
+        # outputted by this node.
+        <<-RUBY
+          buffer.concat(#{text.inspect}.html_safe)
+        RUBY
+      end
+
+      def validate(branches)
+        # Nothing to validate here.
+      end
+
+      def cache_key
+        [
+          text.to_s,
+          self.class.name
+        ].join("/")
+      end
+    end
+  end
+end

data/lib/curlybars/node/unless_else.rb

@@ -0,0 +1,33 @@
+module Curlybars
+  module Node
+    UnlessElse = Struct.new(:expression, :unless_template, :else_template) do
+      def compile
+        # NOTE: the following is a heredoc string, representing the ruby code fragment
+        # outputted by this node.
+        <<-RUBY
+          unless rendering.to_bool(rendering.cached_call(#{expression.compile}))
+            #{unless_template.compile}
+          else
+            #{else_template.compile}
+          end
+        RUBY
+      end
+
+      def validate(branches)
+        [
+          expression.validate(branches),
+          unless_template.validate(branches),
+          else_template.validate(branches)
+        ]
+      end
+
+      def cache_key
+        [
+          expression,
+          unless_template,
+          else_template
+        ].map(&:cache_key).push(self.class.name).join("/")
+      end
+    end
+  end
+end

data/lib/curlybars/node/variable.rb

@@ -0,0 +1,34 @@
+module Curlybars
+  module Node
+    Variable = Struct.new(:variable, :position) do
+      def compile
+        # NOTE: the following is a heredoc string, representing the ruby code fragment
+        # outputted by this node.
+        <<-RUBY
+          -> {
+            position = rendering.position(
+              #{position.line_number},
+              #{position.line_offset}
+            )
+            rendering.variable(#{variable.inspect}, position)
+          }
+        RUBY
+      end
+
+      def validate(branches)
+        # Nothing to validate here.
+      end
+
+      def validate_as_value(branches)
+        # It is always a value.
+      end
+
+      def cache_key
+        [
+          variable,
+          self.class.name
+        ].join("/")
+      end
+    end
+  end
+end

data/lib/curlybars/node/with_else.rb

@@ -0,0 +1,54 @@
+module Curlybars
+  module Node
+    WithElse = Struct.new(:path, :with_template, :else_template, :position) do
+      def compile
+        # NOTE: the following is a heredoc string, representing the ruby code fragment
+        # outputted by this node.
+        <<-RUBY
+          compiled_path = rendering.cached_call(#{path.compile})
+
+          if rendering.to_bool(compiled_path)
+            position = rendering.position(#{position.line_number}, #{position.line_offset})
+            rendering.check_context_is_presenter(compiled_path, #{path.path.inspect}, position)
+
+            contexts.push(compiled_path)
+            begin
+              #{with_template.compile}
+            ensure
+              contexts.pop
+            end
+          else
+            #{else_template.compile}
+          end
+        RUBY
+      end
+
+      def validate(branches)
+        sub_tree = path.resolve_and_check!(branches, check_type: :presenter)
+        with_template_errors = begin
+          branches.push(sub_tree)
+          with_template.validate(branches)
+        ensure
+          branches.pop
+        end
+
+        else_template_errors = else_template.validate(branches)
+
+        [
+          with_template_errors,
+          else_template_errors
+        ]
+      rescue Curlybars::Error::Validate => path_error
+        path_error
+      end
+
+      def cache_key
+        [
+          path,
+          with_template,
+          else_template
+        ].map(&:cache_key).push(self.class.name).join("/")
+      end
+    end
+  end
+end

data/lib/curlybars/parser.rb

@@ -0,0 +1,183 @@
+require 'rltk/parser'
+
+require 'curlybars/node/root'
+require 'curlybars/node/template'
+require 'curlybars/node/item'
+require 'curlybars/node/text'
+require 'curlybars/node/if_else'
+require 'curlybars/node/unless_else'
+require 'curlybars/node/each_else'
+require 'curlybars/node/path'
+require 'curlybars/node/literal'
+require 'curlybars/node/variable'
+require 'curlybars/node/with_else'
+require 'curlybars/node/block_helper_else'
+require 'curlybars/node/option'
+require 'curlybars/node/partial'
+require 'curlybars/node/output'
+
+module Curlybars
+  class Parser < RLTK::Parser
+    start :root
+
+    production(:root, 'template?') { |template| Node::Root.new(template || VOID, pos(0)) }
+    production(:template, 'items') { |items| Node::Template.new(items || [], pos(0)) }
+
+    production(:items) do
+      clause('items item') { |items, item| items << Node::Item.new(item) }
+      clause('item') { |item| [Node::Item.new(item)] }
+    end
+
+    production(:item) do
+      clause('TEXT') { |text| Node::Text.new(text) }
+
+      clause('START HASH .path .expressions? .options? END
+               .template?
+             START SLASH .path END') do |helper, arguments, options, template, helperclose|
+        Node::BlockHelperElse.new(
+          helper,
+          arguments || [],
+          options || [],
+          template || VOID,
+          VOID,
+          helperclose,
+          pos(0)
+        )
+      end
+
+      clause('START HASH .path .expressions? .options? END
+               .template?
+             START ELSE END
+               .template?
+             START SLASH .path END') do |helper, arguments, options, helper_template, else_template, helperclose|
+        Node::BlockHelperElse.new(
+          helper,
+          arguments || [],
+          options || [],
+          helper_template || VOID,
+          else_template || VOID,
+          helperclose,
+          pos(0)
+        )
+      end
+
+      clause('START .path .expressions? .options? END') do |helper, arguments, options|
+        Node::BlockHelperElse.new(
+          helper,
+          arguments || [],
+          options || [],
+          VOID,
+          VOID,
+          helper,
+          pos(0)
+        )
+      end
+
+      clause('START .value END') do |value|
+        Node::Output.new(value)
+      end
+
+      clause('START HASH IF .expression END
+               .template?
+             START SLASH IF END') do |expression, if_template|
+        Node::IfElse.new(expression, if_template || VOID, VOID)
+      end
+
+      clause('START HASH IF .expression END
+               .template?
+             START ELSE END
+               .template?
+             START SLASH IF END') do |expression, if_template, else_template|
+        Node::IfElse.new(expression, if_template || VOID, else_template || VOID)
+      end
+
+      clause('START HASH UNLESS .expression END
+               .template?
+             START SLASH UNLESS END') do |expression, unless_template|
+        Node::UnlessElse.new(expression, unless_template || VOID, VOID)
+      end
+
+      clause('START HASH UNLESS .expression END
+               .template?
+             START ELSE END
+               .template?
+             START SLASH UNLESS END') do |expression, unless_template, else_template|
+        Node::UnlessElse.new(expression, unless_template || VOID, else_template || VOID)
+      end
+
+      clause('START HASH EACH .path END
+               .template?
+             START SLASH EACH END') do |path, each_template|
+        Node::EachElse.new(path, each_template || VOID, VOID, pos(0))
+      end
+
+      clause('START HASH EACH .path END
+               .template?
+             START ELSE END
+               .template?
+             START SLASH EACH END') do |path, each_template, else_template|
+        Node::EachElse.new(path, each_template || VOID, else_template || VOID, pos(0))
+      end
+
+      clause('START HASH WITH .path END
+               .template?
+             START SLASH WITH END') do |path, with_template|
+        Node::WithElse.new(path, with_template || VOID, VOID, pos(0))
+      end
+
+      clause('START HASH WITH .path END
+               .template?
+             START ELSE END
+               .template?
+             START SLASH WITH END') do |path, with_template, else_template|
+        Node::WithElse.new(path, with_template || VOID, else_template || VOID, pos(0))
+      end
+
+      clause('START GT .path END') do |path|
+        Node::Partial.new(path)
+      end
+    end
+
+    production(:options) do
+      clause('options option') { |options, option| options << option }
+      clause('option') { |option| [option] }
+    end
+
+    production(:option, '.KEY .expression') do |key, expression|
+      Node::Option.new(key, expression)
+    end
+
+    production(:expressions) do
+      clause('expressions expression') { |expressions, expression| expressions << expression }
+      clause('expression') { |expression| [expression] }
+    end
+
+    production(:expression) do
+      clause('value') { |value| value }
+      clause('path') { |path| path }
+    end
+
+    production(:value) do
+      clause('LITERAL') { |literal| Node::Literal.new(literal) }
+      clause('VARIABLE') { |variable| Node::Variable.new(variable, pos(0)) }
+    end
+
+    production(:path, 'PATH') { |path| Node::Path.new(path, pos(0)) }
+
+    finalize
+
+    VOID = Class.new do
+      def compile
+        # Nothing to compile.
+      end
+
+      def validate(branches)
+        [] # Nothing to validate.
+      end
+
+      def cache_key
+        # Empty cache key.
+      end
+    end.new
+  end
+end

data/lib/curlybars/position.rb

@@ -0,0 +1,7 @@
+module Curlybars
+  Position = Struct.new(:file_name, :line_number, :line_offset, :length) do
+    def initialize(file_name, line_number, line_offset, length = 0)
+      super
+    end
+  end
+end

data/lib/curlybars/presenter.rb

@@ -0,0 +1,288 @@
+require 'curlybars/method_whitelist'
+require 'curlybars/configuration'
+
+module Curlybars
+  # A base class that can be subclassed by concrete presenters.
+  #
+  # A Curlybars presenter is responsible for delivering data to templates, in the
+  # form of simple strings. Each public instance method on the presenter class
+  # can be referenced in a template. When a template is evaluated with a
+  # presenter, the referenced methods will be called with no arguments, and
+  # the returned strings inserted in place of the components in the template.
+  #
+  # Note that strings that are not HTML safe will be escaped.
+  #
+  # A presenter is always instantiated with a context to which it delegates
+  # unknown messages, usually an instance of ActionView::Base provided by
+  # Rails. See Curlybars::TemplateHandler for a typical use.
+  #
+  # Examples
+  #
+  #   class BlogPresenter < Curlybars::Presenter
+  #     presents :post
+  #     allow_methods :title, :body, :author
+  #
+  #     def title
+  #       @post.title
+  #     end
+  #
+  #     def body
+  #       markdown(@post.body)
+  #     end
+  #
+  #     def author
+  #       @post.author.full_name
+  #     end
+  #   end
+  #
+  #   presenter = BlogPresenter.new(context, post: post)
+  #   presenter.author #=> "Jackie Chan"
+  #
+  class Presenter
+    extend Curlybars::MethodWhitelist
+
+    # Initializes the presenter with the given context and options.
+    #
+    # context - An ActionView::Base context.
+    # options - A Hash of options given to the presenter.
+    def initialize(context, options = {})
+      @_context = context
+      options.stringify_keys!
+
+      self.class.presented_names.each do |name|
+        value = options.fetch(name) do
+          default_values.fetch(name) do
+            block = default_blocks.fetch(name) do
+              raise ArgumentError.new("required identifier `#{name}` missing")
+            end
+
+            instance_exec(name, &block)
+          end
+        end
+
+        instance_variable_set("@#{name}", value)
+      end
+    end
+
+    # Sets up the view.
+    #
+    # Override this method in your presenter in order to do setup before the
+    # template is rendered. One use case is to call `content_for` in order
+    # to inject content into other templates, e.g. a layout.
+    #
+    # Examples
+    #
+    #   class Posts::ShowPresenter < Curlybars::Presenter
+    #     presents :post
+    #
+    #     def setup!
+    #       content_for :page_title, @post.title
+    #     end
+    #   end
+    #
+    # Returns nothing.
+    def setup!
+      # Does nothing.
+    end
+
+    # The key that should be used to cache the view.
+    #
+    # Unless `#cache_key` returns nil, the result of rendering the template
+    # that the presenter supports will be cached. The return value will be
+    # part of the final cache key, along with a digest of the template itself.
+    #
+    # Any object can be used as a cache key, so long as it
+    #
+    # - is a String,
+    # - responds to #cache_key itself, or
+    # - is an Array or a Hash whose items themselves fit either of these
+    #   criteria.
+    #
+    # Returns the cache key Object or nil if no caching should be performed.
+    def cache_key
+      nil
+    end
+
+    # The options that should be passed to the cache backend when caching the
+    # view. The exact options may vary depending on the backend you're using.
+    #
+    # The most common option is `:expires_in`, which controls the duration of
+    # time that the cached view should be considered fresh. Because it's so
+    # common, you can set that option simply by defining `#cache_duration`.
+    #
+    # Note: if you set the `:expires_in` option through this method, the
+    # `#cache_duration` value will be ignored.
+    #
+    # Returns a Hash.
+    def cache_options
+      {}
+    end
+
+    # The duration that the view should be cached for. Only relevant if
+    # `#cache_key` returns a non nil value.
+    #
+    # If nil, the view will not have an expiration time set. See also
+    # `#cache_options` for a more flexible way to set cache options.
+    #
+    # Examples
+    #
+    #   def cache_duration
+    #     10.minutes
+    #   end
+    #
+    # Returns the Fixnum duration of the cache item, in seconds, or nil if no
+    #   duration should be set.
+    def cache_duration
+      nil
+    end
+
+    class << self
+      # The name of the presenter class for a given view path.
+      #
+      # path - The String path of a view.
+      #
+      # Examples
+      #
+      #   Curlybars::TemplateHandler.presenter_name_for_path("foo/bar")
+      #   #=> "Foo::BarPresenter"
+      #
+      # Returns the String name of the matching presenter class.
+      def presenter_name_for_path(path)
+        "#{path}_presenter".camelize
+      end
+
+      # Returns the presenter class for the given path.
+      #
+      # path - The String path of a template.
+      #
+      # Returns the Class or nil if the constant cannot be found.
+      def presenter_for_path(path)
+        name_space = Curlybars.configuration.presenters_namespace
+        name_spaced_path = File.join(name_space, path)
+        full_class_name = presenter_name_for_path(name_spaced_path)
+        begin
+          full_class_name.constantize
+        rescue NameError
+          nil
+        end
+      end
+
+      # The set of view paths that the presenter depends on.
+      #
+      # Examples
+      #
+      #   class Posts::ShowPresenter < Curlybars::Presenter
+      #     version 2
+      #     depends_on 'posts/comment', 'posts/comment_form'
+      #   end
+      #
+      #   Posts::ShowPresenter.dependencies
+      #   #=> ['posts/comment', 'posts/comment_form']
+      #
+      # Returns a Set of String view paths.
+      def dependencies
+        # The base presenter doesn't have any dependencies.
+        return SortedSet.new if self == Curlybars::Presenter
+
+        @dependencies ||= SortedSet.new
+        @dependencies.union(superclass.dependencies)
+      end
+
+      # Indicate that the presenter depends a list of other views.
+      #
+      # deps - A list of String view paths that the presenter depends on.
+      #
+      # Returns nothing.
+      def depends_on(*dependencies)
+        @dependencies ||= SortedSet.new
+        @dependencies.merge(dependencies)
+      end
+
+      # Get or set the version of the presenter.
+      #
+      # version - The Integer version that should be set. If nil, no version
+      #           is set.
+      #
+      # Returns the current Integer version of the presenter.
+      def version(version = nil)
+        @version = version if version.present?
+        @version || 0
+      end
+
+      # The cache key for the presenter class. Includes all dependencies as
+      # well.
+      #
+      # Returns a String cache key.
+      def cache_key
+        @cache_key ||= compute_cache_key
+      end
+
+      private
+
+      def compute_cache_key
+        dependency_cache_keys = dependencies.map do |path|
+          presenter = presenter_for_path(path)
+          if presenter.present?
+            presenter.cache_key
+          else
+            path
+          end
+        end
+
+        [name, version, dependency_cache_keys].flatten.join("/")
+      end
+
+      def presents(*args, **options, &block)
+        if options.key?(:default) && block_given?
+          raise ArgumentError, "Cannot provide both `default:` and block"
+        end
+
+        self.presented_names += args.map(&:to_s)
+
+        if options.key?(:default)
+          args.each do |arg|
+            self.default_values = default_values.merge(arg.to_s => options[:default]).freeze
+          end
+        end
+
+        return unless block_given?
+
+        args.each do |arg|
+          self.default_blocks = default_blocks.merge(arg.to_s => block).freeze
+        end
+      end
+
+      def exposes_helper(*methods)
+        methods.each do |method_name|
+          define_method(method_name) do |*args|
+            @_context.public_send(method_name, *args)
+          end
+        end
+      end
+
+      alias_method :exposes_helpers, :exposes_helper
+    end
+
+    private
+
+    class_attribute :presented_names, :default_values, :default_blocks
+
+    self.presented_names = [].freeze
+    self.default_values = {}.freeze
+    self.default_blocks = {}.freeze
+
+    delegate :render, to: :@_context
+
+    # Delegates private method calls to the current view context.
+    #
+    # The view context, an instance of ActionView::Base, is set by Rails.
+    def method_missing(method, *args, &block)
+      @_context.public_send(method, *args, &block)
+    end
+
+    # Tells ruby (and developers) what methods we can accept.
+    def respond_to_missing?(method, include_private = false)
+      @_context.respond_to?(method, false)
+    end
+  end
+end