thymeleaf 0.1.0

checksums.yaml

@@ -0,0 +1,7 @@
+---
+SHA1:
+  metadata.gz: 2ae44746cdafe6e28cb8f57da926e006a531e0db
+  data.tar.gz: 8b44f5ba0c9eb82025f21f3363fbc8ecd7f27895
+SHA512:
+  metadata.gz: 8663e50466b26f5e3f5de3b096ba355f1ff6649e9e9a7268cb66e2336cb158af1c2e1eed7d2e7d7a1130e3d94e28984e8fd0d7b67bfd5640d54ddf9211160a0f
+  data.tar.gz: 981a896eddf139b5050683f7a7703ad6d2e12db6adb0ddaf8f8c5f581689390cb847201501cd7ca07935e74aa091e7e440ac7e97729d3812d53b93a5d8f88498

data/lib/thymeleaf/configuration.rb

@@ -0,0 +1,45 @@
+
+require_relative 'dialects'
+require_relative 'dialects/default/default_dialect'
+require_relative 'template/template_resolver'
+require_relative 'parser/parse_options'
+
+module Thymeleaf
+
+  class << self
+    attr_accessor :configuration
+  end
+
+  # TODO: Replace accessor with getter/setter?
+
+  def self.configure(&block)
+    self.configuration ||= Configuration.new
+    block.call configuration if block_given?
+  end
+
+  class Configuration
+
+    attr_accessor :dialects, :template, :parser
+
+    def initialize
+      self.dialects = Dialects.new
+      self.template = TemplateResolver.new
+      self.parser   = ParseOptions.new
+      add_dialect DefaultDialect
+    end
+
+    def add_dialect(*args)
+      dialects.add_dialect(*args)
+    end
+    
+    def clear_dialects
+      dialects.clear_dialects
+    end
+    
+    def template_uri(name)
+      template.get_template(name)
+    end
+
+  end
+
+end

data/lib/thymeleaf/context/context_holder.rb

@@ -0,0 +1,34 @@
+
+require_relative 'context_struct'
+
+class ContextHolder < Struct.new(:context, :parent_context)
+
+  def initialize(context, parent_context = nil)
+    if context.is_a? Hash
+      super(ContextStruct.new(context), parent_context)
+    else
+      super(context, parent_context)
+    end
+  end
+
+  def evaluate(expr)
+    instance_eval(expr.to_s)
+  end
+
+  def method_missing(m, *args)
+    if context.respond_to? m
+      context.send(m, *args)
+    elsif !parent_context.nil?
+      parent_context.send(m, *args)
+    end
+  end
+  
+  def root
+    if parent_context.nil?
+      context
+    else
+      parent_context.root
+    end
+  end
+  
+end

data/lib/thymeleaf/context/context_struct.rb

@@ -0,0 +1,50 @@
+
+require 'ostruct'
+
+class ContextStruct < OpenStruct
+
+  def initialize(hash=nil)
+    @table = {}
+    @hash_table = {}
+
+    if hash && (hash.is_a? Hash)
+      hash.each do |k,v|
+
+        if v.is_a?(Array)
+          other = Array.new
+          v.each do |entry|
+            other.push((entry.is_a?(Hash) ? self.class.new(entry) : entry))
+          end
+          v = other
+        end
+
+        @table[k.to_sym] = (v.is_a?(Hash) ? self.class.new(v) : v)
+        @hash_table[k.to_sym] = v
+        new_ostruct_member(k)
+
+      end
+    end
+  end
+  
+  def set_private(private_var, value)
+    value = ContextStruct.new(value) if value.is_a? Hash
+    send(:"\##{private_var}=", value)
+  end
+  
+  def get_private(private_var)
+    send(:"\##{private_var}")
+  end
+  
+  def has_private(private_var)
+    begin
+      !(get_private private_var).nil?
+    rescue
+      false
+    end
+  end
+
+  def to_h
+    @hash_table
+  end
+
+end

data/lib/thymeleaf/dialects.rb

