liquor 0.1.1 → 0.9.1

data/lib/liquor/library.rb

@@ -0,0 +1,41 @@
+module Liquor
+  module Library
+    def self.included(klass)
+      klass.instance_exec {
+        extend ModuleMethods
+
+        @functions = []
+        @tags      = []
+      }
+    end
+
+    module ModuleMethods
+      def export(compiler)
+        @functions.each do |function|
+          compiler.register_function function
+        end
+
+        @tags.each do |tag|
+          compiler.register_tag tag
+        end
+      end
+
+      def function(name, options={}, &block)
+        @functions << Function.new(name, options, &block)
+      end
+
+      def function_alias(name, other)
+        function = @functions.find { |f| f.name == other }
+        if function.nil?
+          raise "Cannot alias to function `#{other}', as it does not exist"
+        end
+
+        @functions << function.alias(name)
+      end
+
+      def tag(name, options={}, &block)
+        @tags << Tag.new(name, options, &block)
+      end
+    end
+  end
+end

data/lib/liquor/manager.rb

@@ -0,0 +1,146 @@
+module Liquor
+  class Manager
+    attr_reader :diagnostics
+
+    def initialize(options={})
+      import   = options.delete(:import).to_a || []
+      @dump_ir = options.delete(:dump_intermediates)
+
+      if options.any?
+        raise "Unknown function options: #{options.keys.join ", "}"
+      end
+
+      @compiler  = Liquor::Compiler.new(manager: self)
+      import.each do |library|
+        library.export @compiler
+      end
+
+      @parser    = Liquor::Parser.new(@compiler.tags)
+
+      @sources   = {}
+      @templates = {}
+      @partials  = {}
+      @compiled_templates = nil
+
+      @diagnostics = []
+    end
+
+    def partial?(name)
+      name.start_with? '_'
+    end
+
+    def register_template(name, source, externals=[])
+      if partial? name
+        raise ::ArgumentError, "Template `#{name}' is a partial"
+      end
+
+      @sources[name] = source.dup
+
+      if @parser.parse(source, name)
+        @templates[name.to_s] = [ @parser.ast, externals ]
+      else
+        @diagnostics.concat @parser.errors
+      end
+    end
+
+    def register_layout(name, source, externals=[])
+      register_template name, source, externals + [ :_inner_template ]
+    end
+
+    def register_partial(name, source)
+      unless partial? name
+        raise ::ArgumentError, "Template `#{name}' is not a partial"
+      end
+
+      @sources[name] = source.dup
+
+      if @parser.parse(source, name)
+        @partials[name.to_s] = @parser.ast
+      else
+        @partials[name.to_s] = :syntax_error
+        @diagnostics.concat @parser.errors
+      end
+    end
+
+    def fetch_partial(name)
+      @partials[name.to_s]
+    end
+
+    def compile
+      @compiled_templates = {}
+
+      @templates.each do |name, (template, externals)|
+        @compiler.compile(template, externals, name)
+        dump_intermediates(name, template)
+
+        if @compiler.success?
+          @compiled_templates[name] = @compiler.code
+        else
+          @diagnostics.concat @compiler.diagnostics
+        end
+      end
+
+      success?
+    end
+
+    def errors
+      diagnostics.select &:error?
+    end
+
+    def success?
+      errors.none?
+    end
+
+    def has_template?(name)
+      !@compiled_templates[name].nil?
+    end
+
+    def render(name, externals={}, storage={})
+      if @compiled_templates.nil?
+        raise ::RuntimeError, "Call #compile before #render"
+      end
+
+      template = @compiled_templates[name]
+      if template.nil?
+        raise Error.new("Template `#{name}' does not exist")
+      end
+
+      template.call(externals, storage)
+    end
+
+    def render_with_layout(layout_name, layout_externals,
+                           template_name, template_externals,
+                           storage={})
+      template_result = render(template_name, template_externals, storage)
+      layout_result   = render(layout_name, layout_externals.
+                            merge(_inner_template: template_result), storage)
+
+      layout_result
+    end
+
+    def decorate(error)
+      decorated = []
+
+      if error.is_a? Diagnostic
+        if error.location
+          if file = error.location[:file]
+            decorated = error.decorate @sources[file]
+          end
+        end
+      end
+
+      decorated
+    end
+
+    protected
+
+    def dump_intermediates(template_name, liquor_source)
+      if @dump_ir
+        path = File.join(@dump_ir, "#{template_name}.liquor.rb")
+        if @compiler.success?
+          File.write(path, @compiler.source)
+        end
+      end
+    end
+  end
+end

