tzispa_rig 0.4.5 → 0.5.0

data/lib/tzispa/rig/template.rb

@@ -4,7 +4,6 @@ require 'forwardable'
 require 'fileutils'
 require 'tzispa/utils/string'
 require 'tzispa/utils/indenter'
-require 'tzispa/rig'
 
 module Tzispa
   module Rig
@@ -13,13 +12,13 @@ module Tzispa
 
     class ReadError < IOError; end
 
-    class File
+    class TemplateBase
 
-      attr_reader :file, :content, :modified
+      attr_reader :content
 
-      def initialize(file)
-        @file = file
-        @loaded = false
+      def initialize
+        @content = nil
+        @loaded = true
       end
 
       def loaded?
@@ -27,33 +26,63 @@ module Tzispa
       end
 
       def modified?
-        @modified != ::File.mtime(@file)
+        false
       end
 
       def exist?
-        ::File.exist?(@file)
+        true
       end
 
       def load!
-        begin
-          raise NotFound.new("Template file '#{@file}' not found") unless exist?
-          ::File.open(@file, 'r:UTF-8') { |f|
-            @content = String.new
-            @modified = f.mtime
-            while line = f.gets
-              @content << line
-            end
-            f.close
+        self
+      end
+
+      def parse!
+        self
+      end
+
+      def render(context, binder=nil)
+        ""
+      end
+
+    end
+
+    class File < TemplateBase
+
+      attr_reader :filename, :encoding
+
+      def initialize(name, encoding: 'UTF-8')
+        super()
+        @filename = name
+        @loaded = false
+        @encoding = encoding
+      end
+
+      def modified?
+        @modified && (@modified != ::File.mtime(filename))
+      end
+
+      def exist?
+        ::File.exist?(filename)
+      end
+
+      def load!
+        raise NotFound.new("Template file '#{filename}' not found") unless exist?
+        ::File.open(filename, "r:#{encoding}") { |f|
+          @content = String.new
+          @modified = f.mtime
+          f.each { |line|
+            @content << line
           }
           @loaded = true
-        rescue Errno::ENOENT
-          raise ReadError.new "Template file '#{@file}' could not be read"
-        end
+        }
         self
+      rescue Errno::ENOENT
+        raise ReadError.new "Template file '#{@file}' could not be read"
       end
 
       def create(content=nil)
-        ::File.open(@file, "w") { |f|
+        ::File.open(filename, "w:#{encoding}") { |f|
           f.puts content
         }
       end
@@ -67,39 +96,32 @@ module Tzispa
       using Tzispa::Utils
 
       BASIC_TYPES    = [:layout, :block, :static].freeze
-      DEFAULT_FORMAT = 'htm'.freeze
-      RIG_EXTENSION  = 'rig'.freeze
+      RIG_EXTENSION  = 'rig'
 
-      attr_reader :name, :type, :domain, :format, :params, :parser, :engine, :subdomain, :childrens
+      attr_reader :id, :name, :type, :domain, :parser, :subdomain, :childrens, :content_type
       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
+      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
+        }
+        @domain = domain
+        @content_type = content_type
         @params = Parameters.new(params)
-        @childrens = Array.new
         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
-        super "#{path}/#{@name}.#{RIG_EXTENSION}.#{@format}"
+        super "#{path}/#{@name}.#{RIG_EXTENSION}.#{content_type}"
       end
 
       def parse!
-        @parser = ParserNext.new self
-        @parser.parse!
+        @parser = ParserNext.new self, domain: domain, content_type: content_type, bindable: bindable?
+        parser.parse!
         self
       end
 
       def modified?
-        super || (childrens.count > 0 && childrens.index { |tpl|
+        super || (parser && parser.childrens.index { |tpl|
           tpl.modified?
         })
       end
@@ -108,15 +130,15 @@ module Tzispa
         !content.empty? && !parser.empty?
       end
 
-      def render(context)
-        parse! unless @parser
-        binder = TemplateBinder.for self, context
-        binder.bind! if binder && binder.respond_to?(:bind!)
-        @parser.render binder, context
+      def render(context, binder=nil)
+        parse! unless parser
+        binder ||= TemplateBinder.for self, context
+        binder.bind! if binder&.respond_to?(:bind!)
+        parser.render binder
       end
 
       def path
-        "#{@domain.path}/rig/#{@type.to_s.downcase}#{'/'+@subdomain if @subdomain}"
+        @path ||= "#{domain.path}/view/#{subdomain || '_'}/#{type.to_s.downcase}"
       end
 
       def create(content='')
@@ -150,20 +172,22 @@ module Tzispa
       end
 
       def binder_require
-        "rig/#{@type}/#{@subdomain+'/' if @subdomain}#{@name.downcase}"
+        @binder_require ||= "view/#{subdomain || '_'}/#{type}/#{name.downcase}"
       end
 
       def binder_namespace
-        "#{@domain.name.to_s.camelize}::Rig::#{@type.to_s.capitalize}#{'::' + @subdomain.camelize if @subdomain}"
+        @binder_namespace ||= "#{domain.name.to_s.camelize}::#{subdomain&.camelize}View"
       end
 
       def binder_class_name
-        @name.camelize
+        @binder_class_name ||= @name.camelize
       end
 
       def binder_class
-        @domain.require binder_require
-        "#{binder_namespace}::#{binder_class_name}".constantize
+        @binder_class ||= begin
+          domain.require binder_require
+          "#{binder_namespace}::#{binder_class_name}#{type.to_s.capitalize}".constantize
+        end
       end
 
       private
@@ -176,7 +200,7 @@ module Tzispa
       def create_binder
         ::File.open("#{domain.path}/#{binder_require}.rb", "w") { |f|
           f.puts write_binder_code
-        } if @type == :block
+        } if type == :block
       end
 
       def write_binder_code

data/lib/tzispa/rig/token.rb

@@ -0,0 +1,57 @@
+# frozen_string_literal: true
+
+require 'forwardable'
+
+module Tzispa
+  module Rig
+
+    class Token
+      extend Forwardable
+
+      RE_ANCHOR = /(\$\$\h+\$\$)/
+
+      attr_reader :type, :parser
+      def_delegators :@parser, :domain, :content_type, :template
+
+      def initialize(parser, type)
+        @parser = parser
+        @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]
+        end
+      end
+
+      def anchor
+        @anchor ||= "$$#{"%x" % object_id}$$".freeze
+      end
+
+    end
+
+    require 'tzispa/rig/type_token/api_url'
+    require 'tzispa/rig/type_token/expression'
+    require 'tzispa/rig/type_token/statement'
+    require 'tzispa/rig/type_token/block'
+
+
+  end
+end

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

@@ -0,0 +1,83 @@
+# frozen_string_literal: true
+
+module Tzispa
+  module Rig
+    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
+        end
+
+        def render(binder)
+          b_layout = bind_value(@layout.dup, binder).to_sym
+          h_params = Rig::Parameters.new(bind_value(@params&.dup, binder)).to_h
+          case type
+          when :purl
+            render_purl(binder, app_name, b_layout, h_params)
+          when :url
+            render_url(binder, app_name, b_layout, h_params)
+          end
+        end
+
+        def render_purl(binder, app_name, b_layout, h_params)
+          app_name ?
+            binder.context.app_layout_path(app_name, b_layout, h_params) :
+            binder.context.layout_path(b_layout, h_params)
+        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) :
+            binder.context.layout_canonical_url(b_layout, h_params)
+        end
+
+        def bind_value(value, binder)
+          value&.gsub(RE_ANCHOR) { |match|
+            parser.tokens.select { |p| p.anchor == match}.first.render(binder)
+          }
+        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
+        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.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)
+          }
+        end
+
+      end
+
+    end
+  end
+end

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

