curlybars 0.9.13

checksums.yaml

@@ -0,0 +1,7 @@
+---
+SHA256:
+  metadata.gz: 301f06415961a13ec43df1d5e9a665a8acf4b82a1bf7c4b3b13c2c9a8e4927c1
+  data.tar.gz: 239584a824c472cfb8990eb5f5222c97af8099dcde44ae260570d9ca7cf67dd6
+SHA512:
+  metadata.gz: b6aacd59a3eaacb5a98b7e7ba084d4b49ba65fe77caae1d227c7fb8469d5e238667fd1c3811d3c778adeca3a6911e04f88fac961d5a2c275ca8a492ea952dd42
+  data.tar.gz: c7fae34b0cf744d87f72062ea07ffa7d2508e3f2d9f4c260b89c66054f0b2e016bb2d4ee28c3017fc5b1156b3c0581f18f215de1facbcd3650bcdecda4c58b08

data/lib/curlybars.rb

@@ -0,0 +1,108 @@
+require 'curlybars/version'
+
+# Curlybars is a view system based on Curly that uses Handlebars syntax.
+#
+# Each view consists of two parts, a template and a presenter.
+# The template is a valid Handlebars template.
+#
+#   {{#with invoice}}
+#     Hello {{recipient.first_name}},
+#     you owe us {{local_currency amount}}.
+#   {{/with}}
+#
+# In the example above `recipient.first_name` is a path
+# `local_currency amount` is an helper
+#
+# See Curlybars::Presenter for more information on presenters.
+module Curlybars
+  class << self
+    # Compiles a Curlybars template to Ruby code.
+    #
+    # source - The source HBS String that should be compiled.
+    # identifier - The the file name of the template being compiled (defaults to `nil`).
+    #
+    # Returns a String containing the Ruby code.
+    def compile(source, identifier = nil)
+      transformers = Curlybars.configuration.compiler_transformers
+      transformed_source = transformers.inject(source) do |memo, transformer|
+        transformer.transform(memo, identifier)
+      end
+
+      ast(transformed_source, identifier, run_processors: true).compile
+    end
+
+    # Validates the source against a presenter.
+    #
+    # dependency_tree - a presenter dependency tree as defined in Curlybars::MethodWhitelist
+    # source - The source HBS String that should be validated.
+    # identifier - The the file name of the template being validated (defaults to `nil`).
+    #
+    # Returns an array of Curlybars::Error::Validation
+    def validate(dependency_tree, source, identifier = nil, **options)
+      options.reverse_merge!(
+        run_processors: true
+      )
+
+      errors = begin
+        branches = [dependency_tree]
+        ast(source, identifier, run_processors: options[:run_processors]).validate(branches)
+      rescue Curlybars::Error::Base => ast_error
+        [ast_error]
+      end
+      errors.flatten!
+      errors.compact!
+      errors
+    end
+
+    # Check if the source is valid for a given presenter.
+    #
+    # presenter_class - the presenter class, used to check if the source is valid.
+    # source - The source HBS String that should be check to be valid.
+    # identifier - The the file name of the template being checked (defaults to `nil`).
+    #
+    # Returns true if the template is valid, false otherwise.
+    def valid?(presenter_class, source, identifier = nil, **options)
+      errors = validate(presenter_class, source, identifier, **options)
+      errors.empty?
+    end
+
+    private
+
+    def ast(source, identifier, run_processors:)
+      tokens = Curlybars::Lexer.lex(source, identifier)
+
+      Curlybars::Processor::Tilde.process!(tokens, identifier)
+
+      if run_processors
+        Curlybars.configuration.custom_processors.each do |processor|
+          processor.process!(tokens, identifier)
+        end
+      end
+
+      Curlybars::Parser.parse(tokens)
+    rescue RLTK::LexingError => lexing_error
+      raise Curlybars::Error::Lex.new(source, identifier, lexing_error)
+    rescue RLTK::NotInLanguage => not_in_language_error
+      raise Curlybars::Error::Parse.new(source, not_in_language_error)
+    end
+  end
+end
+
+require 'curlybars/safe_buffer'
+require 'curlybars/configuration'
+require 'curlybars/rendering_support'
+require 'curlybars/parser'
+require 'curlybars/position'
+require 'curlybars/lexer'
+require 'curlybars/parser'
+require 'curlybars/processor/token_factory'
+require 'curlybars/processor/tilde'
+require 'curlybars/error/lex'
+require 'curlybars/error/parse'
+require 'curlybars/error/compile'
+require 'curlybars/error/validate'
+require 'curlybars/error/render'
+require 'curlybars/template_handler'
+require 'curlybars/railtie' if defined?(Rails)
+require 'curlybars/presenter'
+require 'curlybars/method_whitelist'

