bade 0.1.4 → 0.2.0

data/lib/bade/runtime.rb

@@ -1,7 +1,9 @@
+# frozen_string_literal: true
 
 module Epuber
   module Runtime
     require_relative 'runtime/block'
+    require_relative 'runtime/mixin'
     require_relative 'runtime/render_binding'
   end
 end

data/lib/bade/runtime/block.rb

@@ -1,9 +1,32 @@
+# frozen_string_literal: true
 
 module Bade
   module Runtime
     class RuntimeError < ::StandardError; end
 
     class Block
+      class MissingBlockDefinitionError < RuntimeError
+        # @return [String]
+        #
+        attr_accessor :name
+
+        # @return [Symbol] context of missing block, allowed values are :render and :call
+        #
+        attr_accessor :context
+
+        def initialize(name, context, msg = nil)
+          super()
+
+          self.name = name
+          self.context = context
+
+          @message = msg
+        end
+
+        def message
+          @message || "Block `#{name}` must have block definition to #{context}."
+        end
+      end
 
       # @return [Proc]
       #
@@ -13,28 +36,51 @@ module Bade
       #
       attr_reader :name
 
-      # @param [String] name
+      # @return [RenderBinding]
+      #
+      attr_reader :render_binding
+
+      # @param [String] name  name of the block
+      # @param [RenderBinding] render_binding  reference to current binding instance
+      # @param [Proc] block  reference to lambda
       #
-      def initialize(name, &block)
+      def initialize(name, render_binding, &block)
         @name = name
-        @block = lambda &block unless block.nil?
+        @render_binding = render_binding
+        @block = block
       end
 
+      # --- Calling methods
+
       def call(*args)
-        @block.call(*args) unless @block.nil?
+        call!(*args) unless @block.nil?
       end
 
       def call!(*args)
         if @block.nil?
-          raise RuntimeError, "`#{@name}` must have block definition"
+          raise MissingBlockDefinitionError.new(name, :call)
         else
-          @block.call(*args)
+          render_binding.__buff.concat(@block.call(*args))
+        end
+      end
+
+      # --- Rendering methods
+
+      def render(*args)
+        if @block.nil?
+          ''
+        else
+          render!(*args)
         end
       end
-    end
-  end
 
-  def block(name, &block)
-    Runtime::Block.new(name, &block)
+      def render!(*args)
+        if @block.nil?
+          raise MissingBlockDefinitionError.new(name, :render)
+        else
+          @block.call(*args).join
+        end
+      end
+    end
   end
 end

data/lib/bade/runtime/mixin.rb

@@ -0,0 +1,43 @@
+# frozen_string_literal: true
+
+module Bade
+  module Runtime
+    require_relative 'block'
+
+    class Mixin < Block
+      def call!(blocks, *args)
+        block.call(blocks, *args)
+      rescue ArgumentError => e
+        case e.message
+        when /\Awrong number of arguments \(given ([0-9]+), expected ([0-9]+)\)\Z/, /\Awrong number of arguments \(([0-9]+) for ([0-9]+)\)\Z/
+          # handle incorrect parameters count
+
+          # minus one, because first argument is always hash of blocks
+          given = $1.to_i - 1
+          expected = $2.to_i - 1
+          raise ArgumentError, "wrong number of arguments (given #{given}, expected #{expected}) for mixin `#{name}`"
+
+        when /\Aunknown keyword: (.*)\Z/
+          # handle unknown key-value parameter
+          key_name = $1
+          raise ArgumentError, "unknown key-value argument `#{key_name}` for mixin `#{name}`"
+
+        else
+          raise
+        end
+
+      rescue Block::MissingBlockDefinitionError => e
+        msg = case e.context
+              when :call
+                "Mixin `#{name}` requires block to get called of block `#{e.name}`"
+              when :render
+                "Mixin `#{name}` requires block to get rendered content of block `#{e.name}`"
+              else
+                raise ::ArgumentError, "Unknown context #{e.context} of error #{e}!"
+              end
+
+        raise Block::MissingBlockDefinitionError.new(e.name, e.context, msg)
+      end
+    end
+  end
+end

data/lib/bade/runtime/render_binding.rb