@@ -0,0 +1,144 @@
+# frozen_string_literal: true
+
+module Tzispa
+  module Rig
+    module TypeToken
+
+      class Block < Rig::Token
+
+        attr_reader :id, :params
+
+        def initialize(parser, type, id, params)
+          super(parser, type)
+          @id = id
+          @params = params
+        end
+
+        def parse!
+          # to avoid infinite recursion
+          @parsed_block = obtain_block @id
+          parser.childrens << @parsed_block
+          self
+        end
+
+        def render(binder)
+          blk = @parsed_block.dup
+          blk.params = bind_value(@params.dup, binder) if @params
+          blk.render binder.context
+        end
+
+        private
+
+        def bind_value(value, binder)
+          value.gsub(RE_ANCHOR) { |match|
+            parser.tokens.select { |p| p.anchor == match}.first.render(binder)
+          }
+        end
+
+        def obtain_block(id)
+          case id
+          when '__empty__'
+            Rig::Engine.empty
+          when template&.id
+            # to avoid infinite recursion
+            template&.type == :block ?
+              template :
+              Rig::Engine.block(name: id, domain: domain, content_type: content_type)
+          else
+            Rig::Engine.block(name: id, domain: domain, content_type: content_type)
+          end
+        end
+
+
+      end
+
+
+      class IBlock < 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
+        end
+
+        def parse!
+          @block_then = obtain_block @id_then
+          @block_else = obtain_block @id_else
+          parser.childrens << @block_then << @block_else
+          self
+        end
+
+        def render(binder)
+          if binder.data.respond_to?(@id) && binder.data.send(@id)
+            blk = @block_then.dup
+            blk.params = bind_value(@params_then.dup, binder) if @params_then
+          else
+            blk = @block_else.dup
+            blk.params = bind_value(@params_else.dup, binder) if @params_else
+          end
+          blk.render binder.context
+        end
+
+        private
+
+        def obtain_block(id)
+          case id
+          when '__empty__'
+            Rig::Engine.empty
+          when template&.id
+            # to avoid infinite recursion
+            template&.type == :block ?
+              template :
+              Rig::Engine.block(name: id, domain: domain, content_type: content_type)
+          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)
+          }
+        end
+
+      end
+
+
+      class Static < Rig::Token
+
+        attr_reader :id, :params
+
+        def initialize(parser, type, id, params)
+          super(parser, type)
+          @id = id
+          @params = params
+        end
+
+        def parse!
+          @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.render binder.context
+        end
+
+      end
+
+
+    end
+  end
+end

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

