tzispa_rig 0.2.3

checksums.yaml

@@ -0,0 +1,7 @@
+---
+SHA1:
+  metadata.gz: c00ae9acd7890ced20f0f74e4c54143d458f0907
+  data.tar.gz: 905759eff704cabd933220611ddeaa6b46cc29f4
+SHA512:
+  metadata.gz: defca0f436d1495db948ba55eb11c0ba10fae686ac0f222daaf2abe581b384df0a3c1d40da525c4d0acbf930a306fb4113d2dc33872524b4a98e30df33a0c421
+  data.tar.gz: abee73f6183769d5591560d1e2a5dbf1b0d877b4184771237505cfaa2b9ff14ffe5a7d368d4b2259d480d7bd97c1a1f89bcdaebd389c16a58678c6488011ba5a

data/CHANGELOG.md

@@ -0,0 +1,24 @@
+Tzispa Rig
+
+Rig templates implementation
+
+## v0.2.3
+- Fix in the api call regex syntax
+- Added prefix in api calls
+
+## v0.2.2
+- Bug fix in iblk render
+- Remake of the Binder class defining two specialized classes: TemplateBinder and LoopBinder
+- Bug fix and improvements in the statements parser
+- Bug fix in the loop_binder method not allowing 2 loops with equal ids at the same level
+
+## v0.2.1
+- Regexp optimizations
+- Some classes has been renamed for better code readability
+
+## v0.2.0
+- Implemented new parser to break away parsing and rendering
+- Implemented template caching class 'Engine' with on demand parsing: a block template is parsed only when if it's new or if it has been modified
+
+## v0.1.0
+- Initial release: code moved from tzispa main gem

data/README.md

@@ -0,0 +1,3 @@
+Txispa Rig
+
+General purpose template engine

data/lib/tzispa/rig/binder.rb

@@ -0,0 +1,104 @@
+# frozen_string_literal: true
+
+require 'forwardable'
+require 'tzispa/rig'
+
+module Tzispa
+  module Rig
+
+
+    class Binder
+      extend Forwardable
+
+      attr_reader :context, :dataStruct, :parser
+      def_delegators :@parser, :attribute_tags
+      def_delegators :@context, :app, :request, :response
+
+
+      def initialize(parser, context)
+        @parser = parser
+        @context = context
+        @dataStruct = attribute_tags.count > 0 ? Struct.new(*attribute_tags) : Struct.new(nil)
+      end
+
+      def loop_binder(loop_id)
+        loop_parser = @parser.loop_parser loop_id
+        raise ArgumentError.new("#{self.class}:: there isn't any loop tagged '#{loop_id}'") unless loop_parser && loop_parser.count > 0
+        raise ArgumentError.new("#{self.class}:: there are #{loop_parser.count} loops tagged '#{loop_id}' at the same level: only one allowed") unless loop_parser.count == 1
+        LoopBinder.new loop_parser[0], @context
+      end
+
+    end
+
+
+    class TemplateBinder < Binder
+      extend Forwardable
+
+      attr_reader :template
+      def_delegators :@template, :params
+
+
+      def initialize(template, context)
+        super(template.parser, context)
+        @template = template
+      end
+
+      def data(**params)
+        (@data ||= @dataStruct.new).tap { |d|
+          params.each{ |k,v|
+            d[k] = v
+          }
+        }
+      end
+
+      def self.for(template, context)
+        if template.is_block?
+          binder_class = template.binder_class
+          binder_class.new( template, context ) if binder_class
+        else
+          self.new(template, context)
+        end
+      end
+
+    end
+
+
+    class LoopBinder < Binder
+
+      attr_reader :data
+
+      def bind!(&generator)
+        @source_object = eval "self", generator.binding
+        @data = instance_eval(&generator).to_enum(:each)
+        self
+      end
+
+      def method_missing(method, *args, &generator)
+        @source_object.send method, *args, &generator
+      end
+
+      def loop_item(**params)
+        (LoopItem.new self).tap { |item|
+          params.each{ |k,v|
+            item.data[k] = v
+          }
+        }
+      end
+
+    end
+
+
+    class LoopItem
+
+      attr_reader :context, :data
+
+      def initialize(binder)
+        @context = binder.context
+        @data = binder.dataStruct.new
+      end
+
+    end
+
+
+  end
+end

