tzispa_rig 0.5.0 → 0.5.1

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA1:
-  metadata.gz: 8c7fc4d4373f601d2153eb629fa2cbd150ce1f2c
-  data.tar.gz: 179daf386ee3851db47dfc3808667bd9dae5acfd
+  metadata.gz: b0ee09cd6bcb8f16477ec4472fe2442599db939d
+  data.tar.gz: a168edea1da7db3d372b37ca97bbbb58b6adb3ef
 SHA512:
-  metadata.gz: 0b42740653389d7d04833dc5e90ccdfff3d6316ef35eb790fe748f928f0602ef29ea4ed2573b6ef2ec86954aea73e9a3ac92968210cd4f59bb6d7418cc4e5649
-  data.tar.gz: ffe72dfc14733a083980078d497cc1ca315935de5019a97d2b7e6a457931e635807a9d00b17e47035bc4a93d0f363ced286201c01abc992e258eac4afa87a733
+  metadata.gz: 272a50312a02d4455a1701d12a27270fc01523ee03cd61c85fbd7609875671bbf5885f9c942f96b5f825e131174886cefcec3813e82db66b5a13bdf7a5f3c0d6
+  data.tar.gz: d67f6a12863368644c24a2988e223972ffe5ce6c20cfe0d7632369096f6f1e5d1865e469c6afc57a6e10dc532d0561c8668d8e3c3e0f4342c2339dcd08bd616a

data/CHANGELOG.md

@@ -2,6 +2,9 @@ Tzispa Rig
 
 Rig templates implementation
 
+## v0.5.1
+- Bug fixes and code refactoring
+
 ## v0.5.0
 - Rig templates syntax changes in url/purl and blk/iblk/static
 - Added support for subdoamins in layouts

data/lib/tzispa/rig/binder.rb

@@ -5,25 +5,43 @@ require 'forwardable'
 module Tzispa
   module Rig
 
+    class UnknownTag < NameError
+      def initialize(name, tag)
+        super "#{name} there isn't any loop tagged '#{tag}'"
+      end
+    end
 
-    class UnknownTag < NameError; end
-    class DuplicatedLoop < StandardError; end
+    class DuplicatedLoop < StandardError
+      def initialize(name, loop_id)
+        super "#{name} there are many loops tagged '#{loop_id}' only 1 allowed at the same level"
+      end
+    end
 
+    class IsnotTemplateBinder < ArgumentError
+      def initialize(name)
+        super "Class #{name} isn't a TemplateBinder"
+      end
+    end
 
     class Binder
       extend Forwardable
 
       attr_reader :context, :data_struct, :parser
       def_delegators :@parser, :attribute_tags
-      def_delegators :@context, :app, :request, :response, :session, :router_params, :cache
+      def_delegators :@context, :app, :request, :response,
+                     :session, :router_params, :cache
       def_delegators :app, :repository, :config, :logger
-      alias :tags :attribute_tags
 
+      alias tags attribute_tags
 
       def initialize(parser, context)
         @parser = parser
         @context = context
-        @data_struct = attribute_tags.count > 0 ? Struct.new(*attribute_tags) : Struct.new(nil)
+        @data_struct = if attribute_tags.count.positive?
+                         Struct.new(*attribute_tags)
+                       else
+                         Struct.new(nil)
+                       end
       end
 
       # Gets a LoopBinder context for the given loop_id in a rig template
@@ -39,7 +57,7 @@ module Tzispa
       # The LoopBinder returned by this funcion is independent of the
       # parent binder where it is defined, so the template symbols of the parent
       # binder are not accesible in the loop_binder context. In
-      # other words, in the top example the two 'myvar' symbols are different symbols
+      # other words, in the top example the two 'myvar' symbols are different
       # and you can not access the first myvar value inside the loop
       #
       # ==== Parameters
@@ -47,19 +65,25 @@ module Tzispa
       #
       def loop_binder(loop_id)
         loop_parser = @parser.loop_parser loop_id
-        raise UnknownTag.new("#{self.class.name} there isn't any loop tagged '#{loop_id}'") unless loop_parser && loop_parser.count > 0
-        raise DuplicatedLoop.new("#{self.class.name} there are #{loop_parser.count} loops tagged '#{loop_id}' at the same level: only one allowed") unless loop_parser.count == 1
+        unknown? loop_parser
+        duplicated? loop_parser
         LoopBinder.new loop_parser[0], @context
       end
 
       def attr_cache(*attrs)
-        attrs.each { |attrib|
-          cache[attrib] = send(attrib) if respond_to?(attrib)
-        }
+        attrs.each { |attrib| cache[attrib] = send(attrib) if respond_to?(attrib) }
       end
 
-    end
+      private
+
+      def unknown?(loop_parser)
+        raise UnknownTag.new(self.class.name, loop_parser.id) unless loop_parser.count.positive?
+      end
 
+      def duplicated?(loop_parser)
+        raise DuplicatedLoop.new(self.class.name, loop_parser.id) unless loop_parser.count == 1
+      end
+    end
 
     class TemplateBinder < Binder
       extend Forwardable
@@ -67,7 +91,6 @@ module Tzispa
       attr_reader :template
       def_delegators :@template, :params
 