@@ -0,0 +1,65 @@
+# frozen_string_literal: true
+
+require 'tzispa/utils/string'
+
+module Tzispa
+  module Rig
+    module TypeToken
+
+      class Meta < Rig::Token
+
+        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}"
+        end
+
+      end
+
+
+      class Var < Rig::Token
+        using Tzispa::Utils
+
+        attr_reader :id
+
+        def initialize(parser, type, format, id)
+          super(parser, type)
+          @format = format
+          @id = id.to_sym
+        end
+
+        def render(binder)
+          if binder.data.respond_to?(@id)
+            value = binder.data.send(@id).to_s
+            value.send(parser.content_escape_method) rescue value
+          else
+            unknown
+          end
+        end
+
+        private
+
+        def unknown
+          @unknown ||= "#{@id}"
+        end
+
+      end
+
+    end
+  end
+end

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

@@ -0,0 +1,73 @@
+# frozen_string_literal: true
+
+require 'forwardable'
+
+module Tzispa
+  module Rig
+    module TypeToken
+
+      class Loop < Rig::Token
+        extend Forwardable
+
+        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
+        end
+
+        def parse!
+          @body_parser = Rig::ParserNext.new(template, text: @body, parent: parser, bindable: true ).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 << body_parser.render(loop_item) if loop_item
+            } if looper
+          }
+        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
+        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
+          self
+        end
+
+        def attribute_tags
+          @attribute_tags ||= [test].concat(then_parser.attribute_tags).concat(else_parser&.attribute_tags || Array.new).compact.uniq.freeze
+        end
+
+        def loop_parser(id)
+          @then_parser.loop_parser(id).concat(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) : ''
+        end
+
+      end
+
+    end
+  end
+end

data/lib/tzispa/rig/version.rb

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

data/lib/tzispa/rig.rb

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