data/lib/liquor/runtime.rb

@@ -0,0 +1,167 @@
+module Liquor
+  module Runtime
+    class DummyExternal
+      def liquor_send(method, args, loc=nil)
+        nil
+      end
+
+      def source
+        nil
+      end
+    end
+
+    def self.type(value)
+      case value
+      when nil;         :null
+      when true, false; :boolean
+      when Integer;     :integer
+      when String;      :string
+      when Array;       :tuple
+      when External;    :external
+      else;             :invalid
+      end
+    end
+
+    def self.pretty_type(value)
+      case value
+      when nil;         "Null"
+      when true, false; "Boolean"
+      when Integer;     "Integer"
+      when String;      "String"
+      when Array;       "Tuple"
+      when External;    indexable?(value) ? "IndexableExternal" : "External"
+      else              "_Foreign<#{value.class}>"
+      end
+    end
+
+    def self.default_value_of(type)
+      case type
+      when :null;     nil
+      when :boolean;  false
+      when :integer;  0
+      when :string;   ""
+      when :tuple;    []
+      when :external; DummyExternal.new
+      end
+    end
+
+    @diagnostics = nil
+
+    def self.capture_diagnostics
+      old_diagnostics = @diagnostics
+      @diagnostics    = []
+
+      yield
+
+      @diagnostics
+    ensure
+      @diagnostics    = old_diagnostics
+    end
+
+    @fatal_deprecations = false
+
+    def self.with_fatal_deprecations
+      old_fatal_deprecations = @fatal_deprecations
+      @fatal_deprecations    = true
+
+      yield
+    ensure
+      @fatal_deprecations    = old_fatal_deprecations
+    end
+
+    def self.soft_error(klass=TypeError, message, expectation, loc)
+      error = klass.new(message, loc)
+
+      if @diagnostics.nil?
+        raise error
+      else
+        error.set_backtrace(caller(2))
+        @diagnostics << error
+
+        default_value_of expectation
+      end
+    end
+
+    def self.deprecation(message, loc)
+      error = Liquor::Deprecation.new(message, loc)
+      error.set_backtrace(caller(2))
+
+      if @fatal_deprecations
+        raise error
+      elsif @diagnostics
+        @diagnostics << error
+      end
+    end
+
+    def self.indexable?(value)
+      value.is_a?(Array) ||
+        value.is_a?(External) &&
+        value.class.liquor_exports &&
+        value.class.liquor_exports.include?(:[])
+    end
+
+    def self.add!(left, left_loc, right, right_loc)
+      if left.is_a? Integer
+        right = integer! right, right_loc
+      elsif left.is_a? String
+        right = string! right, right_loc
+      elsif indexable?(left)
+        left  = left.to_a
+        right = tuple! right, right_loc
+      else
+        return soft_error("Integer, String, Tuple or indexable External value expected, #{pretty_type(left)} found", :null, left_loc)
+      end
+
+      left + right
+    end
+
+    def self.integer!(value, loc)
+      unless value.is_a? Integer
+        return soft_error("Integer value expected, #{pretty_type(value)} found", :integer, loc)
+      end
+
+      value
+    end
+
+    def self.string!(value, loc)
+      if value.is_a? String
+        value
+      elsif value.is_a? Integer
+        value.to_s
+      else
+        return soft_error("String value expected, #{pretty_type(value)} found", :string, loc)
+      end
+    end
+
+    # Proper indexable external API:
+    # .[](index) => element fetch
+    # .size      => element count
+    # .to_a      => converts to Array
+
+    def self.tuple!(value, loc)
+      unless indexable?(value)
+        return soft_error("Tuple or indexable External value expected, #{pretty_type(value)} found", :tuple, loc)
+      end
+
+      value
+    end
+
+    def self.external!(value, loc)
+      unless value.is_a? External
+        return soft_error("External value expected, #{pretty_type(value)} found", :external, loc)
+      end
+
+      value
+    end
+
+    def self.interp!(value, loc)
+      unless value.is_a?(String) ||
+             value.is_a?(Integer) ||
+             value.nil?
+        return soft_error("String or Null value expected, #{pretty_type(value)} found", :string, loc)
+      end
+
+      value.to_s
+    end
+  end
+end

data/lib/liquor/stdlib/builtin_functions.rb