-
       def initialize(template, context)
         super(template.parser, context)
         @template = template
@@ -78,65 +101,61 @@ module Tzispa
       end
 
       def attach(**params)
-        data.tap { |d|
-          params.each{ |k,v|
-            raise UnknownTag.new "#{k} is not a tag in #{self.class.name}" unless tags.include? k
+        data.tap do |d|
+          params.each do |k, v|
+            raise UnknownTag.new(self.class.name, k) unless tags.include? k
             d[k] = v
-          }
-        }
+          end
+        end
       end
 
       def self.for(template, context)
         if template.bindable?
           binder_class = template.binder_class
-          binder_class.new(template, context).tap { |binder|
-            raise ArgumentError.new "#{binder_class.name} isn't a TemplateBinder" unless binder&.is_a? Tzispa::Rig::TemplateBinder
-          } if binder_class
+          binder_class&.new(template, context)&.tap do |binder|
+            raise IsnotTemplateBinder(binder_class.name) unless binder.is_a? TemplateBinder
+          end
         else
-          self.new(template, context)
+          new(template, context)
         end
       end
-
     end
 
-
     class LoopBinder < Binder
-
       attr_reader :data
 
       def bind!(&generator)
-        @source_object = eval "self", generator.binding
+        @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
+        @source_object.send(method, *args, &generator)
       end
 
-      def loop_item(params=nil)
-        (LoopItem.new self).tap { |item|
-          params.each{ |k,v|
-            raise UnknownTag.new "#{k} is not a tag in #{self.class.name}" unless tags.include? k
-            item.data[k] = v
-          } if params
-        }
+      def respond_to_missing?(method, *)
+        @source_object.respond_to?(method)
       end
 
+      def loop_item(params = nil)
+        (LoopItem.new self).tap do |item|
+          params&.each do |k, v|
+            raise UnknownTag(self.class.name, k) unless tags.include? k
+            item.data[k] = v
+          end
+        end
+      end
     end
 
-
     class LoopItem
-
       attr_reader :context, :data
 
       def initialize(binder)
         @context = binder.context
         @data = binder.data_struct.new
       end
-
     end
 
-
   end
 end

data/lib/tzispa/rig/engine.rb

@@ -10,52 +10,44 @@ module Tzispa
     class Engine
       include Singleton
 
-      @@cache_size = 512
-      @@cache_ttl  = 600 # 10 mins
+      @cache_size = 512
+      @cache_ttl  = 600
 
       def initialize
-        @cache = LruRedux::TTL::ThreadSafeCache.new(@@cache_size, @@cache_ttl)
+        @cache = LruRedux::TTL::ThreadSafeCache.new(Engine.cache_size, Engine.cache_ttl)
       end
 
       class << self
+        attr_accessor :cache_size, :cache_ttl
 
         def empty
           TemplateBase.new
         end
 
-        def layout(name:, domain:, content_type:, params:nil)
+        def layout(name:, domain:, content_type:, params: nil)
           rig_template name, domain, :layout, content_type, params
         end
 
-        def block(name:, domain:, content_type:, params:nil)
+        def block(name:, domain:, content_type:, params: nil)
           rig_template name, domain, :block, content_type, params
         end
 
-        def static(name:, domain:, content_type:, params:nil)
+        def static(name:, domain:, content_type:, params: nil)
           rig_template name, domain, :static, content_type, params
         end
 
         def rig_template(name, domain, block_type, content_type, params)
           instance.send(:cache_template, name, domain, block_type, content_type, params)
         end
-
-        def cache_size=(sz)
-          @@cache_size = sz
-        end
-
-        def cache_ttl=(seconds)
-          @@cache_ttl = seconds
-        end
-
       end
 
       private
 
       def cache_template(name, domain, block_type, content_type, params)
         key = "#{domain}/#{block_type}/#{name}/#{content_type}".to_sym
-        get_template(key, name, domain, block_type, content_type).dup.tap { |ctpl|
-           ctpl.params = params if params
-        }
+        get_template(key, name, domain, block_type, content_type).dup.tap do |ctpl|
+          ctpl.params = params if params
+        end
       end
 
       def get_template(key, name, domain, block_type, content_type)
@@ -67,9 +59,11 @@ module Tzispa
       end
 
       def set_template(key, name, domain, block_type, content_type)
-        @cache[key] = Template.new(name: name, type: block_type, domain: domain, content_type: content_type).load!.parse!
+        @cache[key] = Template.new(name: name,
+                                   type: block_type,
+                                   domain: domain,
+                                   content_type: content_type).load!.parse!
       end
-
     end
 
   end

data/lib/tzispa/rig/parameters.rb

@@ -4,14 +4,13 @@ module Tzispa
   module Rig
 
     class Parameters
-
       attr_reader :inner, :outer
 
-      def initialize(params=nil, outer=',', inner='=')
-        @data = Hash.new
+      def initialize(params = nil, outer = ',', inner = '=')
+        @data = {}
         @outer = outer
         @inner = inner
-        setData(params) if params
+        load(params) if params
       end
 
       def [](key)