data/lib/tzispa/rig/parameters.rb

@@ -0,0 +1,56 @@
+# frozen_string_literal: true
+
+module Tzispa
+  module Rig
+    class Parameters
+
+
+      attr_reader :inner
+      attr_reader :outer
+      attr_reader :data
+
+
+      def initialize(params=nil, iouter=',', iinner='=')
+        @data = Hash.new
+        @outer = iouter
+        @inner = iinner
+        setData(params) if params
+      end
+
+      def set(key,value)
+        @data[key.to_sym] = value
+      end
+
+      def get(key)
+        @data[key.to_sym]
+      end
+
+      def [](key)
+        @data[key.to_sym]
+      end
+
+      def has?(key)
+        @data.key?(key.to_sym)
+      end
+
+      def to_s
+        @data.map { |k,v| "#{k}#{inner}#{v}" }.join(outer)
+      end
+
+      def merge(params)
+        setData(params)
+      end
+
+      private
+
+      def setData(params)
+        params.split(outer).each do |param|
+          key,value = param.split(inner)
+          @data[key.to_sym] = value
+        end
+      end
+
+
+    end
+  end
+end

data/lib/tzispa/rig/parser.rb

@@ -0,0 +1,165 @@
+# frozen_string_literal: true
+
+require 'tzispa/rig/engine'
+require 'tzispa/rig/formatter'
+require 'tzispa/helpers/security'
+
+module Tzispa
+  module Rig
+    class Parser
+
+      include Tzispa::Helpers::Security
+
+      EMPTY_STRING = ''.freeze
+
+      attr_reader :text
+
+      RIG_SYNTAX = {
+        :re_flags   => /<flags:(\[(\w+=[^,\]]+(,\w+=[^,\]]+)*?)\])\/>/.freeze,
+        :blk        => /<(blk):(\w+(?:\.\w+)?)(?:\[(\w+=[^,\]]+(?:,\w+=[^,\]]+)*)\])?\/>/.freeze,
+        :iblk       => /<(iblk):(\w+):(\w+(?:\.\w+)?)(?:\[(\w+=[^,\]]+(?:,\w+=[^,\]]+)*)\])?:(\w+(?:\.\w+)?)(?:\[(\w+=[^,\]]+(?:,\w+=[^,\]]+)*)\])?\/>/.freeze,
+        :static     => /<(static):(\w+(?:\.\w+)?)(?:\[(\w+=[^,\]]+(?:,\w+=[^,\]]+)*)\])?\/>/.freeze,
+        :re_var     => /<var(\[%[A-Z]?[0-9]*[a-z]\])?:(\w+)\/>/.freeze,
+        :re_metavar => /\{%([^%]+?)%\}/.freeze,
+        :re_loop    => /<loop:(\w+)>(.*?)<\/loop:\1>/m.freeze,
+        :re_ife     => /<ife:(\w+)>(.*?)(<else:\1\/>(.*?))?<\/ife:\1>/m.freeze,
+        :re_purl    => /<purl:(\w+)(\[(\w+=[^,\]]+(,\w+=[^,\]]+)*?)\])?\/>/.freeze,
+        :re_api     => /<api:(\w+(?:\.\w+)?):(\w+)(?::([^:]+))?(?::([^\/]+))?\/>/.freeze
+      }
+
+      def initialize(engine, binder=nil, text=nil)
+        @engine = engine
+        @binder = binder || engine.binder
+        @context = engine.context
+        @text = text
+      end
+
+      def parse!
+        @text ||= @engine.content
+        @binder.bind! if @binder && @binder.respond_to?( :bind! )
+        if @engine.type == :block
+          parseStatement
+          parseExpression
+        end
+        parseBlock
+        self
+      end
+
+
+    private
+
+      def parseExpression
+        parseMetavar
+        parseVar
+        parsePurl
+        parseAPI
+      end
+
+      def parseStatement
+        parseLoop
+        parseIfe
+      end
+
+      def parseFlags
+        @text.gsub!(RIG_SYNTAX[:re_flags]) { |match|
+          flags = Regexp.last_match(1)
+          @engine.flags = flags
+          EMPTY_STRING
+        }
+      end
+
+      def parseLoop
+        @text.gsub!(RIG_SYNTAX[:re_loop]) { |match|
+          loopid = Regexp.last_match(1)
+          loopbody = Regexp.last_match(2)
+          lenrig = @binder.respond_to?("#{loopid}") ? @binder.send("#{loopid}") : []
+          lenrig.respond_to?(:map) ? lenrig.map { |item| Parser.new(@engine, item, loopbody.dup).parse!.text }.join : String.new.freeze
+        }
+      end
+
+      def parseIfe
+        @text.gsub!(RIG_SYNTAX[:re_ife]) { |match|
+          ifetest = Regexp.last_match(1)
+          test = @binder.respond_to?("#{ifetest}") ? @binder.send("#{ifetest}") : false
+          ifebody = Regexp.last_match(2)
+          elsebody = Regexp.last_match(4)
+          Parser.new(@engine, @binder, test ? "#{ifebody}" : "#{elsebody}").parse!.text
+        }
+      end
+
+      def parseMetavar
+        @text.gsub!(RIG_SYNTAX[:re_metavar]) { |match|
+          varid = Regexp.last_match(1)
+          if @context.respond_to?(varid)
+            @context.send(varid)
+          elsif !@context.env.nil? and !@context.env[varid].nil?
+            @context.env[varid]
+          elsif @binder.respond_to?(varid)
+            @binder.send(varid)
+          else
+            Formatter.unknown(varid)
+          end
+        }
+      end
+
+      def parseVar
+        @text.gsub!(RIG_SYNTAX[:re_var]) { |match|
+          fmt = Regexp.last_match(1)
+          varid = Regexp.last_match(2)
+          value = @binder.respond_to?(varid) ? @binder.send(varid) : Formatter.unknown(varid)
+          Formatter.rigvar(value, fmt)
+        }
+      end
+
+      def parsePurl
+        @text.gsub!(RIG_SYNTAX[:re_purl]) { |match|
+          urlid = Regexp.last_match[1]
+          urlparams = Parameters.new(Regexp.last_match[3])
+          @engine.app.router_path urlid.to_sym, urlparams.data
+        }
+      end
+
+      def parseAPI
+        @text.gsub!(RIG_SYNTAX[:re_api]) { |match|
+          handler, verb, predicate, sufix = Regexp.last_match[1], Regexp.last_match[2], Regexp.last_match[3], Regexp.last_match[4]
+          sign = Parser.sign_array [handler, verb, predicate], @engine.app.config.salt
+          @engine.app.router_path :api, {handler: handler, verb: verb, predicate: predicate, sign: sign, sufix: sufix}
+        }
+      end
+
+      def parseBlock
+        reBlocks = Regexp.new(RIG_SYNTAX[:re_blk].to_s + '|' + RIG_SYNTAX[:re_iblk].to_s + '|' + RIG_SYNTAX[:re_static].to_s)
+
+        @text.gsub!(reBlocks) {
+          strtype = (Regexp.last_match[2] || '') << (Regexp.last_match[7] || '') << (Regexp.last_match[16] || '')
+          case strtype
+            when 'blk'
+              rigtype = :block
+              rigname = Regexp.last_match[3]
+              rigparams = Regexp.last_match[5]
+            when 'iblk'
+              rigtype = :block
+              rigtest = Regexp.last_match[8]
+              if (@binder.respond_to?("#{rigtest}?") ? @binder.send("#{rigtest}?") : false)
+                rigname = Regexp.last_match[9]
+                rigparams = Regexp.last_match[11]
+              else
+                rigname = Regexp.last_match[12]
+                rigparams = Regexp.last_match[14]
+              end
+            when 'static'
+              rigtype = :static
+              rigname = Regexp.last_match[17]
+              rigparams = Regexp.last_match[19]
+            else
+              raise ArgumentError.new("Unknown Rig type: #{strtype}")
+          end
+          engine = Engine.new(name: rigname, type: rigtype, parent: @engine, params: rigparams)
+          engine.render!
+          engine.text
+        }
+      end
+
+    end
+  end
+end