data/lib/curlybars/configuration.rb

@@ -0,0 +1,41 @@
+module Curlybars
+  class << self
+    attr_writer :configuration
+  end
+
+  def self.configuration
+    @configuration ||= Configuration.new
+  end
+
+  def self.configure
+    yield(configuration)
+  end
+
+  def self.reset
+    @configuration = Configuration.new
+  end
+
+  class Configuration
+    attr_accessor :presenters_namespace
+    attr_accessor :nesting_limit
+    attr_accessor :traversing_limit
+    attr_accessor :output_limit
+    attr_accessor :rendering_timeout
+    attr_accessor :custom_processors
+    attr_accessor :compiler_transformers
+    attr_accessor :global_helpers_provider_classes
+    attr_accessor :cache
+
+    def initialize
+      @presenters_namespace = ''
+      @nesting_limit = 10
+      @traversing_limit = 10
+      @output_limit = 1.megabyte
+      @rendering_timeout = 10.seconds
+      @custom_processors = []
+      @compiler_transformers = []
+      @global_helpers_provider_classes = []
+      @cache = ->(key, &block) { block.call }
+    end
+  end
+end

data/lib/curlybars/dependency_tracker.rb

@@ -0,0 +1,8 @@
+module Curlybars
+  class DependencyTracker
+    def self.call(path, template)
+      presenter = Curlybars::Presenter.presenter_for_path(path)
+      presenter.dependencies.to_a
+    end
+  end
+end

data/lib/curlybars/error/base.rb

@@ -0,0 +1,18 @@
+module Curlybars
+  module Error
+    class Base < StandardError
+      attr_reader :id, :position, :metadata
+
+      def initialize(id, message, position, metadata = {})
+        super(message)
+        @id = id
+        @position = position
+        @metadata = metadata
+        return if position.nil?
+        return if position.file_name.nil?
+        location = "%s:%d:%d" % [position.file_name, position.line_number, position.line_offset]
+        set_backtrace([location])
+      end
+    end
+  end
+end

data/lib/curlybars/error/compile.rb

@@ -0,0 +1,11 @@
+require 'curlybars/error/base'
+
+module Curlybars
+  module Error
+    class Compile < Curlybars::Error::Base
+      def initialize(id, message, position)
+        super('compile.%s' % id, message, position)
+      end
+    end
+  end
+end

data/lib/curlybars/error/lex.rb

@@ -0,0 +1,22 @@
+require 'curlybars/error/base'
+
+module Curlybars
+  module Error
+    class Lex < Curlybars::Error::Base
+      def initialize(source, file_name, exception)
+        line_number = exception.line_number
+        line_offset = exception.line_offset
+
+        error_line = source.split("\n")[line_number - 1]
+        before_error = error_line.first(line_offset).last(10)
+        after_error = error_line[line_offset + 1..-1].first(10)
+        error = error_line[line_offset]
+
+        details = [before_error, error, after_error]
+        message = ".. %s `%s` %s .. is not permitted symbol in this context" % details
+        position = Curlybars::Position.new(file_name, line_number, line_offset)
+        super('lex', message, position)
+      end
+    end
+  end
+end