@@ -27,29 +26,28 @@ module Tzispa
       end
 
       def to_s
-        @data.map { |k,v| "#{k}#{inner}#{v}" }.join(outer)
+        @data.map { |k, v| "#{k}#{inner}#{v}" }.join(outer)
       end
 
       def to_h
         @data.dup
       end
 
-      alias_method :data, :to_h
+      alias data to_h
 
       def merge(params)
-        setData(params)
+        load(params)
       end
 
       private
 
-      def setData(params)
+      def load(params)
         params.split(outer).each do |param|
-          key,value = param.split(inner)
+          key, value = param.split(inner)
           @data[key.to_sym] = value
         end
       end
-
-
     end
+
   end
 end

data/lib/tzispa/rig/parsernext.rb

@@ -6,35 +6,43 @@ module Tzispa
   module Rig
 
     class ParserNext
-
       EMPTY_STRING = ''
 
       include Tzispa::Rig::Syntax
 
-      attr_reader :flags, :template, :tokens, :domain, :format, :childrens,
-                  :bindable, :content_type, :inner_text, :content_escape_method
+      attr_reader :flags, :template, :tokens, :domain, :format,
+                  :childrens, :content_type, :inner_text
 
-      def initialize(template = nil, text: nil, domain: nil, content_type: nil, bindable: nil, parent: nil)
+      def initialize(opts = {})
         @parsed = false
-        @template = template
-        @inner_text = (text || template&.content)&.dup
-        @domain = domain || parent.domain
-        @bindable = bindable.nil? ? parent.bindable : bindable
-        @content_type = content_type || parent.content_type
-        @content_escape_method = :"escape_#{content_type}"
+        @template = opts[:template] if opts.key?(:template)
+        @inner_text = (opts[:text] || template&.content)&.dup
+        parent = opts[:parent]
+        @domain = opts[:domain] || parent.domain
+        @bindable = opts.key?(:bindable) ? opts[:bindable] : parent.bindable?
+        @content_type = opts[:content_type] || parent.content_type
       end
 
       def empty?
         @tokens.empty?
       end
 
+      def bindable?
+        @bindable
+      end
+
+      def parsed?
+        @parsed
+      end
+
       def parse!
         unless parsed?
-          @attribute_tags  = nil
-          @childrens = Array.new
-          @tokens = Array.new
+          @attribute_tags = nil
+          @childrens = []
+          @tokens = []
+          @loop_parser = {}
           parse_flags
-          if bindable
+          if bindable?
             parse_statements
             parse_expressions
             parse_url_builder
@@ -45,86 +53,81 @@ module Tzispa
         self
       end
 
-      def parsed?
-        @parsed
+      def content_escape_method
+        @content_escape_method ||= :"escape_#{content_type}"
       end
 
       def render(binder)
-        @inner_text.dup.tap { |text|
-          @tokens.each { |value|
-            text.gsub! value.anchor, value.render(binder)
-          }
-        }.freeze
+        @inner_text.dup.tap do |text|
+          @tokens.each { |value| text.gsub! value.anchor, value.render(binder) }
+        end.freeze
       end
 
       def attribute_tags
-        @attribute_tags ||= tokens.map { |p|
-           p.id.to_sym if p.respond_to? :id
-         }.concat(
-            tokens.map{ |p|
-              p.attribute_tags if p.type == :ife
-            }
-          ).compact.flatten.uniq.freeze
+        @at_tags ||= begin
+                      att = tokens.select { |tk| tk.respond_to? :id }
+                      att = att.map { |p| p.id.to_sym }
+                      att.concat(
+                        tokens.map { |p| p.attribute_tags if p.type == :ife }
+                      ).compact.flatten.uniq.freeze
+                    end
       end
 
       def loop_parser(id)