data/lib/tzispa/rig/parsernext.rb

@@ -0,0 +1,419 @@
+# frozen_string_literal: true
+
+require 'forwardable'
+require 'tzispa/domain'
+require 'tzispa/utils/string'
+
+
+module Tzispa
+  module Rig
+
+    class ParsedEntity
+      extend Forwardable
+
+      STRING_EMPTY = ''.freeze
+      RE_ANCHOR = /(@@\h+@@)/
+
+      attr_reader :type, :parser
+      def_delegators :@parser, :template
+
+      def initialize(parser, type)
+        @parser = parser
+        @type = type
+      end
+
+      def self.instance(parser, type, match)
+        case type
+        when :meta
+          ParsedMeta.new parser, type, match[1]
+        when :var
+          ParsedVar.new parser, type, match[1], match[2]
+        when :purl
+          ParsedUrl.new parser, type, match[1], match[3]
+        when :api
+          ParsedApi.new parser, type, match[1], match[2], match[3], match[4]
+        when :loop
+          ParsedLoop.new parser, type, match[3], match[4]
+        when :ife
+          ParsedIfe.new parser, type, match[7], match[8], match[10]
+        when :blk
+          ParsedBlock.new parser, type, match[3], match[4]
+        when :iblk
+          ParsedIBlock.new parser, type, match[7], match[8], match[9], match[10], match[11]
+        when :static
+          ParsedStatic.new parser, type, match[14], match[15]
+        end
+      end
+
+      def anchor
+        #[[object_id].pack("h*")].pack("m0")
+        @anchor ||= "@@#{"%x" % object_id}@@".freeze
+      end
+
+    end
+
+    class ParsedMeta < ParsedEntity
+
+      attr_reader :id
+
+      def initialize(parser, type, id)
+        super(parser, type)
+        @id = id.to_sym
+      end
+
+      def render(binder)
+        if binder.data.respond_to? @id
+          binder.data.send(@id).to_s
+        else
+          unknown
+        end
+      end
+
+      private
+
+      def unknown
+        @unknown ||= "#{@id}:unknown!!".freeze
+      end
+
+    end
+
+
+    class ParsedVar < ParsedEntity
+
+      attr_reader :id
+
+      def initialize(parser, type, format, id)
+        super(parser, type)
+        @format = format
+        @id = id.to_sym
+      end
+
+      def render(binder)
+        binder.data.respond_to?(@id) ? binder.data.send(@id).to_s : unknown
+      end
+
+      private
+
+      def unknown
+        @unknown ||= "#{@id}:unknown!!".freeze
+      end
+
+    end
+
+
+    class ParsedUrl < ParsedEntity
+
+      def initialize(parser, type, path_id, params)
+        super(parser, type)
+        @path_id = path_id.to_sym
+        @params = params
+      end
+
+      def render(binder)
+        b_params = @params.dup.gsub(RE_ANCHOR) { |match|
+          parser.the_parsed.select { |p| p.anchor == match}.first.render(binder)
+        } if @params
+        binder.context.path @path_id, Parameters.new(b_params).data
+      end
+
+    end
+
+
+    class ParsedApi < ParsedEntity
+
+      attr_reader :handler, :verb, :predicate
+
+      def initialize(parser, type, handler, verb, predicate, sufix)
+        super(parser, type)
+        @handler = handler
+        @verb = verb
+        @predicate = predicate
+        @sufix = sufix
+      end
+
+      def render(binder)
+        b_handler = bind_value @handler.dup, binder
+        b_verb = bind_value @verb.dup, binder
+        b_predicate = bind_value( @predicate.dup, binder ) if @predicate
+        b_sufix = bind_value( @sufix.dup, binder ) if @sufix
+        binder.context.api b_handler, b_verb, b_predicate, b_sufix
+      end
+
+      private
+
+      def bind_value(value, binder)
+        value.gsub(RE_ANCHOR) { |match|
+          parser.the_parsed.select { |p| p.anchor == match}.first.render(binder)
+        }
+      end
+
+    end
+
+
+    class ParsedLoop < ParsedEntity
+      extend Forwardable
+
+      attr_reader :id
+      def_delegators :@loop_parser, :attribute_tags, :loop_parser
+
+      def initialize(parser, type, id, body)
+        super(parser, type)
+        @id = id.to_sym
+        @body = body
+      end
+
+      def parse!
+        @loop_parser = ParserNext.new( template, @body ).parse!
+        self
+      end
+
+      def render(binder)
+        String.new.tap { |text|
+          looper = binder.data.send(@id) if binder.data.respond_to?(@id)
+          looper.data.each { |loop_item|
+            text << @loop_parser.render(loop_item) if loop_item
+          } if looper
+        }
+      end
+
+    end
+
+
+    class ParsedIfe < ParsedEntity
+
+      attr_reader :test
+
+      def initialize(parser, type, test, then_body, else_body)
+        super(parser, type)
+        @test = test.to_sym
+        @then_body = then_body
+        @else_body = else_body
+      end
+
+      def parse!
+        @then_parser = ParserNext.new( template, @then_body ).parse!
+        @else_parser = ParserNext.new( template, @else_body ).parse! if @else_body
+        self
+      end
+
+      def attribute_tags
+        @attribute_tags ||= [@test].concat(@then_parser.attribute_tags).concat((@else_parser && @else_parser.attribute_tags) || Array.new).compact.uniq.freeze
+      end
+
+      def loop_parser(id)
+        @then_parser.loop_parser(id).concat((@else_parser && @else_parser.loop_parser(id)) || Array.new).compact.freeze
+      end
+
+      def render(binder)
+        test_eval = binder.data && binder.data.respond_to?(@test) && binder.data.send(@test)
+        ifeparser = test_eval ? @then_parser : @else_parser
+        ifeparser ? ifeparser.render(binder) : STRING_EMPTY
+      end
+
+    end
+
+    class ParsedBlock < ParsedEntity
+
+      attr_reader :params
+
+      def initialize(parser, type, id, params)
+        super(parser, type)
+        @id = id
+        @params = params
+      end
+
+      def parse!
+        @parsed_block = template.engine.block name: @id, parent: template
+        self
+      end
+
+      def render(binder)
+        blk = @parsed_block.dup
+        if @params
+          b_params = @params.dup.gsub(RE_ANCHOR) { |match|
+            parser.the_parsed.select { |p| p.anchor == match}.first.render(binder)
+          }
+          blk.params = b_params
+        end
+        blk.render binder.context
+      end
+
+    end
+
+    class ParsedIBlock < ParsedEntity
+
+      attr_reader :id
+
+      def initialize(parser, type, test, id_then, params_then, id_else, params_else)
+        super(parser, type)
+        @id = test
+        @id_then = id_then
+        @params_then = params_then
+        @id_else = id_else
+        @params_else = params_else
+      end
+
+      def parse!
+        @block_then = template.engine.block name: @id_then, parent: template
+        @block_else = template.engine.block name: @id_else, parent: template
+        self
+      end
+
+      def render(binder)
+        if binder.data.respond_to?(@id) && binder.data.send(@id)
+          blk = @block_then.dup
+          if @params_then
+            b_params = @params_then.dup.gsub(RE_ANCHOR) { |match|
+              parser.the_parsed.select { |p| p.anchor == match}.first.render(binder)
+            }
+            blk.params = b_params
+          end
+        else
+          blk = @block_else.dup
+          if @params_else
+            b_params = @params_else.dup.gsub(RE_ANCHOR) { |match|
+              parser.the_parsed.select { |p| p.anchor == match}.first.render(binder)
+            }
+            blk.params = b_params
+          end
+        end
+        blk.render binder.context
+      end
+
+    end
+
+
+    class ParsedStatic < ParsedEntity
+
+      def initialize(parser, type, id, params)
+        super(parser, type)
+        @id = id
+        @params = params
+      end
+
+      def parse!
+        @parsed_static = template.engine.static name: @id, parent: template
+        self
+      end
+
+      def render(binder)
+        blk = @parsed_static.dup
+        if @params
+          b_params = @params.dup.gsub(RE_ANCHOR) { |match|
+            parser.the_parsed.select { |p| p.anchor == match}.first.render(binder)
+          }
+          blk.params = b_params
+        end
+        blk.render binder.context
+      end
+
+    end
+
+
+    class ParserNext
+
+      EMPTY_STRING = ''
+
+      RIG_EMPTY = {
+        :flags => /<flags:(\[(\w+=[^,\]]+(,\w+=[^,\]]+)*?)\])\/>/
+      }.freeze
+
+      RIG_EXPRESSIONS = {
+        :meta => /\{%([^%]+?)%\}/.freeze,
+        :var  => /<var(\[%[A-Z]?[0-9]*[a-z]\])?:(\w+)\/>/,
+        :purl => /<purl:(\w+(?:\.\w+)?)(\[(\w+=[^,\]]+(,\w+=[^,\]]+)*?)\])?\/>/,
+        :api  => /<api:([^:\.]+(?:\.[^:]+)?):([^:\/]+)(?::([^:\/]+))?(?::([^\/]+))?\/>/
+      }.freeze
+
+      RIG_STATEMENTS = /(<(loop):(\w+)>(.*?)<\/loop:\3>)|(<(ife):(\w+)>(.*?)(<else:\7\/>(.*?))?<\/ife:\7>)/m
+
+      RIG_TEMPLATES = {
+        :blk    => /<(blk):(\w+(?:\.\w+)?)(?:\[(\w+=[^,\]]+(?:,\w+=[^,\]]+)*)\])?\/>/,
+        :iblk   => /<(iblk):(\w+):(\w+(?:\.\w+)?)(?:\[(\w+=[^,\]]+(?:,\w+=[^,\]]+)*)\])?:(\w+(?:\.\w+)?)(?:\[(\w+=[^,\]]+(?:,\w+=[^,\]]+)*)\])?\/>/,
+        :static => /<(static):(\w+(?:\.\w+)?)(?:\[(\w+=[^,\]]+(?:,\w+=[^,\]]+)*)\])?\/>/
+      }.freeze
+
+      attr_reader :flags, :template, :the_parsed
+
+      def initialize(template, text=nil)
+        @template = template
+        @inner_text = text ? text : template.content
+        @the_parsed = Array.new
+      end
+
+      def parse!
+        @tags = nil
+        parse_flags
+        if @template.is_block?
+          parse_statements
+          parse_expressions
+        end
+        parse_templates
+        self
+      end
+
+      def render(binder, context=nil)
+        @inner_text.dup.tap { |text|
+          @the_parsed.each { |value|
+            text.gsub! value.anchor, value.render(binder)
+          }
+        }.freeze
+      end
+
+      def attribute_tags
+        @attribute_tags ||= @the_parsed.map { |p|
+           p.id.to_sym if p.respond_to? :id
+         }.concat(@the_parsed.map{ |p|
+            p.attribute_tags if p.type==:ife
+        }).compact.flatten.uniq.freeze
+      end
+
+      def loop_parser(id)
+        @the_parsed.select{ |p| p.type==:loop && p.id==id}.concat(
+          @the_parsed.select{ |p| p.type==:ife }.map { |p| p.loop_parser(id) }.flatten.compact
+        )
+      end
+
+      private
+
+      def parse_flags
+        @inner_text.gsub!(RIG_EMPTY[:flags]) { |match|
+          @flags = Regexp.last_match(1)
+          EMPTY_STRING
+        }
+      end
+
+      def parse_expressions
+        RIG_EXPRESSIONS.each_key { |kre|
+          @inner_text.gsub!(RIG_EXPRESSIONS[kre]) { |match|
+            pe = ParsedEntity.instance(self, kre, Regexp.last_match )
+            @the_parsed << pe
+            pe.anchor
+          }
+        }
+      end
+
+      def parse_statements
+        @inner_text.gsub!(RIG_STATEMENTS) { |match|
+          #puts Regexp.last_match.inspect
+          type = (Regexp.last_match[2] || String.new) << (Regexp.last_match[6] || String.new)
+          pe = ParsedEntity.instance(self, type.to_sym, Regexp.last_match )
+          @the_parsed << pe.parse!
+          pe.anchor
+        }
+      end
+
+      def parse_templates
+        reTemplates = Regexp.new RIG_TEMPLATES.values.map{ |re| "(#{re})"}.join('|')
+        @inner_text.gsub!(reTemplates) { |match|
+          type = (Regexp.last_match[2] || String.new) << (Regexp.last_match[6] || String.new) << (Regexp.last_match[13] || String.new)
+          pe = ParsedEntity.instance(self, type.to_sym, Regexp.last_match )
+          @the_parsed << pe.parse!
+          pe.anchor
+        }
+      end
+
+    end
+
+  end
+end

