bade 0.1.3

checksums.yaml

@@ -0,0 +1,7 @@
+---
+SHA1:
+  metadata.gz: 77771024dceda938d8320695d2acbd5731588cbb
+  data.tar.gz: 6c0b8f8c0f7cb9d17053599a754f0d28e25ea11c
+SHA512:
+  metadata.gz: 260bd643d97374af1e3209d25d3ad3c98090808191c8f13482e910e10e707f5fa41cf8160007325bf02066eeb0af01ccd603f93a84746bb6f26a8b95286c4259
+  data.tar.gz: 6d9fbcf48c636f38c608bbb37b7096c2e2aadfc208d4bf749fc9e74c87fc2314765752b93fb7124a4a8d663de82749e310bfb12afae38052b26ed4353ef1c78d

data/Bade.gemspec

@@ -0,0 +1,26 @@
+# coding: utf-8
+
+lib = File.expand_path('../lib', __FILE__)
+$LOAD_PATH.unshift(lib) unless $LOAD_PATH.include?(lib)
+
+require 'bade/version'
+
+
+Gem::Specification.new do |spec|
+	spec.name        = 'bade'
+	spec.version     = Bade::VERSION
+	spec.authors     = ['Roman Kříž']
+	spec.email       = ['samnung@gmail.com']
+	spec.summary     = %q{Minimalistic template engine for Ruby.}
+	spec.homepage    = 'https://github.com/samnung/bade'
+	spec.license     = 'MIT'
+
+	spec.files         = Dir['bin/**/*'] + Dir['lib/**/*'] + %w(Bade.gemspec Gemfile README.md)
+	spec.executables   = spec.files.grep(%r{^bin/}) { |f| File.basename(f) }
+	spec.test_files    = spec.files.grep(%r{^(test|spec|features)/})
+	spec.require_paths = ['lib']
+
+	spec.add_development_dependency 'bundler', '~> 1'
+	spec.add_development_dependency 'rspec', '~> 3.2'
+	spec.add_development_dependency 'rake', '~> 10.4'
+end

data/Gemfile

@@ -0,0 +1,4 @@
+source 'https://rubygems.org'
+
+gemspec
+

data/README.md

@@ -0,0 +1,49 @@
+
+# Bade
+
+[![Build Status](https://semaphoreci.com/api/v1/projects/61441d8f-9c6b-41c2-b677-1ef8516649e5/559728/badge.svg)](https://semaphoreci.com/samnung/bade)      
+
+Minimalistic template engine written in Ruby for Ruby. Developed mainly to help with creating e-books. Highly influenced by [Jade](http://jade-lang.com) and [Slim](http://slim-lang.com).
+
+The language is in development state, breaking changes can be made in future. Current version supports minimal list of features to make it working in production for my purposes.
+
+
+## Installation
+
+Add this line to your application's Gemfile:
+
+```ruby
+gem 'bade'
+```
+
+And then execute:
+
+    $ bundle
+
+Or install it yourself as:
+
+    $ gem install bade
+
+
+## Development
+
+After checking out the repo, run `bundle install` to install dependencies. Then, run `rake spec` to run the tests.
+
+To install this gem onto your local machine, run `bundle exec rake install`.
+
+
+## Contributing
+
+Bug reports and pull requests are welcome on GitHub at https://github.com/samnung/bade. This project is intended to be a safe, welcoming space for collaboration, and contributors are expected to adhere to the [Contributor Covenant](contributor-covenant.org) code of conduct.
+
+
+## TODO
+
+- [ ] move all cards from Trello to GitHub
+- [ ] create documentation about syntax
+- [ ] create several examples
+
+
+## License
+
+The gem is available as open source under the terms of the [MIT License](http://opensource.org/licenses/MIT).

data/lib/bade/document.rb

@@ -0,0 +1,33 @@
+
+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

@@ -0,0 +1,80 @@
+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

@@ -0,0 +1,336 @@
+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

data/lib/bade/generator.rb

@@ -0,0 +1,16 @@
+require_relative 'node'
+
+module Bade
+  class Generator
+    require_relative 'generator/html_generator'
+    require_relative 'generator/ruby_generator'
+
+    # @param [Node] root
+    #
+    # @return [Lambda]
+    #
+    def self.node_to_lambda(root, new_line: "\n", indent: "\t", filename: '')
+
+    end
+  end
+end

data/lib/bade/node/doctype_node.rb

@@ -0,0 +1,21 @@
+require_relative '../node'
+
+
+module Bade
+  class DoctypeNode < Node
+    # @return [String]
+    #
+    def xml_output
+      case self.data
+        when 'xml'
+          '<?xml version="1.0" encoding="utf-8" ?>'
+
+        when 'html'
+          '<!DOCTYPE html>'
+
+        else
+          raise Parser::ParserInternalError 'Unknown doctype type'
+      end
+    end
+  end
+end

data/lib/bade/node/key_value_node.rb

@@ -0,0 +1,10 @@
+require_relative '../node'
+
+
+module Bade
+  class KeyValueNode < Node
+    attr_forw_accessor :name, :data
+
+    attr_accessor :value
+  end
+end

data/lib/bade/node/mixin_node.rb

@@ -0,0 +1,69 @@
+require_relative '../node'
+
+
+module Bade
+  class MixinCommonNode < Node
+
+    # @return [Array<Node>]
+    #
+    attr_reader :params
+
+    def initialize(*args)
+      super
+
+      @params = []
+    end
+
+    def << (node)
+      if allowed_parameter_types.include?(node.type)
+        node.parent = self
+        @params << node
+      else
+        super
+      end
+    end
+  end
+
+  class MixinDeclarationNode < MixinCommonNode
+    def allowed_parameter_types
+      [:mixin_param, :mixin_key_param, :mixin_block_param]
+    end
+  end
+
+  class MixinCallNode < MixinCommonNode
+    attr_reader :blocks
+
+    attr_reader :default_block
+
+    def initialize(*args)
+      super
+
+      @blocks = []
+    end
+
+    def allowed_parameter_types
+      [:mixin_param, :mixin_key_param]
+    end
+
+    def << (node)
+      if allowed_parameter_types.include?(node.type)
+        node.parent = self
+        @params << node
+      elsif node.type == :mixin_block
+        node.parent = self
+        @blocks << node
+      else
+        if @default_block.nil?
+          if node.type == :newline
+            # skip newlines at start
+            return self
+          end
+
+          @default_block = Node.create(:mixin_block, self)
+        end
+
+        @default_block << node
+      end
+    end
+  end
+end

data/lib/bade/node/tag_node.rb

@@ -0,0 +1,29 @@
+require_relative '../node'
+
+
+module Bade
+  class TagNode < Node
+    attr_forw_accessor :name, :data
+
+    # @return [Array<TagAttributeNode>]
+    #
+    attr_reader :attributes
+
+    def initialize(*args)
+      super(*args)
+
+      @attributes = []
+    end
+
+    # @param [Node] node
+    #
+    def << (node)
+      if node.type == :tag_attribute
+        node.parent = self
+        @attributes << node
+      else
+        super
+      end
+    end
+  end
+end