-        tokens.select{ |p|
-          p.type==:loop && p.id==id
-        }.concat(
-          tokens.select{ |p|
-            p.type==:ife }.map {
-               |p| p.loop_parser(id)
-             }.flatten.compact
+        lpp = tokens.select { |p| p.type == :loop && p.id == id }
+        lpp.concat(
+          tokens.select { |p| p.type == :ife }.map do |p|
+            p.loop_parser(id)
+          end.flatten.compact
         )
       end
 
       private
 
       def parse_flags
-        while match = @inner_text.match(RIG_EMPTY[:flags]) do
+        while (match = @inner_text.match RIG_EMPTY[:flags])
           @flags = Regexp.last_match(1)
           @inner_text.gsub! match[0], ''
         end
       end
 
       def parse_url_builder
-        RIG_URL_BUILDER.each_key { |kre|
-          while match = @inner_text.match(RIG_URL_BUILDER[kre]) do
-            tk = Token.instance(self, kre, match )
+        RIG_URL_BUILDER.each_key do |kre|
+          while (match = @inner_text.match RIG_URL_BUILDER[kre])
+            tk = Token.instance(self, kre, match)
             @tokens << tk
             @inner_text.gsub! match[0], tk.anchor
           end
-        }
+        end
       end
 
       def parse_expressions
-        RIG_EXPRESSIONS.each { |kre, re|
-          while match = @inner_text.match(re) do
-            tk = Token.instance(self, kre, match )
+        RIG_EXPRESSIONS.each do |kre, re|
+          while (match = @inner_text.match re)
+            tk = Token.instance(self, kre, match)
             @tokens << tk
             @inner_text.gsub! match[0], tk.anchor
           end
-        }
+        end
       end
 
       def parse_statements
-        while match = @inner_text.match(RIG_STATEMENTS) do
-          type = (match[2] || String.new) << (match[6] || String.new)
-          tk = Token.instance(self, type.to_sym, match )
+        while (match = @inner_text.match RIG_STATEMENTS)
+          type = String.new << (match[2] || match[6])
+          tk = Token.instance(self, type.to_sym, match)
           @tokens << tk.parse!
           @inner_text.gsub! match[0], tk.anchor
         end
       end
 
       def parse_templates
-        while match = @inner_text.match(RIG_TEMPLATES) do
-          type = (match[2] || String.new) << (match[6] || String.new) << (match[13] || String.new)
-          tk = Token.instance(self, type.to_sym, match )
+        while (match = @inner_text.match RIG_TEMPLATES)
+          type = String.new << (match[2] || match[6] || match[13])
+          tk = Token.instance(self, type.to_sym, match)
           @tokens << tk.parse!
           @inner_text.gsub! match[0], tk.anchor
         end
       end
-
     end
 
   end

data/lib/tzispa/rig/syntax.rb

@@ -1,26 +1,27 @@
+# frozen_string_literal: true
+
 module Tzispa
   module Rig
     module Syntax
 
       RIG_EMPTY = {
-        :flags => /<flags:(\[(\w+=[^,\]]+(,\w+=[^,\]]+)*?)\])\/>/
+        flags: /<flags:(\[(\w+=[^,\]]+(,\w+=[^,\]]+)*?)\])\/>/
       }.freeze
 
       RIG_EXPRESSIONS = {
-        :meta => /\{%([^%]+?)%\}/,
-        :var  => /<var(\[%[A-Z]?[0-9]*[a-z]\])?:(\w+)\/>/
+        meta: /\{%([^%]+?)%\}/,
+        var:  /<var(\[%[A-Z]?[0-9]*[a-z]\])?:(\w+)\/>/
       }.freeze
 
       RIG_URL_BUILDER = {
-        :url  => /<(url|purl)(#\w+)?:([^\[\@\/]+(?:\@[^\[\/]+)?)(\[(\w+=[^,\]]+(,\w+=[^,\]]+)*?)\])?\/>/,
-        :api => /<(api|sapi)(#\w+)?:([^:\@]+(?:\@[^:]+)?):([^:\/]+)(?::([^:\/]+))?(?::([^\/]+))?\/>/
+        url: /<(url|purl)(#\w+)?:([^\[\@\/]+(?:\@[^\[\/]+)?)(\[(\w+=[^,\]]+(,\w+=[^,\]]+)*?)\])?\/>/,
+        api: /<(api|sapi)(#\w+)?:([^:\@]+(?:\@[^:]+)?):([^:\/]+)(?::([^:\/]+))?(?::([^\/]+))?\/>/
       }.freeze
 
       RIG_STATEMENTS = /(<(loop):(\w+)>(.*?)<\/loop:\3>)|(<(ife):(\w+)>(.*?)(<else:\7\/>(.*?))?<\/ife:\7>)/m
 
       RIG_TEMPLATES = /(<(blk):(\w+(?:@\w+)?)(?:\[(\w+=[^,\]]+(?:,\w+=[^,\]]+)*)\])?\/>)|(<(iblk):(\w+):(\w+(?:@\w+)?)(?:\[(\w+=[^,\]]+(?:,\w+=[^,\]]+)*)\])?:(\w+(?:@\w+)?)(?:\[(\w+=[^,\]]+(?:,\w+=[^,\]]+)*)\])?\/>)|(<(static):(\w+(?:@\w+)?)(?:\[(\w+=[^,\]]+(?:,\w+=[^,\]]+)*)\])?\/>)/
 
-
     end
   end
 end

data/lib/tzispa/rig/template.rb

@@ -4,16 +4,26 @@ require 'forwardable'
 require 'fileutils'
 require 'tzispa/utils/string'
 require 'tzispa/utils/indenter'
+require 'tzispa/rig/parameters'
+require 'tzispa/rig/parsernext'
+require 'tzispa/rig/binder'
 
 module Tzispa
   module Rig
 
-    class NotFound < NameError; end
+    class NotFound < NameError
+      def initialize(filename)
+        super "Template file '#{filename}' not found"
+      end
+    end
 
-    class ReadError < IOError; end
+    class ReadError < IOError
+      def initialize(file)
+        super "Template file '#{file}' could not be read"
+      end
+    end
 
     class TemplateBase
-
       attr_reader :content
 
       def initialize
@@ -41,14 +51,12 @@ module Tzispa
         self
       end
 
-      def render(context, binder=nil)
-        ""
+      def render(_context, _binder = nil)
+        ''
       end
-
     end
 
     class File < TemplateBase
-
       attr_reader :filename, :encoding
 
       def initialize(name, encoding: 'UTF-8')
