bade 0.1.4 → 0.2.0

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA1:
-  metadata.gz: 7fce9a16c6a092fa176cd6adf94f87f09dc805ef
-  data.tar.gz: dd198f4a76c878eac584c0a03c5269f6174055c2
+  metadata.gz: ab630e2e6b7eec2139fbc4b14699985eefed370a
+  data.tar.gz: a132ae2fd1e1fd2d39dc8a9957f1e410dfcc821b
 SHA512:
-  metadata.gz: 18c57022d6ababf11353a754bf99890fab414b21b6e4e64542f2543a8f79a74b53f1548555ffee7bfb0757932d651290bdf7b4b464889c11bbd8e105f1d755e1
-  data.tar.gz: 4fc5473929741d309c794671c2508dea40a60f42ea2f8910756f8fcbc42c32aa1accf9bfd4fa9d41501ec3cef2324e9bb0a669a483be19a21739bd41062051e7
+  metadata.gz: 2624ab09740f0ee43309ffef7de6d5508e3880576ee0c461902b5762012c096ce7e829dcab577f1913fc29755956dc0cee256168e8d45bb579c3e81e9f6e0478
+  data.tar.gz: f859d3d06ca8bc9d1303c6afe7fa96f5a8e5a8a96d6c2d0bd67542392c2a9e4c29bb5736254786f051a6408b72db94ea41fabe415f7cdd10637ac3b26e2dea1b

data/Bade.gemspec

@@ -14,6 +14,7 @@ Gem::Specification.new do |spec|
 	spec.summary     = %q{Minimalistic template engine for Ruby.}
 	spec.homepage    = 'https://github.com/epuber-io/bade'
 	spec.license     = 'MIT'
+	spec.required_ruby_version = '>= 2.0'
 
 	spec.files         = Dir['bin/**/*'] + Dir['lib/**/*'] + %w(Bade.gemspec Gemfile README.md)
 	spec.executables   = spec.files.grep(%r{^bin/}) { |f| File.basename(f) }

data/Gemfile

@@ -3,3 +3,6 @@ source 'https://rubygems.org'
 gemspec
 
 gem 'coveralls', require: false
+gem 'benchmark-ips', require: false
+gem 'ruby-prof'
+gem 'flamegraph'

data/README.md

@@ -8,6 +8,8 @@ Minimalistic template engine written in Ruby for Ruby. Developed mainly to help
 
 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.
 
+This gem acts only as library, it does not provide CLI tool, yet.
+
 
 ## Installation
 
@@ -19,7 +21,7 @@ gem 'bade'
 
 And then execute:
 
-    $ bundle
+    $ bundle install
 
 Or install it yourself as:
 
@@ -40,7 +42,6 @@ Bug reports and pull requests are welcome on GitHub at https://github.com/epuber
 
 ## TODO
 
-- [ ] move all cards from Trello to GitHub
 - [ ] create documentation about syntax
 - [ ] create several examples
 

data/lib/bade.rb

@@ -1,3 +1,4 @@
+# frozen_string_literal: true
 
 module Bade
   require_relative 'bade/version'

data/lib/bade/ast/document.rb

@@ -0,0 +1,53 @@
+# frozen_string_literal: true
+
+require_relative 'node'
+
+
+module Bade
+  module AST
+    class Document
+      # Root node of this document
+      #
+      # @return [Bade::Node]
+      #
+      attr_reader :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: Node.new(:root), file_path: nil)
+        @root = root
+
+        @file_path = file_path.dup.freeze unless file_path.nil?
+        @sub_documents = []
+      end
+
+      def freeze
+        super
+
+        root.freeze
+        sub_documents.freeze
+        sub_documents.each(&:freeze)
+      end
+
+      # @param other [Bade::Document]
+      #
+      # @return [Bool]
+      #
+      def ==(other)
+        return false unless Document === other
+
+        root == other.root && sub_documents == other.sub_documents
+      end
+    end
+  end
+end

data/lib/bade/ast/node.rb