@@ -1,3 +1,4 @@
+# frozen_string_literal: true
 
 require_relative 'block'
 
@@ -6,27 +7,70 @@ module Bade
     class RenderBinding
       class KeyError < ::StandardError; end
 
+      # @return [Array<Array<String>>]
+      #
+      attr_accessor :__buffs_stack
+
+      # @return [Hash<String, Mixin>]
+      #
+      attr_accessor :__mixins
+
+      # Holds
+      # @return [String]
+      #
+      attr_accessor :__new_line, :__base_indent
+
       # @param vars [Hash]
       #
       def initialize(vars = {})
-        @vars = vars
+        __reset
+
+        vars.each do |key, value|
+          raise KeyError, "Already defined variable #{key.inspect} in this binding" if respond_to?(key.to_sym)
+
+          define_singleton_method(key) do
+            value
+          end
+        end
       end
 
-      def method_missing(name, *args)
-        raise KeyError, "Not found value for key `#{name}'" unless @vars.key?(name)
-        @vars[name]
+      # Resets this binding to default state, this method should be envoked after running the template lambda
+      #
+      # @return [nil]
+      #
+      def __reset
+        @__buffs_stack = [[]]
+        @__mixins = Hash.new { |_hash, key| raise "Undefined mixin '#{key}'" }
       end
 
       # @return [Binding]
       #
-      def get_binding
+      def __get_binding
         binding
       end
 
       # Shortcut for creating blocks
       #
-      def __create_block(*args, &block)
-        Bade::Runtime::Block.new(*args, &block)
+      def __create_block(name, &block)
+        Bade::Runtime::Block.new(name, self, &block)
+      end
+
+      def __create_mixin(name, &block)
+        Bade::Runtime::Mixin.new(name, self, &block)
+      end
+
+      # --- Methods for dealing with pushing and poping buffers in stack
+
+      def __buff
+        __buffs_stack.last
+      end
+
+      def __buffs_push
+        __buffs_stack.push([])
+      end
+
+      def __buffs_pop
+        __buffs_stack.pop
       end
 
       # Escape input text with html escapes
@@ -35,14 +79,14 @@ module Bade
       #
       # @return [String]
       #
-      def html_escaped(text)
+      def __html_escaped(text)
         text.sub('&', '&amp;')
             .sub('<', '&lt;')
             .sub('>', '&gt;')
             .sub('"', '&quot;')
       end
 
-      def tag_render_attribute(name, *values)
+      def __tag_render_attribute(name, *values)
         values = values.compact
         return if values.empty?
 

data/lib/bade/version.rb

@@ -1,4 +1,5 @@
+# frozen_string_literal: true
 
 module Bade
-  VERSION = '0.1.4'
+  VERSION = '0.2.0'
 end

metadata

@@ -1,14 +1,14 @@
 --- !ruby/object:Gem::Specification
 name: bade
 version: !ruby/object:Gem::Version
-  version: 0.1.4
+  version: 0.2.0
 platform: ruby
 authors:
 - Roman Kříž
 autorequire: 
 bindir: bin
 cert_chain: []
-date: 2015-11-25 00:00:00.000000000 Z
+date: 2016-01-04 00:00:00.000000000 Z
 dependencies:
 - !ruby/object:Gem::Dependency
   name: bundler
@@ -63,21 +63,24 @@ files:
 - Gemfile
 - README.md
 - lib/bade.rb
-- lib/bade/document.rb
+- lib/bade/ast/document.rb
+- lib/bade/ast/node.rb
+- lib/bade/ast/node/doctype_node.rb
+- lib/bade/ast/node/key_value_node.rb
+- lib/bade/ast/node/mixin_node.rb
+- lib/bade/ast/node/tag_node.rb
+- lib/bade/ast/node/value_node.rb
+- lib/bade/ast/node_registrator.rb
+- lib/bade/ast/string_serializer.rb
 - lib/bade/generator.rb
-- lib/bade/generator/html_generator.rb
-- lib/bade/generator/ruby_generator.rb
-- lib/bade/node.rb
-- lib/bade/node/doctype_node.rb
-- lib/bade/node/key_value_node.rb
-- lib/bade/node/mixin_node.rb
-- lib/bade/node/tag_node.rb
 - lib/bade/parser.rb