@@ -0,0 +1,315 @@
+require 'time'
+require 'uri'
+require_relative 'html_truncater'
+
+module Liquor
+  module Builtins
+    #
+    # Universal functions
+    #
+
+    function "is_empty", unnamed_arg: :any do |arg,|
+      arg.nil? || (arg.respond_to?(:size) && arg.size == 0)
+    end
+
+    function "size", unnamed_arg: [:string, :tuple] do |arg,|
+      arg.size
+    end
+
+    #
+    # Type conversion functions
+    #
+
+    function "strftime",
+              unnamed_arg: :string,
+              mandatory_named_args: { format: :string } do |arg, kw|
+      begin
+        time = Time.parse(arg)
+
+        if defined?(I18n)
+          I18n.localize(time, format: kw[:format])
+        else
+          time.strftime(kw[:format])
+        end
+
+      rescue Exception => e
+        arg
+      end
+    end
+
+    function "to_number", unnamed_arg: [:integer, :string] do |arg,|
+      if arg.is_a? Integer
+        arg
+      else
+        arg.to_i
+      end
+    end
+
+    #
+    # Integer functions
+    #
+
+    function "is_even", unnamed_arg: :integer do |arg,|
+      (arg % 2) == 0
+    end
+
+    function "is_odd", unnamed_arg: :integer do |arg,|
+      (arg % 2) == 1
+    end
+
+    #
+    # String functions
+    #
+
+    function "downcase", unnamed_arg: :string do |arg,|
+      arg.downcase
+    end
+
+    function "upcase", unnamed_arg: :string do |arg,|
+      arg.upcase
+    end
+
+    function "capitalize", unnamed_arg: :string do |arg,|
+      arg.capitalize
+    end
+
+    function "starts_with", unnamed_arg: :string,
+                            mandatory_named_args: { pattern: :string } do |arg, kw|
+      arg.start_with?(kw[:pattern])
+    end
+
+    function "strip_newlines", unnamed_arg: :string do |arg,|
+      arg.gsub("\n", "")
+    end
+
+    function "join", unnamed_arg: :tuple,
+                     optional_named_args: { with: :string } do |arg, kw|
+      arg.flatten.join(kw[:with] || ' ')
+    end
+
+    function "split", unnamed_arg: :string,
+                      optional_named_args: { by: :string } do |arg, kw|
+      arg.split(kw[:by] || ' ')
+    end
+
+    function "replace",
+              unnamed_arg: :string,
+              mandatory_named_args: {
+                pattern: :string,
+                replacement: :string
+              } do |arg, kw|
+      arg.gsub kw[:pattern], kw[:replacement]
+    end
+
+    function "replace_first",
+              unnamed_arg: :string,
+              mandatory_named_args: {
+                pattern: :string,
+                replacement: :string
+              } do |arg, kw|
+      arg.sub kw[:pattern], kw[:replacement]
+    end
+
+    function "remove",
+              unnamed_arg: :string,
+              mandatory_named_args: {
+                pattern: :string,
+              } do |arg, kw|
+      arg.gsub kw[:pattern], ''
+    end
+
+    function "remove_first",
+              unnamed_arg: :string,
+              mandatory_named_args: {
+                pattern: :string,
+              } do |arg, kw|
+      arg.sub kw[:pattern], ''
+    end
+
+    function "newline_to_br", unnamed_arg: :string do |arg,|
+      arg.gsub(/\n/, "<br>\n")
+    end
+
+    function "url_escape", unnamed_arg: :string do |arg,|
+      URI.encode_www_form_component(arg)
+    end
+
+    function "html_escape", unnamed_arg: [:string, :null] do |arg,|
+      if arg
+        if defined?(Rack::Utils)
+          Rack::Utils.escape_html(arg)
+        else
+          raise NotImplementedError, "html_escape() requires Rack"
+        end
+      end
+    end
+
+    function "html_escape_once", unnamed_arg: :string do |arg,|
+      if defined?(ActionView)
+        @html_escape_once_helper ||= Object.new.
+            tap { |obj| obj.extend ActionView::Helpers::TagHelper }
+        @html_escape_once_helper.escape_once(arg)
+      else
+        raise NotImplementedError, "html_escape_once() requires ActionView"
+      end
+    end
+    function_alias "h", "html_escape_once"
+
+    function "strip_html", unnamed_arg: :string do |arg,|
+      if defined?(HTML::Sanitizer)
+        HTML::FullSanitizer.new.sanitize(arg)
+      else
+        raise NotImplementedError, "escape_once() requires HTML::Sanitizer (try loading ActionView)"
+      end
+    end
+
+    function "decode_html_entities", unnamed_arg: :string do |arg,|
+      if defined?(HTMLEntities)
+        HTMLEntities.new.decode(arg)
+      else
+        raise NotImplementedError, "decode_html_entities() requires HTMLEntities"
+      end
+    end
+
+    #
+    # Tuple functions
+    #
+
+    function "compact", unnamed_arg: :tuple do |arg,|
+      arg.compact
+    end
+
+    function "reverse", unnamed_arg: :tuple do |arg,|
+      arg.reverse
+    end
+
+    function "uniq", unnamed_arg: :tuple do |arg, |
+      arg.uniq
+    end
+
+    minmax = lambda do |fn, fn_by, set, key|
+      if key
+        set.to_a.select { |r| !r.liquor_send(key, []).nil? }.
+                 send(fn_by) { |r| r.liquor_send(key, []) }
+      else
+        set.to_a.send(fn)
+      end
+    end
+
+    function "min", unnamed_arg: [:tuple],
+                    optional_named_args: {
+                      by: :string
+                    } do |source_set, kw|
+      minmax.call(:min, :min_by, source_set, kw[:by])
+    end
+
+    function "max", unnamed_arg: [:tuple],
+                    optional_named_args: {
+                      by: :string
+                    } do |source_set, kw|
+      minmax.call(:max, :max_by, source_set, kw[:by])
+    end
+
+    function "in_groups_of",
+              unnamed_arg: [:tuple],
+              mandatory_named_args: { size: :integer },
+              optional_named_args:  { fill_with: [:string, :boolean] } do |arg, kw|
+      if [].respond_to? :in_groups_of
+        arg.to_a.in_groups_of(kw[:size], kw[:fill_with])
+      else
+        raise NotImplementedError, "in_groups_of() requires ActiveSupport Array extensions"
+      end
+    end
+
+    function "in_groups",
+              unnamed_arg: [:tuple],
+              mandatory_named_args: { count: :integer },
+              optional_named_args:  { fill_with: [:string, :boolean] } do |arg, kw|
+      if [].respond_to? :in_groups
+        arg.to_a.in_groups(kw[:count], kw[:fill_with])
+      else
+        raise NotImplementedError, "in_groups() requires ActiveSupport Array extensions"
+      end
+    end
+
+    # DEPRECATED
+    function "includes",
+              unnamed_arg: :tuple,
+              mandatory_named_args: { element: :any } do |arg, kw|
+      arg.include?(kw[:element])
+    end
+
+    #
+    # Intelligent truncation functions
+    #
+
+    function "truncate",
+              unnamed_arg: :string,
+              optional_named_args: {
+                length:   :integer,
+                omission: :string
+              } do |arg, kw|
+      length   = kw[:length]   || 50
+      omission = kw[:omission] || '...'
+
+      truncate_at = length - kw[:omission].length
+      truncate_at = 0 if length < 0
+
+      if arg.length > length
+        arg[0...truncate_at] + omission
+      else
+        arg
+      end
+    end
+
+    function "truncate_words",
+              unnamed_arg: :string,
+              optional_named_args: {
+                words:    :integer,
+                omission: :string
+              } do |arg, kw|
+      words    = arg.split
+      length   = kw[:words]    || 15
+      omission = kw[:omission] || '...'
+
+      if words.length > length
+        words[0...length].join(" ") + omission
+      else
+        words.join(" ")
+      end
+    end
+
+    function "html_truncate",
+              unnamed_arg: :string,
+              optional_named_args: {
+                length:   :integer,
+                omission: :string
+              } do |arg, kw|
+      length   = kw[:length]   || 50
+      omission = kw[:omission] || '...'
+
+      if defined?(Nokogiri)
+        HTMLTruncater.truncate(arg, length, omission)
+      else
+        raise NotImplementedError, "html_truncate() requires Nokogiri"
+      end
+    end
+
+    function "html_truncate_words",
+              unnamed_arg: :string,
+              optional_named_args: {
+                words:    :integer,
+                omission: :string
+              } do |arg, kw|
+      length   = kw[:words]    || 15
+      omission = kw[:omission] || '...'
+
+      if defined?(Nokogiri)
+        HTMLTruncater.truncate_words(arg, length, omission)
+      else
+        raise NotImplementedError, "html_truncate_words() requires Nokogiri"
+      end
+    end
+
+  end
+end