@@ -0,0 +1,50 @@
+# frozen_string_literal: true
+
+
+module Bade
+  module AST
+    class Node
+      # --- MAIN INFO ---
+
+      # @return [Symbol] type of this node
+      #
+      attr_reader :type
+
+      # @return [Array<Bade::Node>]
+      #
+      attr_accessor :children
+
+      # --- METADATA ---
+
+      # @return [Int] line number
+      #
+      attr_reader :lineno
+
+      def initialize(type, lineno: nil)
+        @type = type
+        @children = []
+
+        @lineno = lineno
+      end
+
+      def to_s
+        require_relative 'string_serializer'
+        StringSerializer.new(self).to_s
+      end
+
+      def inspect
+        to_s
+      end
+
+      # @param other [Node]
+      #
+      # @return [Bool]
+      #
+      def ==(other)
+        return false unless self.class == other.class
+
+        type == other.type && children == other.children
+      end
+    end
+  end
+end

data/lib/bade/ast/node/doctype_node.rb

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

data/lib/bade/ast/node/key_value_node.rb

@@ -0,0 +1,21 @@
+# frozen_string_literal: true
+
+module Bade
+  module AST
+    class KeyValueNode < Node
+      # @return [String]
+      #
+      attr_accessor :name
+
+      # @return [Any]
+      #
+      attr_accessor :value
+
+      # @param other [KeyValueNode]
+      #
+      def ==(other)
+        super && name == other.name && value == other.value
+      end
+    end
+  end
+end

data/lib/bade/ast/node/mixin_node.rb

@@ -0,0 +1,45 @@
+# frozen_string_literal: true
+
+module Bade
+  module AST
+    class MixinCommonNode < Node
+      # @return [String]
+      #
+      attr_accessor :name
+
+      # @return [Array<Node>]
+      #
+      def params
+        children.select { |n| allowed_parameter_types.include?(n.type) }
+      end
+
+      # @param [MixinCommonNode] other
+      #
+      def ==(other)
+        super && name == other.name
+      end
+    end
+
+    class MixinDeclarationNode < MixinCommonNode
+      def allowed_parameter_types
+        [:mixin_param, :mixin_key_param, :mixin_block_param]
+      end
+    end
+
+    class MixinBlockNode < MixinCommonNode
+      def allowed_parameter_types
+        [:mixin_param, :mixin_key_param]
+      end
+    end
+
+    class MixinCallNode < MixinCommonNode
+      def allowed_parameter_types
+        [:mixin_param, :mixin_key_param]
+      end
+
+      def blocks
+        children.select { |a| a.type == :mixin_block }
+      end
+    end
+  end
+end

data/lib/bade/ast/node/tag_node.rb

@@ -0,0 +1,23 @@
+# frozen_string_literal: true
+
+module Bade
+  module AST
+    class TagNode < Node
+      # @return [String]
+      #
+      attr_accessor :name
+
+      # @param [TagNode] other
+      #
+      def ==(other)
+        super && name == other.name
+      end
+
+      # @return [Array<KeyValueNode>]
+      #
+      def attributes
+        children.select { |n| n.type == :tag_attr }
+      end
+    end
+  end
+end

data/lib/bade/ast/node/value_node.rb

@@ -0,0 +1,32 @@
+# frozen_string_literal: true
+
+module Bade
+  module AST
+    class ValueNode < Node
+      # @return [String]
+      #
+      attr_accessor :value
+
+      # @return [Bool]
+      #
+      attr_accessor :escaped
+
+      # @return [Bool]
+      #
+      attr_accessor :conditional
+
+      def initialize(*args)
+        super
+
+        @escaped = false
+        @conditional = false
+      end
+
+      # @param [ValueNode] other
+      #
+      def ==(other)
+        super && value == other.value && escaped == other.escaped && conditional == other.conditional
+      end
+    end
+  end
+end

data/lib/bade/ast/node_registrator.rb

