liquid 2.6.1 → 4.0.3

data/lib/liquid/document.rb

@@ -1,17 +1,27 @@
 module Liquid
-  class Document < Block
-    # we don't need markup to open this block
-    def initialize(tokens)
-      parse(tokens)
+  class Document < BlockBody
+    def self.parse(tokens, parse_context)
+      doc = new
+      doc.parse(tokens, parse_context)
+      doc
     end
 
-    # There isn't a real delimiter
-    def block_delimiter
-      []
+    def parse(tokens, parse_context)
+      super do |end_tag_name, end_tag_params|
+        unknown_tag(end_tag_name, parse_context) if end_tag_name
+      end
+    rescue SyntaxError => e
+      e.line_number ||= parse_context.line_number
+      raise
     end
 
-    # Document blocks don't need to be terminated since they are not actually opened
-    def assert_missing_delimitation!
+    def unknown_tag(tag, parse_context)
+      case tag
+      when 'else'.freeze, 'end'.freeze
+        raise SyntaxError.new(parse_context.locale.t("errors.syntax.unexpected_outer_tag".freeze, tag: tag))
+      else
+        raise SyntaxError.new(parse_context.locale.t("errors.syntax.unknown_tag".freeze, tag: tag))
+      end
     end
   end
 end

data/lib/liquid/drop.rb

@@ -1,7 +1,6 @@
 require 'set'
 
 module Liquid
-
   # A drop in liquid is a class which allows you to export DOM like things to liquid.
   # Methods of drops are callable.
   # The main use for liquid drops is to implement lazy loaded objects.
@@ -19,43 +18,61 @@ module Liquid
   #   tmpl = Liquid::Template.parse( ' {% for product in product.top_sales %} {{ product.name }} {%endfor%} '  )
   #   tmpl.render('product' => ProductDrop.new ) # will invoke top_sales query.
   #
-  # Your drop can either implement the methods sans any parameters or implement the before_method(name) method which is a
-  # catch all.
+  # Your drop can either implement the methods sans any parameters
+  # or implement the liquid_method_missing(name) method which is a catch all.
   class Drop
     attr_writer :context
 
-    EMPTY_STRING = ''.freeze
-
     # Catch all for the method
-    def before_method(method)
-      nil
+    def liquid_method_missing(method)
+      return nil unless @context && @context.strict_variables
+      raise Liquid::UndefinedDropMethod, "undefined method #{method}"
     end
 
     # called by liquid to invoke a drop
     def invoke_drop(method_or_key)
-      if method_or_key && method_or_key != EMPTY_STRING && self.class.invokable?(method_or_key)
+      if self.class.invokable?(method_or_key)
         send(method_or_key)
       else
-        before_method(method_or_key)
+        liquid_method_missing(method_or_key)
       end
     end
 
-    def has_key?(name)
+    def key?(_name)
       true
     end
 
+    def inspect
+      self.class.to_s
+    end
+
     def to_liquid
       self
     end
 
-    alias :[] :invoke_drop
+    def to_s
+      self.class.name
+    end
 
-    private
+    alias_method :[], :invoke_drop
 
     # Check for method existence without invoking respond_to?, which creates symbols
     def self.invokable?(method_name)
-      @invokable_methods ||= Set.new(["to_liquid"] + (public_instance_methods - Liquid::Drop.public_instance_methods).map(&:to_s))
-      @invokable_methods.include?(method_name.to_s)
+      invokable_methods.include?(method_name.to_s)
+    end
+
+    def self.invokable_methods
+      @invokable_methods ||= begin
+        blacklist = Liquid::Drop.public_instance_methods + [:each]
+
+        if include?(Enumerable)
+          blacklist += Enumerable.public_instance_methods
+          blacklist -= [:sort, :count, :first, :min, :max, :include?]
+        end
+
+        whitelist = [:to_liquid] + (public_instance_methods - blacklist)
+        Set.new(whitelist.map(&:to_s))
+      end
     end
   end
 end

data/lib/liquid/errors.rb

@@ -1,12 +1,56 @@
 module Liquid