data/lib/curlybars/error/parse.rb

@@ -0,0 +1,41 @@
+require 'curlybars/error/base'
+
+module Curlybars
+  module Error
+    class Parse < Curlybars::Error::Base
+      def initialize(source, exception)
+        position = exception.current.position
+
+        if exception.current.type == :EOS
+          message = "A block helper hasn't been closed properly"
+          position = EOSPosition.new(source)
+        else
+          line_number = position.line_number
+          line_offset = position.line_offset
+          length = exception.current.position.length
+
+          error_line = source.split("\n")[line_number - 1]
+          before_error = error_line.first(line_offset).last(10)
+          after_error = error_line[line_offset + length..-1].first(10)
+          error = error_line.slice(line_offset, length)
+
+          details = [before_error, error, after_error]
+          message = ".. %s `%s` %s .. is not permitted in this context" % details
+        end
+
+        super('parse', message, position)
+      end
+    end
+
+    class EOSPosition
+      attr_reader :line_number, :line_offset, :length, :file_name
+
+      def initialize(source)
+        @line_number = source.count("\n") + 1
+        @line_offset = 0
+        @length = source.rpartition("\n").last.length
+        @file_name = nil
+      end
+    end
+  end
+end

data/lib/curlybars/error/presenter/not_found.rb

@@ -0,0 +1,23 @@
+module Curlybars
+  module Error
+    module Presenter
+      class NotFound < StandardError
+        attr_reader :path
+
+        def initialize(path)
+          @path = path
+        end
+
+        def message
+          "error compiling `#{path}`: could not find #{presenter_class_name}"
+        end
+
+        private
+
+        def presenter_class_name
+          Curlybars::Presenter.presenter_name_for_path(path)
+        end
+      end
+    end
+  end
+end

data/lib/curlybars/error/render.rb

@@ -0,0 +1,11 @@
+require 'curlybars/error/base'
+
+module Curlybars
+  module Error
+    class Render < Curlybars::Error::Base
+      def initialize(id, message, position, **metadata)
+        super('render.%s' % id, message, position, metadata)
+      end
+    end
+  end
+end

data/lib/curlybars/error/validate.rb

@@ -0,0 +1,18 @@
+require 'curlybars/error/base'
+
+module Curlybars
+  module Error
+    class Validate < Curlybars::Error::Base
+      def initialize(id, message, rltk_position, offset_adjustment = 0, **metadata)
+        position = Curlybars::Position.new(
+          rltk_position.file_name,
+          rltk_position.line_number,
+          rltk_position.line_offset + offset_adjustment,
+          rltk_position.length - offset_adjustment
+        )
+
+        super('validate.%s' % id, message, position, metadata)
+      end
+    end
+  end
+end

data/lib/curlybars/lexer.rb