@@ -0,0 +1,82 @@
+# frozen_string_literal: true
+
+
+module Bade
+  module AST
+    class NodeRegistrator
+      require_relative 'node/key_value_node'
+      require_relative 'node/tag_node'
+      require_relative 'node/value_node'
+      require_relative 'node/mixin_node'
+      require_relative 'node/doctype_node'
+
+      class << self
+        # @return [Hash<Symbol, Class>]
+        #
+        def registered_types
+          @registered_types ||= {}
+        end
+
+        # Method to map some node type to backing node class
+        #
+        # @param [Symbol] type  type of the node
+        # @param [Class] klass  registering class
+        #
+        # @return [nil]
+        #
+        def register_type(klass, type)
+          raise StandardError, "Class #{klass} should be subclass of #{Node}" unless klass <= Node
+
+          registered_types[type] = klass
+        end
+
+        # Method to create node backing instance
+        #
+        # @param [Symbol] type  type of the node
+        # @param [Fixnum] lineno  line number of the node appearance
+        #
+        # @return [Bade::AST::Node]
+        #
+        def create(type, lineno)
+          klass = registered_types[type]
+
+          if klass.nil?
+            raise ::KeyError, "Undefined node type #{type.inspect}"
+          end
+
+          klass.new(type, lineno: lineno)
+        end
+      end
+
+      register_type ValueNode, :text
+      register_type ValueNode, :newline
+      register_type ValueNode, :code
+      register_type ValueNode, :output
+
+      register_type DoctypeNode, :doctype
+
+      register_type ValueNode, :import
+
+      # --- Comments
+
+      register_type Node, :comment
+      register_type Node, :html_comment
+
+      # --- Tags
+
+      register_type TagNode, :tag
+      register_type KeyValueNode, :tag_attr
+
+      # --- Mixins
+
+      register_type ValueNode, :mixin_param
+      register_type KeyValueNode, :mixin_key_param
+      register_type ValueNode, :mixin_block_param
+
+      register_type MixinBlockNode, :mixin_block
+
+      register_type MixinCallNode, :mixin_call
+      register_type MixinDeclarationNode, :mixin_decl
+    end
+  end
+end

data/lib/bade/ast/string_serializer.rb

@@ -0,0 +1,72 @@
+# frozen_string_literal: true
+
+
+module Bade
+  module AST
+    class StringSerializer
+      # @return [AST::Node, AST::Document]
+      #
+      attr_reader :root
+
+      # @param [AST::Node, AST::Document] root
+      #
+      def initialize(root)
+        @root = root
+      end
+
+      def to_s
+        case root
+        when Node
+          node_to_s(root, 0)
+        when Document
+          node_to_s(root.root, 0)
+        else
+          raise AttributeError, "Root attribute passed into initializer must be subclass of #{Node} or #{Document}, is #{root.class}!"
+        end
+      end
+
+      # @param [Node] node
+      # @param [Fixnum] level
+      #
+      # @return [String]
+      #
+      def node_to_s(node, level)
+        type_s = node.type.inspect
+        indent = '  ' * level
+
+        children_s = ''
+        if node.children.count > 0
+          children_s = "\n" + node.children.map { |n| node_to_s(n, level + 1) }.join("\n") + "\n#{indent}"
+        end
+
+        other = ''
+
+        case node
+        when TagNode
+          other = node.name
+        when KeyValueNode
+          other = "#{node.name}:#{node.value}"
+        when ValueNode
+          escaped_sign = if node.escaped
+                           '& '
+                         elsif node.escaped.nil?
+                           '&(nil) '
+                         else
+                           ''
+                         end
+          other = "#{escaped_sign}#{node.value}"
+        when MixinCommonNode
+          other = node.name
+        when Node
+          # nothing
+        else
+          raise "Unknown node class #{node.class} of type #{node.type} for serializing"
+        end
+
+        other = ' ' + other if other && other.length > 0
+
+        "#{indent}(#{type_s}#{other}#{children_s})"
+      end
+    end
+  end
+end