data/lib/tzispa/rig/template.rb

@@ -0,0 +1,165 @@
+# frozen_string_literal: true
+
+module Tzispa
+  module Rig
+
+    class NotFound < NameError; end
+
+    class ReadError < IOError; end
+
+    class File
+
+      attr_reader :file, :content, :modified
+
+      def initialize(file)
+        @file = file
+        @loaded = false
+      end
+
+      def loaded?
+        @loaded
+      end
+
+      def modified?
+        @modified != File.mtime(@file)
+      end
+
+      def exists?
+        ::File.exists?(@file)
+      end
+
+      def load!
+        begin
+          raise NotFound.new("Template file '#{@file}' not found") unless exists?
+          ::File.open(@file, 'r:UTF-8') { |f|
+            @content = String.new
+            @modified = f.mtime
+            while line = f.gets
+              @content << line
+            end
+          }
+          @loaded = true
+        rescue Errno::ENOENT
+          raise ReadError.new "Template file '#{@file}' could not be read"
+        end
+        self
+      end
+
+    end
+
+
+    class Template < File
+      extend Forwardable
+
+      BASIC_TYPES    = [:layout, :block, :static].freeze
+      DEFAULT_FORMAT = 'htm'.freeze
+      RIG_EXTENSION  = 'rig'.freeze
+
+      attr_reader :name, :type, :domain, :format, :params, :parser, :engine, :subdomain
+      def_delegators :@parser, :attribute_tags
+
+      def initialize(name:, type:, domain: nil, parent: nil, format: nil, params: nil, engine: nil)
+        subdom_name = name.downcase.split('.')
+        @subdomain = subdom_name.first if subdom_name.length > 1
+        @name = subdom_name.last
+        @params = Parameters.new(params)
+        send('type=', type)
+        if parent
+          @engine = engine || parent.engine
+          @domain = domain || parent.domain
+          @format = format || parent.format
+        else
+          @engine = engine
+          @domain = domain
+          @format = format || DEFAULT_FORMAT
+        end
+        raise ArgumentError.new('Missing parameter(s): domain and engine must be especified') unless @domain && @engine
+        super "#{@domain.path}/rig/#{@type.to_s.downcase}/#{@subdomain+'/' if @subdomain}#{@name}.#{RIG_EXTENSION}.#{@format}"
+      end
+
+      def parse!
+        @parser = ParserNext.new self
+        @parser.parse!
+        self
+      end
+
+      def render(context)
+        parse! unless @parser
+        binder = TemplateBinder.for self, context
+        binder.bind! if binder && binder.respond_to?(:bind!)
+        @parser.render binder, context
+      end
+
+      def is_block?
+        @type == :block
+      end
+
+      def is_layout?
+        @type == :layout
+      end
+
+      def is_static?
+        @type == :static
+      end
+
+      def params=(value)
+        @params = Parameters.new(value)
+      end
+
+      def params
+        @params.data
+      end
+
+      def binder_class
+        @domain.require "rig/#{@type}/#{@subdomain+'/' if @subdomain}#{@name.downcase}"
+        TzString.constantize "#{TzString.camelize @domain.name}::Rig::#{@type.to_s.capitalize}::#{TzString.camelize(@subdomain+'::') if @subdomain}#{TzString.camelize @name }"
+      end
+
+      private
+
+      def type=(value)
+        raise ArgumentError.new("#{value} is not a Rig block") unless BASIC_TYPES.include?(value)
+        @type = value
+      end
+
+    end
+
+
+    class Engine
+
+      attr_reader :app
+
+      def initialize(app)
+        @app = app
+        @pool= Hash.new
+        @mutex = Mutex.new
+      end
+
+      def layout(name:, format:nil, params:nil)
+        rig_template name, :layout, format, params, nil
+      end
+
+      def block(name:, format:nil, params:nil, parent:nil)
+        rig_template name, :block, format, params, parent
+      end
+
+      def static(name:, format:nil, params:nil, parent:nil)
+        rig_template name, :static, format, params, parent
+      end
+
+      def rig_template(name, type, format, params, parent)
+        if @mutex.owned?
+          tpl = @pool["#{type}__#{name}"] || Template.new( name: name, type: type, format: format, domain: @app.domain, params: params, parent: parent, engine: self )
+          tpl.loaded? && !tpl.modified? ? tpl : tpl.load!.parse!
+        else
+          @mutex.synchronize {
+            tpl = @pool["#{type}__#{name}"] || Template.new( name: name, type: type, format: format, domain: @app.domain, params: params, parent: parent, engine: self )
+            tpl.loaded? && !tpl.modified? ? tpl : tpl.load!.parse!
+          }
+        end
+      end
+
+    end
+
+  end
+end