@@ -67,33 +75,27 @@ module Tzispa
       end
 
       def load!
-        raise NotFound.new("Template file '#{filename}' not found") unless exist?
-        ::File.open(filename, "r:#{encoding}") { |f|
+        raise Tzispa::Rig::NotFound.new(filename) unless exist?
+        ::File.open(filename, "r:#{encoding}") do |f|
           @content = String.new
           @modified = f.mtime
-          f.each { |line|
-            @content << line
-          }
+          f.each { |line| @content << line }
           @loaded = true
-        }
+        end
         self
       rescue Errno::ENOENT
-        raise ReadError.new "Template file '#{@file}' could not be read"
+        raise Tzispa::Rig::ReadError.new(@file)
       end
 
-      def create(content=nil)
-        ::File.open(filename, "w:#{encoding}") { |f|
-          f.puts content
-        }
+      def create(content = nil)
+        ::File.open(filename, "w:#{encoding}") { |f| f.puts content }
       end
-
     end
 
-
     class Template < File
       extend Forwardable
 
-      using Tzispa::Utils
+      using Tzispa::Utils::TzString
 
       BASIC_TYPES    = [:layout, :block, :static].freeze
       RIG_EXTENSION  = 'rig'
@@ -103,10 +105,7 @@ module Tzispa
 
       def initialize(name:, type:, domain:, content_type:, params: nil)
         @id = name
-        name.downcase.split('@').tap { |sdn|
-          @subdomain = sdn.length > 1 ? sdn.first : nil
-          @name = sdn.last
-        }
+        build_name name
         @domain = domain
         @content_type = content_type
         @params = Parameters.new(params)
@@ -115,22 +114,23 @@ module Tzispa
       end
 
       def parse!
-        @parser = ParserNext.new self, domain: domain, content_type: content_type, bindable: bindable?
+        @parser = ParserNext.new template: self,
+                                 domain: domain,
+                                 content_type: content_type,
+                                 bindable: bindable?
         parser.parse!
         self
       end
 
       def modified?
-        super || (parser && parser.childrens.index { |tpl|
-          tpl.modified?
-        })
+        super || (parser && parser.childrens.index(&:modified?))
       end
 
       def valid?
         !content.empty? && !parser.empty?
       end
 
-      def render(context, binder=nil)
+      def render(context, binder = nil)
         parse! unless parser
         binder ||= TemplateBinder.for self, context
         binder.bind! if binder&.respond_to?(:bind!)
@@ -141,7 +141,7 @@ module Tzispa
         @path ||= "#{domain.path}/view/#{subdomain || '_'}/#{type.to_s.downcase}"
       end
 
-      def create(content='')
+      def create(content = '')
         FileUtils.mkdir_p(path) unless Dir.exist? path
         super(content)
         create_binder
@@ -192,38 +192,42 @@ module Tzispa
 
       private
 
+      def build_name(name)
+        name.to_s.downcase.split('@').tap do |sdn|
+          @subdomain = sdn.first if sdn.length > 1
+          @name = sdn.last
+        end
+      end
+
       def type=(value)
-        raise ArgumentError.new("#{value} is not a Rig block") unless BASIC_TYPES.include?(value)
+        raise ArgumentError("#{value} is not a Rig block") unless BASIC_TYPES.include?(value)
         @type = value
       end
 
       def create_binder
-        ::File.open("#{domain.path}/#{binder_require}.rb", "w") { |f|
+        return unless [:block, :layout].include?(type)
+        ::File.open("#{domain.path}/#{binder_require}.rb", 'w') do |f|
           f.puts write_binder_code
-        } if type == :block
+        end
       end
 
       def write_binder_code
-        Tzispa::Utils::Indenter.new(2).tap { |binder_code|
+        Tzispa::Utils::Indenter.new(2).tap do |binder_code|
           binder_code << "require 'tzispa/rig/binder'\n\n"
           level = 0
-          binder_namespace.split('::').each { |ns|
-            binder_code.indent if level > 0
+          binder_namespace.split('::').each do |ns|
+            binder_code.indent if level.positive?
             binder_code << "module #{ns}\n"
             level += 1
-          }
+          end
           binder_code.indent << "\nclass #{binder_class_name} < Tzispa::Rig::TemplateBinder\n\n"
           binder_code.indent << "def bind!\n"
           binder_code << "end\n\n"
           binder_code.unindent << "end\n"
-          binder_namespace.split('::').each { |ns|
-            binder_code.unindent << "end\n"
-          }
-        }.to_s
+          binder_namespace.split('::').each { binder_code.unindent << "end\n" }
+        end.to_s
       end
-
     end
 
-
   end
 end

data/lib/tzispa/rig/token.rb

@@ -1,6 +1,7 @@
 # frozen_string_literal: true
 
 require 'forwardable'
+require 'tzispa/utils/string'
 
 module Tzispa
   module Rig
@@ -8,6 +9,8 @@ module Tzispa
     class Token
       extend Forwardable
 
+      using Tzispa::Utils::TzString
+
       RE_ANCHOR = /(\$\$\h+\$\$)/
 
       attr_reader :type, :parser
@@ -18,33 +21,15 @@ module Tzispa
         @type = type
       end
 