@@ -0,0 +1,60 @@
+require 'rltk/lexer'
+
+# rubocop:disable Style/RegexpLiteral, Style/Semicolon
+module Curlybars
+  class Lexer < RLTK::Lexer
+    match_first
+
+    # The following is an identifier Handlebars compliant
+    # IDENTIFIER = '[A-Za-z_][0-9\w]*'
+
+    # This accomodates the edge case of identifiers containing dashes
+    # IDENTIFIER = '[A-Za-z_\-][0-9\w\-]*'
+
+    # This accomodates the edge case of identifiers containing all numbers
+    # and dashes
+    IDENTIFIER = '[0-9A-Za-z_\-][0-9\w\-]*'.freeze
+
+    r(/\\{/) { [:TEXT, '{'] }
+    r(/\\/) { [:TEXT, '\\'] }
+
+    r(/{{!--/) { push_state :comment_block }
+    r(/--}}/, :comment_block) { pop_state }
+    r(/./m, :comment_block)
+
+    r(/{{!/) { push_state :comment }
+    r(/}}/, :comment) { pop_state }
+    r(/./m, :comment)
+
+    r(/{{~/) { push_state :curly; :TILDE_START }
+    r(/~}}/, :curly) { pop_state; :TILDE_END }
+
+    r(/{{/) { push_state :curly; :START }
+    r(/}}/, :curly) { pop_state; :END }
+
+    r(/#/, :curly) { :HASH }
+    r(/\//, :curly) { :SLASH }
+    r(/>/, :curly) { :GT }
+
+    r(/if\b/, :curly) { :IF }
+    r(/unless\b/, :curly) { :UNLESS }
+    r(/each\b/, :curly) { :EACH }
+    r(/with\b/, :curly) { :WITH }
+    r(/else\b/, :curly) { :ELSE }
+
+    r(/true/, :curly) { [:LITERAL, true] }
+    r(/false/, :curly) { [:LITERAL, false] }
+    r(/[-+]?\d+/, :curly) { |integer| [:LITERAL, integer.to_i] }
+    r(/'(.*?)'/, :curly) { [:LITERAL, match[1].inspect] }
+    r(/"(.*?)"/, :curly) { [:LITERAL, match[1].inspect] }
+
+    r(/@((?:\.\.\/)*#{IDENTIFIER})/, :curly) { |variable| [:VARIABLE, match[1]] }
+
+    r(/(#{IDENTIFIER})\s*=/, :curly) { [:KEY, match[1]] }
+    r(/(?:\.\.\/)*(?:#{IDENTIFIER}\.)*#{IDENTIFIER}/, :curly) { |name| [:PATH, name] }
+
+    r(/\s/, :curly)
+
+    r(/.*?(?=\\|{{|\z)/m) { |text| [:TEXT, text] }
+  end
+end

data/lib/curlybars/method_whitelist.rb

@@ -0,0 +1,69 @@
+module Curlybars
+  module MethodWhitelist
+    def allow_methods(*methods, **methods_with_type)
+      methods_with_type.each do |(method_name, type)|
+        if type.is_a?(Array)
+          if type.size != 1 || !type.first.respond_to?(:dependency_tree)
+            raise "Invalid allowed method syntax for `#{method_name}`. Collections must be of one presenter class"
+          end
+        end
+      end
+
+      define_method(:allowed_methods) do
+        methods_list = methods + methods_with_type.keys
+        defined?(super) ? super() + methods_list : methods_list
+      end
+
+      define_singleton_method(:methods_schema) do |*args|
+        schema = methods.each_with_object({}) do |method, memo|
+          memo[method] = nil
+        end
+
+        methods_with_type_resolved = methods_with_type.each_with_object({}) do |(method_name, type), memo|
+          memo[method_name] = if type.respond_to?(:call)
+            type.call(*args)
+          else
+            type
+          end
+        end
+
+        schema.merge!(methods_with_type_resolved)
+
+        # Inheritance
+        schema.merge!(super(*args)) if defined?(super)
+
+        # Included modules
+        included_modules.each do |mod|
+          next unless mod.respond_to?(:methods_schema)
+          schema.merge!(mod.methods_schema(*args))
+        end
+
+        schema
+      end
+
+      define_singleton_method(:dependency_tree) do |*args|
+        methods_schema(*args).each_with_object({}) do |method_with_type, memo|
+          method_name = method_with_type.first
+          type = method_with_type.last
+
+          memo[method_name] = if type.respond_to?(:dependency_tree)
+            type.dependency_tree(*args)
+          elsif type.is_a?(Array)
+            [type.first.dependency_tree(*args)]
+          else
+            type
+          end
+        end
+      end
+
+      define_method(:allows_method?) do |method|
+        allowed_methods.include?(method)
+      end
+    end
+
+    def self.extended(base)
+      # define a default of no method allowed
+      base.allow_methods
+    end
+  end
+end