@@ -0,0 +1,92 @@
+
+module Thymeleaf
+
+  class Dialects
+
+    def initialize
+      clear_dialects
+    end
+
+    def add_dialect(*args)
+      key, dialect_class = * expand_key_dialect(*args)
+
+      dialect = dialect_class.new
+
+      registered_dialects[key] = dialect
+      registered_attr_processors[key] = dialect_processors(dialect)
+      registered_tag_processors[key] = dialect_tag_processors(dialect)
+    end
+    
+    def clear_dialects
+      self.registered_dialects        = {}
+      self.registered_attr_processors = {}
+      self.registered_tag_processors  = {}
+    end
+
+    def find_attr_processor(key)
+      find_processor key, dialect_attr_matchers, registered_attr_processors
+    end
+
+    def find_tag_processor(key)
+      find_processor key, dialect_tag_matchers, registered_tag_processors
+    end
+
+  private
+
+    attr_accessor :registered_dialects, :registered_attr_processors, :registered_tag_processors
+
+    def dialect_attr_matchers
+      /^data-(#{registered_dialects.keys.join("|")})-(.*)$/
+    end
+    
+    def dialect_tag_matchers
+      /^(#{registered_dialects.keys.join("|")})-(.*)$/
+    end
+
+    def null_processor
+      @null_prccesor ||= NullProcessor.new
+    end
+    
+    def expand_key_dialect(*args)
+      if args.length == 1
+        [ args[0].default_key, args[0] ]
+      elsif args.length == 2
+        args
+      else
+        raise ArgumentError
+      end
+    end
+
+    def dialect_processors(dialect)
+      dialect.processors.reduce({}) do |processors, (processor_key, processor)|
+        processors[processor_key.to_s] = processor.new
+        processors
+      end
+    end
+
+    def dialect_tag_processors(dialect)
+      dialect.tag_processors.reduce({}) do |processors, (processor_key, processor)|
+        processors[processor_key.to_s] = processor.new
+        processors
+      end
+    end
+    
+    def find_processor(key, dialect_matchers, processor_list)
+      match = dialect_matchers.match(key)
+
+      # TODO: check performance null object vs null check
+      return [key, null_processor] if match.nil?
+
+      dialect_key, processor_key = *match[1..2]
+
+      dialect_processors = processor_list[dialect_key]
+      raise ArgumentError, "No dialect found for key #{key}" if dialect_processors.nil?
+
+      processor = dialect_processors[processor_key] || dialect_processors['default']
+      raise ArgumentError, "No processor found for key #{key}" if processor.nil?
+
+      [processor_key, processor]
+    end
+  end
+
+end

data/lib/thymeleaf/dialects/default/default_dialect.rb

@@ -0,0 +1,66 @@
+
+require_relative '../../processor'
+require_relative '../../template_engine'
+
+require_relative '../dialect'
+
+class DefaultDialect < Dialect
+  
+  CONTEXT_SWITCH_VAR   = 'switch_var'
+  CONTEXT_FRAGMENT_VAR = 'fragment_var'
+  CONTEXT_OBJECT_VAR   = 'context_obj'
+
+  def self.default_key
+    'th'
+  end
+  
+  def self.context_fragment_var(var_name)
+    "#{CONTEXT_FRAGMENT_VAR}_#{var_name}"
+  end
+  
+  def tag_processors
+    {
+        block: BlockProcessor
+    }
+  end
+
+  # Precedence based on order for the time being
+  def processors
+    {
+        insert:   InsertProcessor,
+        replace:  ReplaceProcessor,
+        fragment: FragmentProcessor,
+        each:     EachProcessor,
+        if:       IfProcessor,
+        unless:   UnlessProcessor,
+        switch:   SwitchProcessor,
+        case:     CaseProcessor,
+        object:   ObjectProcessor,
+        text:     TextProcessor,
+        utext:    UTextProcessor,
+        remove:   RemoveProcessor,
+        default:  DefaultProcessor
+    }
+  end
+
+  require_relative 'parsers/eval'
+  require_relative 'parsers/selection'
+  require_relative 'parsers/each'
+  require_relative 'parsers/fragment'
+
+  require_relative 'processors/default'
+  require_relative 'processors/object'
+  require_relative 'processors/text'
+  require_relative 'processors/utext'
+  require_relative 'processors/if'
+  require_relative 'processors/unless'
+  require_relative 'processors/switch'
+  require_relative 'processors/case'
+  require_relative 'processors/each'
+  require_relative 'processors/remove'
+  require_relative 'processors/insert'
+  require_relative 'processors/replace'
+  require_relative 'processors/block'
+  require_relative 'processors/fragment'
+
+end

data/lib/thymeleaf/dialects/default/parsers/dollar.rb

@@ -0,0 +1,12 @@
+
+class DollarExpression
+  def self.parse(context, expr, mode = nil, **args)
+    expr.gsub(/(\${.+?})/) do |match|
+      conv = ContextEvaluator.new(context).evaluate(match[2..-2])
+      if mode.eql? :single_expression
+        return conv
+      end
+      conv
+    end
+  end
+end

data/lib/thymeleaf/dialects/default/parsers/each.rb

@@ -0,0 +1,12 @@
+# Matches:
+# "item, stat : ${iterator}",
+# "item : ${iterator}" or
+# "${iterator}"
+class EachExpression
+  
+  def self.parse(context, expr, **args)
+    md = expr.match(/\s*(?:([^\n,]+?)\s*(?:,\s*([^\n,]*?))?\s*:\s*)?\${(.+?)}/)
+    raise ArgumentError, "Not a valid each expression" if md.nil?
+    md[1..3]
+  end
+end

data/lib/thymeleaf/dialects/default/parsers/eval.rb

@@ -0,0 +1,15 @@
+
+require_relative 'selection'
+require_relative 'dollar'
+
+class EvalExpression
+  
+  def self.parse(context, expr, mode = nil, **_)
+    text = SelectionExpression.parse(context, expr, context.get_private(DefaultDialect::CONTEXT_OBJECT_VAR))
+    DollarExpression.parse(context, text, mode)
+  end
+  
+  def self.parse_single_expression(context, expr, **_)
+    self.parse(context, expr, :single_expression)
+  end
+end

data/lib/thymeleaf/dialects/default/parsers/fragment.rb

@@ -0,0 +1,7 @@
+class FragmentExpression
+  def self.parse(context, expr, **args)
+    md = expr.match(/\s*(?:([^\n:]+)\s*)?(?:::([^\n]+))?\s*/)
+    raise ArgumentError, "Not a valid include expression" if md.nil?
+    md[1..2]
+  end
+end

data/lib/thymeleaf/dialects/default/parsers/selection.rb

@@ -0,0 +1,15 @@
+
+class SelectionExpression
+  
+  # Parse asterisk *{...} syntax (object selection)
+  def self.parse(context, expr, obj_var, **args)
+    expr.gsub(/(\*{.+?})/) do |match|
+      if obj_var.nil?
+        "${#{match[2..-2]}}"
+      else
+        ContextEvaluator.new(ContextHolder.new obj_var).evaluate(match[2..-2])
+      end
+    end
+  end
+  
+end

data/lib/thymeleaf/dialects/default/processors/block.rb

@@ -0,0 +1,13 @@
+
+class BlockProcessor
+
+  include Thymeleaf::Processor
+  
+  def call(node:nil, context:nil, **_)
+    node.children.reverse.each do |child|
+      subprocess_node(context, child)
+      node.add_next_sibling child
+    end
+    node.unlink
+  end
+end

data/lib/thymeleaf/dialects/default/processors/case.rb

@@ -0,0 +1,23 @@
+
+class CaseProcessor
+  include Thymeleaf::Processor
+
+  def call(node:nil, attribute:nil, context:nil, **_)
+    attribute.unlink
+    
+    var_cmp = EvalExpression.parse(context, attribute.value)
+
+    unless case_equals? context, var_cmp
+      node.children.each { |child| child.unlink }
+      node.unlink
+    end
+    
+  end
+  
+  def case_equals?(context, var_comparation)
+    (context.has_private DefaultDialect::CONTEXT_SWITCH_VAR) &&
+        (context.get_private DefaultDialect::CONTEXT_SWITCH_VAR).eql?(var_comparation)
+  end
+  
+  
+end

data/lib/thymeleaf/dialects/default/processors/default.rb

@@ -0,0 +1,8 @@
+class DefaultProcessor
+  include Thymeleaf::Processor
+
+  def call(key:nil, node:nil, attribute:nil, context:nil)
+    node[key] = [node[key], EvalExpression.parse(context, attribute.value)].compact.join(' ')
+    attribute.unlink
+  end
+end

data/lib/thymeleaf/dialects/default/processors/each.rb

@@ -0,0 +1,67 @@
+class EachProcessor
+  
+  include Thymeleaf::Processor
+  require_relative '../parsers/each'
+
+  def call(node:nil, attribute:nil, context:nil, **_)
+    variable, stat, enumerable = EachExpression.parse(context, attribute.value)
+    
+    elements = evaluate_in_context(context, enumerable)
+    
+    stat_var = init_stat_var(stat, elements)
+
+
+    attribute.unlink
+    
+    elements.each do |element|
+      subcontext_vars = {}
+      subcontext_vars[variable] = element unless variable.nil?
+
+      unless stat.nil?
+        stat_var[:index]  += 1
+        stat_var[:count]  += 1
+        stat_var[:current] = element
+        stat_var[:even]    = stat_var[:count].even?
+        stat_var[:odd]     = stat_var[:count].odd?
+        stat_var[:first]   = (stat_var[:index].eql? 0)
+        stat_var[:last]    = (stat_var[:count].eql? stat_var[:size])
+
+        subcontext_vars[stat] = stat_var
+      end
+      
+      subcontext = ContextHolder.new(subcontext_vars, context)
+      new_node = node.dup
+      subprocess_node(subcontext, new_node)
+      node.add_previous_sibling(new_node)
+    end
+
+    node.children.each {|child| child.unlink }
+    node.unlink
+    
+    context # TODO: Remove
+  end
+  
+  def has_subcontext?
+    true
+  end
+
+private
+
+  def init_stat_var(stat, elements)
+    if stat.nil?
+      nil
+    else
+      {
+          :index    => -1,
+          :count    => 0,
+          :size     => elements.length,
+          :current  => nil,
+          :even     => false,
+          :odd      => true,
+          :first    => true,
+          :last     => false
+      }
+    end
+  end
+  
+end

data/lib/thymeleaf/dialects/default/processors/fragment.rb

@@ -0,0 +1,12 @@
+class FragmentProcessor
+  include Thymeleaf::Processor
+
+  def call(node:nil, attribute:nil, context:nil, **_)
+    fragment_name = EvalExpression.parse(context, attribute.value)
+    
+    context.root.set_private DefaultDialect::context_fragment_var(fragment_name), node
+
+    attribute.unlink
+  end
+
+end

data/lib/thymeleaf/dialects/default/processors/if.rb

@@ -0,0 +1,14 @@
+require_relative '../../../utils/booleanize'
+
+class IfProcessor
+
+  include Thymeleaf::Processor
+
+  def call(node:nil, attribute:nil, context:nil, **_)
+    attribute.unlink
+    unless booleanize EvalExpression.parse(context, attribute.value)
+      node.children.each {|child| child.unlink }
+      node.unlink
+    end
+  end
+end

data/lib/thymeleaf/dialects/default/processors/insert.rb

@@ -0,0 +1,65 @@
+
+class InsertProcessor
+
+  include Thymeleaf::Processor
+  
+  require_relative '../parsers/fragment'
+
+  def call(node:nil, attribute:nil, context:nil, **_)
+    attribute.unlink
+
+    template, fragment = FragmentExpression.parse(context, attribute.value)
+    
+    node_subcontent = get_node_template(template, node, context)
+
+    node.children.each {|child| child.unlink }
+    
+    if fragment.nil?
+      # Avoid infinite loop when template is "this" and fragment is nil
+      return nil if is_self_template? template
+    else
+      node_subcontent = get_fragment_node(fragment, context, node_subcontent)
+    end
+
+    unless node_subcontent.nil?
+      node_subcontent.dup.parent = node
+    end
+  end
+
+
+private
+  
+  def get_node_template(template, node, context)
+    if is_self_template? template
+      root_node node
+    else
+      subtemplate = EvalExpression.parse(context, template)
+
+      load_template subtemplate do |template_file|
+        Thymeleaf::Parser.new(template_file).call
+      end
+    end
+  end
+  
+  def root_node(node)
+    new_node = node
+    until new_node.parent.nil?
+      new_node = new_node.parent
+    end
+    new_node
+  end
+  
+  def is_self_template?(template)
+    template.nil? || (template.eql? 'this')
+  end
+  
+  def get_fragment_node(fragment_name, context, node)
+    root_context = context.root
+    
+    if root_context.has_private DefaultDialect::context_fragment_var(fragment_name)
+      root_context.get_private DefaultDialect::context_fragment_var(fragment_name)
+    else
+      node.at_css fragment_name
+    end
+  end
+end

data/lib/thymeleaf/dialects/default/processors/object.rb

@@ -0,0 +1,21 @@
+require_relative '../../../utils/booleanize'
+
+class ObjectProcessor
+
+  include Thymeleaf::Processor
+
+  def call(attribute:nil, context:nil, **_)
+    attribute.unlink
+
+    obj_var = EvalExpression.parse_single_expression(context, attribute.value)
+    new_context = ContextHolder.new({}, context)
+    new_context.set_private(DefaultDialect::CONTEXT_OBJECT_VAR, obj_var)
+
+    attribute.unlink
+    new_context
+  end
+
+  def has_subcontext?
+    true
+  end
+end

data/lib/thymeleaf/dialects/default/processors/remove.rb

@@ -0,0 +1,85 @@
+require_relative '../../../utils/booleanize'
+
+class RemoveProcessor
+
+  include Thymeleaf::Processor
+  
+  REMOVE_ALL           = 'all'
+  REMOVE_BODY          = 'body'
+  REMOVE_TAG           = 'tag'
+  REMOVE_ALL_BUT_FIRST = 'all-but-first'
+  REMOVE_NONE          = 'none'
+
+  def call(node:nil, attribute:nil, context:nil, **_)
+    attribute.unlink
+    
+    expr = EvalExpression.parse(context, attribute.value)
+    
+    method = case expr
+               when REMOVE_ALL
+                 :remove_all
+               when REMOVE_BODY
+                 :remove_body
+               when REMOVE_TAG
+                 :remove_tag
+               when REMOVE_ALL_BUT_FIRST
+                 :remove_allbutfirst
+               when REMOVE_NONE
+                 :remove_none
+               else
+                 if booleanize expr
+                   :remove_all
+                 else
+                   :remove_none
+                 end
+               end
+    
+    send(method, node, context)
+  end
+  
+private
+  def remove_all(node, _)
+    node.children.each do |child|
+      child.unlink
+    end
+    node.unlink
+  end
+  
+  def remove_body(node, _)
+    node.children.each do |child|
+      child.unlink
+    end
+  end
+  
+  def remove_tag(node, context)
+    node.children.reverse.each do |child|
+      subprocess_node(context, child)
+      node.add_next_sibling child
+    end
+    node.unlink
+  end
+  
+  def remove_allbutfirst(node, _)
+    skip_first(node.children) do |child|
+      child.unlink
+    end
+  end
+  
+  def remove_none(_, _)
+  end
+  
+  def empty_node?(node)
+    node.to_s.strip.empty?
+  end
+  
+  def skip_first(node_set)
+    i = 0
+    node_set.each do |child|
+      if i > 0
+        yield child
+      else
+        i += 1 unless empty_node? child
+      end
+    end
+  end
+end

data/lib/thymeleaf/dialects/default/processors/replace.rb

@@ -0,0 +1,33 @@
+
+require_relative 'insert'
+
+class ReplaceProcessor < InsertProcessor
+
+  include Thymeleaf::Processor
+
+  def call(node:nil, attribute:nil, context:nil, **_)
+
+    attribute.unlink
+
+    template, fragment = FragmentExpression.parse(context, attribute.value)
+
+    node_subcontent = get_node_template(template, node, context)
+
+    node.children.each {|child| child.unlink }
+
+    if fragment.nil?
+      # Avoid infinite loop when template is "this" and fragment is nil
+      return nil if is_self_template? template
+    else
+      node_subcontent = get_fragment_node(fragment, context, node_subcontent)
+    end
+
+    unless node_subcontent.nil?
+      node_subcontent = node_subcontent.dup
+      subprocess_node(context, node_subcontent)
+
+      node.replace node_subcontent
+    end
+  end
+  
+end

data/lib/thymeleaf/dialects/default/processors/switch.rb

@@ -0,0 +1,17 @@
+class SwitchProcessor
+  include Thymeleaf::Processor
+
+  def call(attribute:nil, context:nil, **_)
+    condition = EvalExpression.parse(context, attribute.value)
+    new_context = ContextHolder.new({}, context)
+    new_context.set_private DefaultDialect::CONTEXT_SWITCH_VAR, condition
+
+    attribute.unlink
+    new_context
+  end
+  
+  def has_subcontext?
+    true
+  end
+
+end

data/lib/thymeleaf/dialects/default/processors/text.rb

@@ -0,0 +1,9 @@
+
+class TextProcessor
+  include Thymeleaf::Processor
+
+  def call(node:nil, attribute:nil, context:nil, **_)
+    node.content = EvalExpression.parse(context, attribute.value)
+    attribute.unlink
+  end
+end

data/lib/thymeleaf/dialects/default/processors/unless.rb

@@ -0,0 +1,13 @@
+require_relative '../../../utils/booleanize'
+
+class UnlessProcessor
+  include Thymeleaf::Processor
+
+  def call(node:nil, attribute:nil, context:nil, **_)
+    attribute.unlink
+    if booleanize EvalExpression.parse(context, attribute.value)
+      node.children.each {|child| child.unlink }
+      node.unlink
+    end
+  end
+end

data/lib/thymeleaf/dialects/default/processors/utext.rb

@@ -0,0 +1,8 @@
+class UTextProcessor
+  include Thymeleaf::Processor
+
+  def call(node:nil, attribute:nil, context:nil, **_)
+    node.inner_html = EvalExpression.parse(context, attribute.value)
+    attribute.unlink
+  end
+end

data/lib/thymeleaf/dialects/dialect.rb

@@ -0,0 +1,18 @@
+
+class Dialect
+
+  def self.default_key
+    nil
+  end
+
+  # Precedence based on order
+  def tag_processors
+    {}
+  end
+
+  # Precedence based on order
+  def processors
+    {}
+  end
+
+end

data/lib/thymeleaf/parser.rb

@@ -0,0 +1,12 @@
+
+require 'nokogiri'
+
+module Thymeleaf
+
+  class Parser < Struct.new(:template_markup)
+    def call
+      Nokogiri::HTML::fragment(template_markup, Thymeleaf.configuration.parser.encoding)
+    end
+  end
+
+end

data/lib/thymeleaf/parser/parse_options.rb

@@ -0,0 +1,12 @@
+
+require 'nokogiri'
+
+class ParseOptions
+  
+  attr_accessor :encoding
+  
+  def initialize
+    self.encoding = nil
+  end
+  
+end

data/lib/thymeleaf/processor.rb

@@ -0,0 +1,33 @@
+
+module Thymeleaf
+
+  module Processor
+    
+    require_relative 'processor/context_evaluator'
+
+    def evaluate_in_context(context, expr)
+      ContextEvaluator.new(context).evaluate(expr)
+    end
+    
+    def subprocess_node(context, node)
+      processor = Thymeleaf::TemplateEngine.new
+      processor.send(:process_node, context, node)
+    end
+
+    def load_template(template_name)
+      template_uri = Thymeleaf.configuration.template_uri(template_name)
+
+      File.open template_uri do |template_file|
+        template_file.rewind
+        yield template_file.read
+      end
+    end
+    
+  end
+
+  class NullProcessor
+    def call(**_)
+    end
+  end
+
+end

data/lib/thymeleaf/processor/context_evaluator.rb

@@ -0,0 +1,13 @@
+
+class ContextEvaluator
+  def initialize(context)
+    self.context = context
+  end
+
+  def evaluate(expr)
+    context.evaluate(expr)
+  end
+
+private
+  attr_accessor :context
+end

data/lib/thymeleaf/template.rb

@@ -0,0 +1,35 @@
+
+require_relative 'processor'
+
+module Thymeleaf
+  
+  require_relative 'context/context_holder'
+
+  class Template < Struct.new(:template_markup, :context)
+    def render
+      do_render template_markup
+    end
+    
+    def render_file
+      template_markup_uri = Thymeleaf.configuration.template_uri(template_markup)
+      
+      template_file_open template_markup_uri do |template|
+        do_render template
+      end
+    end
+  
+  private
+    def do_render(template)
+      parsed_template = Parser.new(template).call
+      context_holder = ContextHolder.new(context)
+      TemplateEngine.new.call(parsed_template, context_holder).to_s
+    end
+    
+    def template_file_open(template_file)
+      File.open template_file do |template|
+        template.rewind
+        yield template.read
+      end
+    end
+  end
+end

data/lib/thymeleaf/template/template_resolver.rb

@@ -0,0 +1,15 @@
+
+class TemplateResolver
+  
+  attr_accessor :prefix, :suffix
+  
+  def initialize
+    self.prefix = ''
+    self.suffix = ''
+  end
+  
+  def get_template(template_name)
+    "#{self.prefix}#{template_name}#{self.suffix}"
+  end
+  
+end

data/lib/thymeleaf/template_engine.rb

@@ -0,0 +1,56 @@
+
+module Thymeleaf
+
+  class TemplateEngine
+    def call(parsed_template, context_holder)
+      process_node(context_holder, parsed_template)
+      parsed_template
+    end
+
+  private
+    def process_node(context_holder, node)
+      attr_context = process_attributes(context_holder, node)
+      children_context = process_tag(attr_context, node)
+      
+      # TODO: Processing all nodes. Maybe filtering by only-thymeleaf nodes can give better performance?
+      node.children.each {|child| process_node(children_context, child)}
+    end
+
+    def process_attributes(context_holder, node)
+      attr_context = context_holder
+      node.attributes.each do |attribute_key, attribute|
+        attr_context = process_attribute(attr_context, node, attribute_key, attribute)
+      end
+      attr_context
+    end
+
+    def process_attribute(context_holder, node, attribute_key, attribute)
+      # TODO: Find all proccessors. Apply in precedence order!
+      dialects = Thymeleaf.configuration.dialects
+      key, processor = * dialects.find_attr_processor(attribute_key)
+      
+      process_element(context_holder, node, attribute, key, processor)
+    end
+    
+    def process_tag(context_holder, node)
+      dialects = Thymeleaf.configuration.dialects
+      key, processor = * dialects.find_tag_processor(node.name)
+
+      process_element(context_holder, node, nil, key, processor)
+    end
+    
+    def processor_has_subcontext?(processor)
+      processor.respond_to?(:has_subcontext?) && processor.has_subcontext?
+    end
+    
+    def process_element(context_holder, node, attribute, key, processor)
+      subcontext = processor.call(key: key, node: node, attribute: attribute, context: context_holder)
+
+      if processor_has_subcontext?(processor)
+        subcontext
+      else
+        context_holder
+      end
+    end
+  end
+end

data/lib/thymeleaf/utils/booleanize.rb

@@ -0,0 +1,4 @@
+
+def booleanize(str)
+    !(str.strip =~ /^(false|f|no|n|0|-0|nil)$/i)
+end

data/lib/thymeleaf/version.rb

@@ -0,0 +1,3 @@
+module Thymeleaf
+  VERSION = "0.1.0"
+end

metadata

@@ -0,0 +1,192 @@
+--- !ruby/object:Gem::Specification
+name: thymeleaf
+version: !ruby/object:Gem::Version
+  version: 0.1.0
+platform: ruby
+authors:
+- David Barral Precedo
+- Daniel Vazquez Brañas
+autorequire: 
+bindir: bin
+cert_chain: []
+date: 2016-09-09 00:00:00.000000000 Z
+dependencies:
+- !ruby/object:Gem::Dependency
+  name: nokogiri
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - ">="
+      - !ruby/object:Gem::Version
+        version: '0'
+  type: :runtime
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - ">="
+      - !ruby/object:Gem::Version
+        version: '0'
+- !ruby/object:Gem::Dependency
+  name: bundler
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: '1.10'
+  type: :development
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: '1.10'
+- !ruby/object:Gem::Dependency
+  name: rake
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: '10.0'
+  type: :development
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: '10.0'
+- !ruby/object:Gem::Dependency
+  name: minitest
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - ">="
+      - !ruby/object:Gem::Version
+        version: '0'
+  type: :development
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - ">="
+      - !ruby/object:Gem::Version
+        version: '0'
+- !ruby/object:Gem::Dependency
+  name: awesome_print
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - ">="
+      - !ruby/object:Gem::Version
+        version: '0'
+  type: :development
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - ">="
+      - !ruby/object:Gem::Version
+        version: '0'
+- !ruby/object:Gem::Dependency
+  name: benchmark-ips
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: '2.6'
+  type: :development
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: '2.6'
+- !ruby/object:Gem::Dependency
+  name: webrick
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - ">="
+      - !ruby/object:Gem::Version
+        version: '0'
+  type: :development
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - ">="
+      - !ruby/object:Gem::Version
+        version: '0'
+- !ruby/object:Gem::Dependency
+  name: json
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - ">="
+      - !ruby/object:Gem::Version
+        version: '0'
+  type: :development
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - ">="
+      - !ruby/object:Gem::Version
+        version: '0'
+description: Thymeleaf template engine for Ruby
+email:
+- contact@trabesoluciones.com
+- david.barral@trabesoluciones.com
+executables: []
+extensions: []
+extra_rdoc_files: []
+files:
+- lib/thymeleaf/configuration.rb
+- lib/thymeleaf/context/context_holder.rb
+- lib/thymeleaf/context/context_struct.rb
+- lib/thymeleaf/dialects.rb
+- lib/thymeleaf/dialects/default/default_dialect.rb
+- lib/thymeleaf/dialects/default/parsers/dollar.rb
+- lib/thymeleaf/dialects/default/parsers/each.rb
+- lib/thymeleaf/dialects/default/parsers/eval.rb
+- lib/thymeleaf/dialects/default/parsers/fragment.rb
+- lib/thymeleaf/dialects/default/parsers/selection.rb
+- lib/thymeleaf/dialects/default/processors/block.rb
+- lib/thymeleaf/dialects/default/processors/case.rb
+- lib/thymeleaf/dialects/default/processors/default.rb
+- lib/thymeleaf/dialects/default/processors/each.rb
+- lib/thymeleaf/dialects/default/processors/fragment.rb
+- lib/thymeleaf/dialects/default/processors/if.rb
+- lib/thymeleaf/dialects/default/processors/insert.rb
+- lib/thymeleaf/dialects/default/processors/object.rb
+- lib/thymeleaf/dialects/default/processors/remove.rb
+- lib/thymeleaf/dialects/default/processors/replace.rb
+- lib/thymeleaf/dialects/default/processors/switch.rb
+- lib/thymeleaf/dialects/default/processors/text.rb
+- lib/thymeleaf/dialects/default/processors/unless.rb
+- lib/thymeleaf/dialects/default/processors/utext.rb
+- lib/thymeleaf/dialects/dialect.rb
+- lib/thymeleaf/parser.rb
+- lib/thymeleaf/parser/parse_options.rb
+- lib/thymeleaf/processor.rb
+- lib/thymeleaf/processor/context_evaluator.rb
+- lib/thymeleaf/template.rb
+- lib/thymeleaf/template/template_resolver.rb
+- lib/thymeleaf/template_engine.rb
+- lib/thymeleaf/utils/booleanize.rb
+- lib/thymeleaf/version.rb
+homepage: https://trabe.github.io/thymeleaf-rb
+licenses:
+- MIT
+metadata: {}
+post_install_message: 
+rdoc_options: []
+require_paths:
+- lib
+required_ruby_version: !ruby/object:Gem::Requirement
+  requirements:
+  - - "~>"
+    - !ruby/object:Gem::Version
+      version: 2.3.0
+required_rubygems_version: !ruby/object:Gem::Requirement
+  requirements:
+  - - ">="
+    - !ruby/object:Gem::Version
+      version: '0'
+requirements: []
+rubyforge_project: 
+rubygems_version: 2.4.5.1
+signing_key: 
+specification_version: 4
+summary: Thymeleaf for Ruby
+test_files: []