data/lib/tzispa/rig/version.rb

@@ -0,0 +1,10 @@
+# frozen_string_literal: true
+
+module Tzispa
+  module Rig
+
+    VERSION = '0.2.3'.freeze
+    GEM_NAME = 'tzispa_rig'.freeze
+
+  end
+end

data/lib/tzispa/rig.rb

@@ -0,0 +1,11 @@
+module Tzispa
+  module Rig
+
+    require 'tzispa/rig/parameters'
+    require 'tzispa/rig/binder'
+    require 'tzispa/rig/template'
+    require 'tzispa/rig/parsernext'
+    require 'tzispa/rig/version'
+
+  end
+end

data/lib/tzispa_rig.rb

@@ -0,0 +1,7 @@
+module Tzispa
+  module Rig
+
+    require 'tzispa/rig'
+
+  end
+end

metadata

@@ -0,0 +1,82 @@
+--- !ruby/object:Gem::Specification
+name: tzispa_rig
+version: !ruby/object:Gem::Version
+  version: 0.2.3
+platform: ruby
+authors:
+- Juan Antonio Piñero
+autorequire: 
+bindir: bin
+cert_chain: []
+date: 2016-02-24 00:00:00.000000000 Z
+dependencies:
+- !ruby/object:Gem::Dependency
+  name: tzispa_helpers
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: '0.1'
+  type: :runtime
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: '0.1'
+- !ruby/object:Gem::Dependency
+  name: tzispa_utils
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: '0.1'
+  type: :runtime
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: '0.1'
+description: General purpose template engine
+email:
+- japinero@area-integral.com
+executables: []
+extensions: []
+extra_rdoc_files: []
+files:
+- CHANGELOG.md
+- README.md
+- lib/tzispa/rig.rb
+- lib/tzispa/rig/binder.rb
+- lib/tzispa/rig/parameters.rb
+- lib/tzispa/rig/parser.rb
+- lib/tzispa/rig/parsernext.rb
+- lib/tzispa/rig/template.rb
+- lib/tzispa/rig/version.rb
+- lib/tzispa_rig.rb
+homepage: https://www.area-integral.com
+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.0'
+required_rubygems_version: !ruby/object:Gem::Requirement
+  requirements:
+  - - "~>"
+    - !ruby/object:Gem::Version
+      version: '2.0'
+requirements: []
+rubyforge_project: 
+rubygems_version: 2.5.1
+signing_key: 
+specification_version: 4
+summary: General purpose template engine
+test_files: []