-  class Error < ::StandardError; end
-
-  class ArgumentError < Error; end
-  class ContextError < Error; end
-  class FilterNotFound < Error; end
-  class FileSystemError < Error; end
-  class StandardError < Error; end
-  class SyntaxError < Error; end
-  class StackLevelError < Error; end
-  class MemoryError < Error; end
+  class Error < ::StandardError
+    attr_accessor :line_number
+    attr_accessor :template_name
+    attr_accessor :markup_context
+
+    def to_s(with_prefix = true)
+      str = ""
+      str << message_prefix if with_prefix
+      str << super()
+
+      if markup_context
+        str << " "
+        str << markup_context
+      end
+
+      str
+    end
+
+    private
+
+    def message_prefix
+      str = ""
+      if is_a?(SyntaxError)
+        str << "Liquid syntax error"
+      else
+        str << "Liquid error"
+      end
+
+      if line_number
+        str << " ("
+        str << template_name << " " if template_name
+        str << "line " << line_number.to_s << ")"
+      end
+
+      str << ": "
+      str
+    end
+  end
+
+  ArgumentError = Class.new(Error)
+  ContextError = Class.new(Error)
+  FileSystemError = Class.new(Error)
+  StandardError = Class.new(Error)
+  SyntaxError = Class.new(Error)
+  StackLevelError = Class.new(Error)
+  TaintedError = Class.new(Error)
+  MemoryError = Class.new(Error)
+  ZeroDivisionError = Class.new(Error)
+  FloatDomainError = Class.new(Error)
+  UndefinedVariable = Class.new(Error)
+  UndefinedDropMethod = Class.new(Error)
+  UndefinedFilter = Class.new(Error)
+  MethodOverrideError = Class.new(Error)
+  InternalError = Class.new(Error)
 end

data/lib/liquid/expression.rb

@@ -0,0 +1,49 @@
+module Liquid
+  class Expression
+    class MethodLiteral
+      attr_reader :method_name, :to_s
+
+      def initialize(method_name, to_s)
+        @method_name = method_name
+        @to_s = to_s
+      end
+
+      def to_liquid
+        to_s
+      end
+    end
+
+    LITERALS = {
+      nil => nil, 'nil'.freeze => nil, 'null'.freeze => nil, ''.freeze => nil,
+      'true'.freeze  => true,
+      'false'.freeze => false,
+      'blank'.freeze => MethodLiteral.new(:blank?, '').freeze,
+      'empty'.freeze => MethodLiteral.new(:empty?, '').freeze
+    }.freeze
+
+    SINGLE_QUOTED_STRING = /\A'(.*)'\z/m
+    DOUBLE_QUOTED_STRING = /\A"(.*)"\z/m
+    INTEGERS_REGEX       = /\A(-?\d+)\z/
+    FLOATS_REGEX         = /\A(-?\d[\d\.]+)\z/
+    RANGES_REGEX         = /\A\((\S+)\.\.(\S+)\)\z/
+
+    def self.parse(markup)
+      if LITERALS.key?(markup)
+        LITERALS[markup]
+      else
+        case markup
+        when SINGLE_QUOTED_STRING, DOUBLE_QUOTED_STRING
+          $1
+        when INTEGERS_REGEX
+          $1.to_i
+        when RANGES_REGEX
+          RangeLookup.parse($1, $2)
+        when FLOATS_REGEX
+          $1.to_f
+        else
+          VariableLookup.parse(markup)
+        end
+      end
+    end
+  end
+end

data/lib/liquid/extensions.rb

@@ -7,44 +7,56 @@ class String # :nodoc:
   end
 end
 
-class Array  # :nodoc:
+class Symbol # :nodoc:
+  def to_liquid
+    to_s
+  end
+end
+
+class Array # :nodoc:
+  def to_liquid
+    self
+  end
+end
+
+class Hash # :nodoc:
   def to_liquid
     self
   end
 end
 
-class Hash  # :nodoc:
+class Numeric # :nodoc:
   def to_liquid
     self
   end
 end
 
-class Numeric  # :nodoc:
+class Range # :nodoc:
   def to_liquid
     self
   end
 end
 
-class Time  # :nodoc:
+class Time # :nodoc:
   def to_liquid
     self
   end
 end
 
-class DateTime < Date  # :nodoc:
+class DateTime < Date # :nodoc:
   def to_liquid
     self
   end
 end
 
-class Date  # :nodoc:
+class Date # :nodoc:
   def to_liquid
     self
   end
 end
 
 class TrueClass
-  def to_liquid  # :nodoc:
+  def to_liquid # :nodoc:
     self
   end
 end

data/lib/liquid/file_system.rb

@@ -8,13 +8,13 @@ module Liquid
   #
   # Example:
   #
-  # Liquid::Template.file_system = Liquid::LocalFileSystem.new(template_path)
-  # liquid = Liquid::Template.parse(template)
+  #   Liquid::Template.file_system = Liquid::LocalFileSystem.new(template_path)
+  #   liquid = Liquid::Template.parse(template)
   #
   # This will parse the template with a LocalFileSystem implementation rooted at 'template_path'.
   class BlankFileSystem
     # Called by Liquid to retrieve a template file
-    def read_template_file(template_path, context)
+    def read_template_file(_template_path)
       raise FileSystemError, "This liquid context does not allow includes."
     end
   end