-      def self.instance(parser, type, match)
-        case type
-        when :meta
-          TypeToken::Meta.new parser, type, match[1]
-        when :var
-          TypeToken::Var.new parser, type, match[1], match[2]
-        when :url
-          TypeToken::Url.new parser, match[1].to_sym, match[3], match[5], match[2]&.slice(1..-1)
-        when :api
-          TypeToken::Api.new parser, match[1].to_sym, match[3], match[4], match[5], match[6], match[2]&.slice(1..-1)
-        when :loop
-          TypeToken::Loop.new parser, type, match[3], match[4]
-        when :ife
-          TypeToken::Ife.new parser, type, match[7], match[8], match[10]
-        when :blk
-          TypeToken::Block.new parser, type, match[3], match[4]
-        when :iblk
-          TypeToken::IBlock.new parser, type, match[7], match[8], match[9], match[10], match[11]
-        when :static
-          TypeToken::Static.new parser, type, match[14], match[15]
+      class << self
+        def instance(parser, type, match)
+          "Tzispa::Rig::TypeToken::#{type.to_s.capitalize}".constantize.new parser, match
         end
       end
 
       def anchor
-        @anchor ||= "$$#{"%x" % object_id}$$".freeze
+        @anchor ||= "$$#{format '%x', object_id}$$"
       end
-
     end
 
     require 'tzispa/rig/type_token/api_url'
@@ -52,6 +37,5 @@ module Tzispa
     require 'tzispa/rig/type_token/statement'
     require 'tzispa/rig/type_token/block'
 
-
   end
-end
+end

data/lib/tzispa/rig/type_token/api_url.rb

@@ -5,14 +5,13 @@ module Tzispa
     module TypeToken
 
       class Url < Rig::Token
-
         attr_reader :layout, :params, :app_name
 
-        def initialize(parser, type, layout, params, app_name = nil)
-          super(parser, type)
-          @layout = layout
-          @params = params
-          @app_name = app_name&.to_sym
+        def initialize(parser, match)
+          super(parser, match[1].to_sym)
+          @layout = match[3]
+          @params = match[5]
+          @app_name = match[2]&.slice(1..-1)&.to_sym
         end
 
         def render(binder)
@@ -27,55 +26,55 @@ module Tzispa
         end
 
         def render_purl(binder, app_name, b_layout, h_params)
-          app_name ?
-            binder.context.app_layout_path(app_name, b_layout, h_params) :
+          if app_name
+            binder.context.app_layout_path(app_name, b_layout, h_params)
+          else
             binder.context.layout_path(b_layout, h_params)
+          end
         end
 
         def render_url(binder, app_name, b_layout, h_params)
-          app_name ?
-            binder.context.app_layout_canonical_url(app_name, b_layout, h_params) :
+          if app_name
+            binder.context.app_layout_canonical_url(app_name, b_layout, h_params)
+          else
             binder.context.layout_canonical_url(b_layout, h_params)
+          end
         end
 
         def bind_value(value, binder)
-          value&.gsub(RE_ANCHOR) { |match|
-            parser.tokens.select { |p| p.anchor == match}.first.render(binder)
-          }
+          value&.gsub(RE_ANCHOR) do |match|
+            parser.tokens.select { |p| p.anchor == match }.first.render(binder)
+          end
         end
-
       end
 
-
       class Api < Rig::Token
-
         attr_reader :handler, :verb, :predicate, :app_name
 
-        def initialize(parser, type, handler, verb, predicate, sufix, app_name = nil)
-          super(parser, type)
-          @handler = handler
-          @verb = verb
-          @predicate = predicate
-          @sufix = sufix
-          @app_name = app_name&.to_sym
+        def initialize(parser, match)
+          super(parser, match[1].to_sym)
+          @handler = match[3]
+          @verb = match[4]
+          @predicate = match[5]
+          @sufix = match[6]
+          @app_name = match[2]&.slice(1..-1)&.to_sym
         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
+          b_predicate = bind_value(@predicate.dup, binder) if @predicate
+          b_sufix = bind_value(@sufix.dup, binder) if @sufix
           binder.context.send(type.to_sym, b_handler, b_verb, b_predicate, b_sufix, app_name)
         end
 
         private
 
         def bind_value(value, binder)
-          value.gsub(RE_ANCHOR) { |match|
-            parser.tokens.select { |p| p.anchor == match}.first.render(binder)
-          }
+          value.gsub(RE_ANCHOR) do |match|
+            parser.tokens.select { |p| p.anchor == match }.first.render(binder)
+          end
         end
-
       end
 
     end

data/lib/tzispa/rig/type_token/block.rb

@@ -4,14 +4,13 @@ module Tzispa
   module Rig
     module TypeToken
 
-      class Block < Rig::Token
-
+      class Blk < Rig::Token
         attr_reader :id, :params
 
-        def initialize(parser, type, id, params)
-          super(parser, type)
-          @id = id
-          @params = params
+        def initialize(parser, match)
+          super(parser, :blk)
+          @id = match[3]
+          @params = match[4]
         end
 
         def parse!
@@ -30,9 +29,10 @@ module Tzispa
         private
 
         def bind_value(value, binder)