+- lib/bade/precompiled.rb
 - lib/bade/renderer.rb
-- lib/bade/ruby_extensions/object.rb
+- lib/bade/ruby_extensions/array.rb
 - lib/bade/ruby_extensions/string.rb
 - lib/bade/runtime.rb
 - lib/bade/runtime/block.rb
+- lib/bade/runtime/mixin.rb
 - lib/bade/runtime/render_binding.rb
 - lib/bade/version.rb
 homepage: https://github.com/epuber-io/bade
@@ -92,7 +95,7 @@ required_ruby_version: !ruby/object:Gem::Requirement
   requirements:
   - - ">="
     - !ruby/object:Gem::Version
-      version: '0'
+      version: '2.0'
 required_rubygems_version: !ruby/object:Gem::Requirement
   requirements:
   - - ">="
@@ -100,9 +103,8 @@ required_rubygems_version: !ruby/object:Gem::Requirement
       version: '0'
 requirements: []
 rubyforge_project: 
-rubygems_version: 2.4.8
+rubygems_version: 2.5.1
 signing_key: 
 specification_version: 4
 summary: Minimalistic template engine for Ruby.
 test_files: []
-has_rdoc: 

data/lib/bade/document.rb

@@ -1,33 +0,0 @@
-
-require_relative 'node'
-
-
-module Bade
-  class Document
-    # Root node of this document
-    #
-    # @return [Bade::Node]
-    #
-    attr_accessor :root
-
-    # Path to this document, but only if it is defined from file
-    #
-    # @return [String, nil]
-    #
-    attr_reader :file_path
-
-    # @return [Array<Bade::Document>]
-    #
-    attr_reader :sub_documents
-
-    # @param root [Bade::Node]
-    #
-    def initialize(root: nil, file_path: nil)
-      @root = root || Node.new(:root)
-      @root.parent = self
-
-      @file_path = file_path
-      @sub_documents = []
-    end
-  end
-end

data/lib/bade/generator/html_generator.rb

@@ -1,80 +0,0 @@
-require_relative '../generator'
-
-module Bade
-  class HTMLGenerator < Generator
-
-    # @param [Node] root node
-    # @return [String]
-    #
-    def self.node_to_lambda(root, new_line: "\n", indent: "\t")
-      str = node_to_html_array(root, new_line: new_line, indent: indent).join
-
-      lambda {
-        str
-      }
-    end
-
-
-    private
-
-    # @param [Node] root node
-    # @return [Array<String>]
-    #
-    def self.node_to_html_array(root, new_line: "\n", indent: "\t", indent_level: 0)
-      unless root.kind_of? Node
-        return [ root.inspect ]
-      end
-
-      buff = []
-
-      if indent_level > 0 and not indent.empty?
-        buff << indent * indent_level
-      end
-
-      append_childrens = lambda { |indent_plus|
-        root.childrens.each { |node|
-          buff += node_to_html_array(node, new_line: new_line, indent: indent, indent_level: indent_level+indent_plus)
-        }
-      }
-
-
-      case root.type
-        when :root
-          append_childrens.call(0)
-
-        when :text
-          buff << root.data
-
-        when :tag
-          attributes = formatted_attributes root
-
-          if attributes.length > 0
-            buff << "<#{root.data} #{attributes}>" + new_line
-          else
-            buff << "<#{root.data}>" + new_line
-          end
-
-          append_childrens.call(1)
-
-          buff << "</#{root.data}>" + new_line
-      end
-
-      buff
-    end
-
-    # @param [Node] tag_node
-    #
-    # @return [String] formatted attributes
-    #
-    def self.formatted_attributes(tag_node)
-
-      attributes = tag_node.childrens.select { |child|
-        child.type == :tag_attribute
-      }.map { |attr|
-        "#{attr.data}=\"#{attr.childrens.first.data}\""
-      }
-
-      attributes.join ' '
-    end
-  end
-end

data/lib/bade/generator/ruby_generator.rb