@@ -26,35 +26,46 @@ module Liquid
   #
   # Example:
   #
-  # file_system = Liquid::LocalFileSystem.new("/some/path")
+  #   file_system = Liquid::LocalFileSystem.new("/some/path")
   #
-  # file_system.full_path("mypartial")       # => "/some/path/_mypartial.liquid"
-  # file_system.full_path("dir/mypartial")   # => "/some/path/dir/_mypartial.liquid"
+  #   file_system.full_path("mypartial")       # => "/some/path/_mypartial.liquid"
+  #   file_system.full_path("dir/mypartial")   # => "/some/path/dir/_mypartial.liquid"
+  #
+  # Optionally in the second argument you can specify a custom pattern for template filenames.
+  # The Kernel::sprintf format specification is used.
+  # Default pattern is "_%s.liquid".
+  #
+  # Example:
+  #
+  #   file_system = Liquid::LocalFileSystem.new("/some/path", "%s.html")
+  #
+  #   file_system.full_path("index") # => "/some/path/index.html"
   #
   class LocalFileSystem
     attr_accessor :root
 
-    def initialize(root)
+    def initialize(root, pattern = "_%s.liquid".freeze)
       @root = root
+      @pattern = pattern
     end
 
-    def read_template_file(template_path, context)
+    def read_template_file(template_path)
       full_path = full_path(template_path)
-      raise FileSystemError, "No such template '#{template_path}'" unless File.exists?(full_path)
+      raise FileSystemError, "No such template '#{template_path}'" unless File.exist?(full_path)
 
       File.read(full_path)
     end
 
     def full_path(template_path)
-      raise FileSystemError, "Illegal template name '#{template_path}'" unless template_path =~ /^[^.\/][a-zA-Z0-9_\/]+$/
+      raise FileSystemError, "Illegal template name '#{template_path}'" unless template_path =~ /\A[^.\/][a-zA-Z0-9_\/]+\z/
 
-      full_path = if template_path.include?('/')
-        File.join(root, File.dirname(template_path), "_#{File.basename(template_path)}.liquid")
+      full_path = if template_path.include?('/'.freeze)
+        File.join(root, File.dirname(template_path), @pattern % File.basename(template_path))
       else
-        File.join(root, "_#{template_path}.liquid")
+        File.join(root, @pattern % template_path)
       end
 
-      raise FileSystemError, "Illegal template path '#{File.expand_path(full_path)}'" unless File.expand_path(full_path) =~ /^#{File.expand_path(root)}/
+      raise FileSystemError, "Illegal template path '#{File.expand_path(full_path)}'" unless File.expand_path(full_path).start_with?(File.expand_path(root))
 
       full_path
     end

data/lib/liquid/forloop_drop.rb

@@ -0,0 +1,42 @@
+module Liquid
+  class ForloopDrop < Drop
+    def initialize(name, length, parentloop)
+      @name = name
+      @length = length
+      @parentloop = parentloop
+      @index = 0
+    end
+
+    attr_reader :name, :length, :parentloop
+
+    def index
+      @index + 1
+    end
+
+    def index0
+      @index
+    end
+
+    def rindex
+      @length - @index
+    end
+
+    def rindex0
+      @length - @index - 1
+    end
+
+    def first
+      @index == 0
+    end
+
+    def last
+      @index == @length - 1
+    end
+
+    protected
+
+    def increment!
+      @index += 1
+    end
+  end
+end

data/lib/liquid/i18n.rb

@@ -0,0 +1,39 @@
+require 'yaml'
+
+module Liquid
+  class I18n
+    DEFAULT_LOCALE = File.join(File.expand_path(__dir__), "locales", "en.yml")
+
+    TranslationError = Class.new(StandardError)
+
+    attr_reader :path
+
+    def initialize(path = DEFAULT_LOCALE)
+      @path = path
+    end
+
+    def translate(name, vars = {})
+      interpolate(deep_fetch_translation(name), vars)
+    end
+    alias_method :t, :translate
+
+    def locale
+      @locale ||= YAML.load_file(@path)
+    end
+
+    private
+
+    def interpolate(name, vars)
+      name.gsub(/%\{(\w+)\}/) do
+        # raise TranslationError, "Undefined key #{$1} for interpolation in translation #{name}"  unless vars[$1.to_sym]
+        (vars[$1.to_sym]).to_s
+      end
+    end
+
+    def deep_fetch_translation(name)
+      name.split('.'.freeze).reduce(locale) do |level, cur|
+        level[cur] or raise TranslationError, "Translation for #{name} does not exist in locale #{path}"
+      end
+    end
+  end
+end