-          value.gsub(RE_ANCHOR) { |match|
-            parser.tokens.select { |p| p.anchor == match}.first.render(binder)
-          }
+          value.gsub(RE_ANCHOR) do |match|
+            anchor = parser.tokens.select { |p| p.anchor == match }
+            anchor.first.render(binder)
+          end
         end
 
         def obtain_block(id)
@@ -41,29 +41,27 @@ module Tzispa
             Rig::Engine.empty
           when template&.id
             # to avoid infinite recursion
-            template&.type == :block ?
-              template :
+            if template&.type == :block
+              template
+            else
               Rig::Engine.block(name: id, domain: domain, content_type: content_type)
+            end
           else
             Rig::Engine.block(name: id, domain: domain, content_type: content_type)
           end
         end
-
-
       end
 
-
-      class IBlock < Rig::Token
-
+      class Iblk < Rig::Token
         attr_reader :id, :id_then, :params_then, :id_else, :params_else
 
-        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
+        def initialize(parser, match)
+          super(parser, :iblk)
+          @id = match[7]
+          @id_then = match[8]
+          @params_then = match[9]
+          @id_else = match[10]
+          @params_else = match[11]
         end
 
         def parse!
@@ -92,53 +90,57 @@ module Tzispa
             Rig::Engine.empty
           when template&.id
             # to avoid infinite recursion
-            template&.type == :block ?
-              template :
+            if template&.type == :block
+              template
+            else
               Rig::Engine.block(name: id, domain: domain, content_type: content_type)
+            end
           else
             Rig::Engine.block(name: id, domain: domain, content_type: content_type)
           end
         end
 
         def bind_value(value, binder)
-          value.gsub(RE_ANCHOR) { |match|
-            parser.tokens.select { |p| p.anchor == match}.first.render(binder)
-          }
+          value.gsub(RE_ANCHOR) do |match|
+            anchor = parser.tokens.select { |p| p.anchor == match }
+            anchor.first.render(binder)
+          end
         end
-
       end
 
-
       class Static < Rig::Token
-
         attr_reader :id, :params
 
-        def initialize(parser, type, id, params)
-          super(parser, type)
-          @id = id
-          @params = params
+        def initialize(parser, match)
+          super(parser, :static)
+          @id = match[14]
+          @params = match[15]
         end
 
         def parse!
-          @parsed_static = Tzispa::Rig::Engine.static name: @id, domain: domain, content_type: content_type
+          @parsed_static = Tzispa::Rig::Engine.static name: @id,
+                                                      domain: domain,
+                                                      content_type: content_type
           parser.childrens << @parsed_static
           self
         end
 
         def render(binder)
           blk = @parsed_static.dup
-          if @params
-            b_params = @params.dup.gsub(RE_ANCHOR) { |match|
-              parser.tokens.select { |p| p.anchor == match}.first.render(binder)
-            }
-            blk.params = b_params
-          end
+          blk.params = bind_value(@params.dup, binder) if @params
           blk.render binder.context
         end
 
-      end
+        private
 
+        def bind_value(value, binder)
+          value.gsub(RE_ANCHOR) do |match|
+            anchor = parser.tokens.select { |p| p.anchor == match }
+            anchor.first.render(binder)
+          end
+        end
+      end
 
     end
   end
-end
+end

data/lib/tzispa/rig/type_token/expression.rb

@@ -7,12 +7,11 @@ module Tzispa
     module TypeToken
 
       class Meta < Rig::Token
-
         attr_reader :id
 
-        def initialize(parser, type, id)
-          super(parser, type)
-          @id = id.to_sym
+        def initialize(parser, match)
+          super(parser, :meta)
+          @id = match[1].to_sym
         end
 
         def render(binder)
@@ -26,21 +25,19 @@ module Tzispa
         private
 
         def unknown
-          @unknown ||= "#{@id}"
+          @unknown ||= id.to_s
         end
-
       end
 
-
       class Var < Rig::Token
-        using Tzispa::Utils
+        using Tzispa::Utils::TzString
 
         attr_reader :id
 
-        def initialize(parser, type, format, id)
-          super(parser, type)
-          @format = format
-          @id = id.to_sym
+        def initialize(parser, match)
+          super(parser, :var)
+          @format = match[1]
+          @id = match[2].to_sym
         end
 
         def render(binder)
@@ -55,11 +52,10 @@ module Tzispa
         private
 
         def unknown
-          @unknown ||= "#{@id}"
+          @unknown ||= @id.to_s
         end
-
       end
 
     end
   end
-end
+end

data/lib/tzispa/rig/type_token/statement.rb

@@ -12,52 +12,65 @@ module Tzispa
         attr_reader :id, :body_parser
         def_delegators :@body_parser, :attribute_tags, :loop_parser
 
-        def initialize(parser, type, id, body)
-          super(parser, type)
-          @id = id.to_sym
-          @body = body
+        def initialize(parser, match)
+          super(parser, :loop)
+          @id = match[3].to_sym
+          @body = match[4]
         end
 
         def parse!