@@ -1,336 +0,0 @@
-require_relative '../generator'
-require_relative '../runtime'
-require_relative '../document'
-
-module Bade
-  class RubyGenerator < Generator
-
-    BUFF_NAME = '__buff'
-    MIXINS_NAME = '__mixins'
-    START_STRING =	"
-lambda {
-  #{BUFF_NAME} = []
-  #{MIXINS_NAME} = Hash.new { |hash, key| raise \"Undefined mixin '\#{key}'\" }
-"
-
-    END_STRING =	"
-  #{BUFF_NAME}.join
-}"
-
-    # @param [Document] document
-    #
-    # @return [Proc]
-    #
-    def self.document_to_lambda(document, new_line: "\n", indent: "\t", filename: '')
-      generator = self.new(new_line, indent)
-      generator.generate_lambda(document, filename)
-    end
-
-    # @param [Document] document
-    #
-    # @return [String]
-    #
-    def self.document_to_lambda_string(document, new_line: "\n", indent: "\t", filename: '')
-      generator = self.new(new_line, indent)
-      generator.generate_lambda_string(document)
-    end
-
-
-
-    # @param [String] new_line_string
-    # @param [String] indent_string
-    #
-    def initialize(new_line_string, indent_string)
-      @new_line_string = new_line_string
-      @indent_string = indent_string
-    end
-
-    # @param [Document] document
-    # @param [String] filename
-    #
-    def generate_lambda(document, filename)
-      eval(generate_lambda_string(document), nil, filename)
-    end
-
-    # @param [Document] document
-    #
-    # @return [String] string to parse with Ruby
-    #
-    def generate_lambda_string(document)
-      @buff = []
-      @indent = 0
-      @code_indent = 1
-
-      @buff << START_STRING
-
-      visit_document(document)
-
-      @buff << END_STRING
-
-      @buff.join("\n")
-    end
-
-    # @param [String] text
-    #
-    def buff_print_text(text, indent: false, new_line: false)
-      indent_text = if indent
-                      @indent_string * @indent
-                    else
-                      ''
-                    end
-
-      prepended_text = indent_text + text
-
-      if prepended_text.length > 0
-        buff_code %Q{#{BUFF_NAME} << %Q{#{prepended_text}}}
-      end
-    end
-
-    def buff_code(text)
-      @buff << "\t" * @code_indent + text
-    end
-
-
-    # @param document [Bade::Document]
-    #
-    def visit_document(document)
-      document.sub_documents.each do |sub_document|
-        visit_document(sub_document)
-      end
-
-      buff_code("# ----- start file #{document.file_path}") unless document.file_path.nil?
-      visit_node(document.root)
-      buff_code("# ----- end file #{document.file_path}") unless document.file_path.nil?
-    end
-
-    # @param current_node [Node]
-    #
-    def visit_node_childrens(current_node)
-      visit_nodes(current_node.childrens)
-    end
-
-    # @param nodes [Array<Node>]
-    #
-    def visit_nodes(nodes)
-      nodes.each { |node|
-        visit_node(node)
-      }
-    end
-
-    # @param current_node [Node]
-    #
-    def visit_node(current_node)
-      case current_node.type
-        when :root
-          visit_node_childrens(current_node)
-
-        when :text
-          buff_print_text current_node.data
-
-        when :tag
-          visit_tag(current_node)
-
-        when :ruby_code
-          buff_code current_node.data
-
-        when :html_comment
-          buff_print_text '<!-- '
-          visit_node_childrens(current_node)
-          buff_print_text ' -->'
-
-        when :comment
-          comment_text = current_node.childrens.select { |node|
-            !node.data.nil?
-          }.map { |node|
-            node.data
-          }.join(@new_line_string + '#')
-
-          buff_code '#' + comment_text
-
-        when :doctype
-          buff_print_text current_node.xml_output
-
-        when :mixin_declaration
-          params = formatted_mixin_params(current_node)
-          buff_code "#{MIXINS_NAME}['#{current_node.data}'] = lambda { |#{params}|"
-
-          indent {
-            blocks_name_declaration(current_node)
-            visit_node_childrens(current_node)
-          }
-
-          buff_code '}'
-
-        when :mixin_call
-          params = formatted_mixin_params(current_node)
-          buff_code "#{MIXINS_NAME}['#{current_node.data}'].call(#{params})"
-
-        when :output
-          data = current_node.data
-          output_code = if current_node.escaped
-                          "\#{html_escaped(#{data})}"
-                        else
-                          "\#{#{data}}"
-                        end
-          buff_print_text output_code
-
-        when :newline
-          buff_print_text @new_line_string if @new_line_string.length > 0
-
-        when :import
-          # nothing
-
-        else
-          raise "Unknown type #{current_node.type}"
-      end
-    end
-
-    # @param [TagNode] current_node
-    #
-    def visit_tag(current_node)
-      attributes = formatted_attributes current_node
-
-      text = "<#{current_node.name}"
-
-      if attributes.length > 0
-        text += "#{attributes}"
-      end
-
-      other_than_new_lines = current_node.childrens.any? { |node|
-        node.type != :newline
-      }
-
-      if other_than_new_lines
-        text += '>'
-      else
-        text += '/>'
-      end
-
-      buff_print_text text, new_line: true, indent: true
-
-      if other_than_new_lines
-        last_node = current_node.childrens.last
-        is_last_newline = !last_node.nil? && last_node.type == :newline
-        nodes = if is_last_newline
-                  current_node.childrens[0...-1]
-                else
-                  current_node.childrens
-                end
-
-        indent do
-          visit_nodes(nodes)
-        end
-
-        buff_print_text "</#{current_node.name}>", new_line: true, indent: true
-
-        # print new line after the tag
-        visit_node(last_node) if is_last_newline
-      end
-    end
-
-    # @param [TagNode] tag_node
-    #
-    # @return [String] formatted attributes
-    #
-    def formatted_attributes(tag_node)
-      all_attributes = Hash.new { |hash, key| hash[key] = [] }
-      xml_attributes = []
-
-      tag_node.attributes.each do |attr|
-        unless all_attributes.include?(attr.name)
-          xml_attributes << attr.name
-        end
-
-        all_attributes[attr.name] << attr.value
-      end
-
-      xml_attributes.map do |attr_name|
-        joined = all_attributes[attr_name].join('), (')
-        %Q{\#{tag_render_attribute('#{attr_name}', (#{joined}))}}
-      end.join
-    end
-
-    def indent(plus = 1)
-      @code_indent += plus
-      yield
-      @code_indent -= plus
-    end
-
-    # @param [MixinCommonNode] mixin_node
-    #
-    # @return [String] formatted params
-    #
-    def formatted_mixin_params(mixin_node)
-      params = mixin_node.params
-      result = []
-
-
-
-      if mixin_node.type == :mixin_call
-        if mixin_node.blocks.length > 0
-          buff_code '__blocks = {}'
-
-          mixin_node.blocks.each { |block|
-            block_name = block.data ? block.data : 'default_block'
-            buff_code "__blocks['#{block_name}'] = __create_block('#{block_name}') do"
-            indent {
-              visit_node_childrens(block)
-            }
-            buff_code 'end'
-          }
-
-          result << '__blocks.dup'
-        else
-          result << '{}'
-        end
-      elsif mixin_node.type == :mixin_declaration
-        result << '__blocks'
-      end
-
-
-      # normal params
-      result += params.select { |param|
-        param.type == :mixin_param
-      }.map { |param|
-        param.data
-      }
-
-      result += params.select { |param|
-        param.type == :mixin_key_param
-      }.map { |param|
-        "#{param.name}: #{param.value}"
-      }
-
-      result.join(', ')
-    end
-
-
-    # @param [String] block_name
-    #
-    def block_name_declaration(block_name)
-      buff_code "#{block_name} = __blocks.delete('#{block_name}') { __create_block('#{block_name}') }"
-    end
-
-    # @param [MixinDeclarationNode] mixin_node
-    #
-    def blocks_name_declaration(mixin_node)
-      mixin_node.params.select { |param|
-        param.type == :mixin_block_param
-      }.each { |param|
-        block_name_declaration(param.data)
-      }
-
-      block_name_declaration('default_block')
-    end
-
-
-
-    # @param [String] str
-    #
-    # @return [Void]
-    #
-    def escape_double_quotes!(str)
-      str.gsub!(/"/, '\"')
-    end
-  end
-end