-          @body_parser = Rig::ParserNext.new(template, text: @body, parent: parser, bindable: true ).parse!
+          @body_parser = Rig::ParserNext.new template: template,
+                                             text: @body,
+                                             parent: parser,
+                                             bindable: true
+          @body_parser.parse!
           self
         end
 
         def render(binder)
-          String.new.tap { |text|
+          String.new.tap do |text|
             looper = binder.data.send(@id) if binder.data.respond_to?(@id)
-            looper&.data&.each { |loop_item|
+            looper&.data&.each do |loop_item|
               text << body_parser.render(loop_item) if loop_item
-            } if looper
-          }
+            end
+          end
         end
-
       end
 
-
       class Ife < Rig::Token
-
         attr_reader :test, :then_parser, :else_parser
 
-        def initialize(parser, type, test, then_body, else_body)
-          super(parser, type)
-          @test = test.to_sym
-          @then_body = then_body
-          @else_body = else_body
+        def initialize(parser, match)
+          super(parser, :ife)
+          @test = match[7].to_sym
+          @then_body = match[8]
+          @else_body = match[10]
         end
 
         def parse!
-          @then_parser = Rig::ParserNext.new(template, text: @then_body, parent: parser ).parse!
-          @else_parser = @else_body ? Rig::ParserNext.new(template,  text: @else_body, parent: parser ).parse! : nil
+          @then_parser = Rig::ParserNext.new(template: template,
+                                             text: @then_body,
+                                             parent: parser).parse!
+          @else_parser = if @else_body
+                           Rig::ParserNext.new(template: template,
+                                               text: @else_body,
+                                               parent: parser).parse!
+                         end
           self
         end
 
         def attribute_tags
-          @attribute_tags ||= [test].concat(then_parser.attribute_tags).concat(else_parser&.attribute_tags || Array.new).compact.uniq.freeze
+          @attribute_tags ||= begin
+                               att = [test].concat(then_parser.attribute_tags)
+                               att.concat(else_parser&.attribute_tags || [])
+                               att.compact.uniq.freeze
+                             end
         end
 
         def loop_parser(id)
-          @then_parser.loop_parser(id).concat(else_parser&.loop_parser(id) || Array.new).compact.freeze
+          lpp = then_parser.loop_parser(id)
+          lpp.concat(else_parser&.loop_parser(id) || [])
+          lpp.compact.freeze
         end
 
         def render(binder)
@@ -65,9 +78,8 @@ module Tzispa
           ifeparser = test_eval ? then_parser : else_parser
           ifeparser ? ifeparser.render(binder) : ''
         end
-
       end
 
     end
   end
-end
+end

data/lib/tzispa/rig/version.rb

@@ -3,7 +3,7 @@
 module Tzispa
   module Rig
 
-    VERSION = '0.5.0'
+    VERSION = '0.5.1'
     GEM_NAME = 'tzispa_rig'
 
   end

data/test/parsernext_test.rb

@@ -212,10 +212,10 @@ class ParsernextTest < Minitest::Test
     parser = Tzispa::Rig::ParserNext.new text: TPL_BLK, domain: domain, content_type: :htm, bindable: true
     parser.parse!
     assert_equal parser.tokens.count, 5
-    assert_instance_of Tzispa::Rig::TypeToken::Block, parser.tokens[1]
-    assert_instance_of Tzispa::Rig::TypeToken::Block, parser.tokens[2]
-    assert_instance_of Tzispa::Rig::TypeToken::IBlock, parser.tokens[3]
-    assert_instance_of Tzispa::Rig::TypeToken::IBlock, parser.tokens[4]
+    assert_instance_of Tzispa::Rig::TypeToken::Blk, parser.tokens[1]
+    assert_instance_of Tzispa::Rig::TypeToken::Blk, parser.tokens[2]
+    assert_instance_of Tzispa::Rig::TypeToken::Iblk, parser.tokens[3]
+    assert_instance_of Tzispa::Rig::TypeToken::Iblk, parser.tokens[4]
     assert_equal parser.tokens[1].id, 'detail'
     assert_equal parser.tokens[2].id, 'product@detail'
     assert_equal parser.tokens[2].params, "tab=#{parser.tokens[0].anchor}"

data/test/res/apps/test_domain/view/_/layout/index.rig.txt

@@ -0,0 +1 @@
+This is a layout template file

metadata

@@ -1,14 +1,14 @@
 --- !ruby/object:Gem::Specification
 name: tzispa_rig
 version: !ruby/object:Gem::Version
-  version: 0.5.0
+  version: 0.5.1
 platform: ruby
 authors:
 - Juan Antonio Piñero
 autorequire: 
 bindir: bin
 cert_chain: []
-date: 2017-02-13 00:00:00.000000000 Z
+date: 2017-03-13 00:00:00.000000000 Z
 dependencies:
 - !ruby/object:Gem::Dependency
   name: tzispa_utils
@@ -79,6 +79,7 @@ files:
 - test/engine_test.rb
 - test/parameters_test.rb
 - test/parsernext_test.rb
+- test/res/apps/test_domain/view/_/layout/index.rig.txt
 - test/res/apps/test_domain/view/product/layout/list.rig.htm
 - test/template_test.rb
 - test/test_helper.rb