bade 0.1.4 → 0.2.0

data/lib/bade/precompiled.rb

@@ -0,0 +1,61 @@
+# frozen_string_literal: true
+
+require 'yaml'
+
+
+module Bade
+  class Precompiled
+    # @return [String]
+    #
+    attr_accessor :code_string
+
+    # @return [String]
+    #
+    attr_accessor :source_file_path
+
+    # # @return [Proc]
+    # #
+    # attr_accessor :lambda_instance
+
+    # @param [String, File] file  file instance or path to file
+    #
+    def self.from_yaml_file(file)
+      file = if file.is_a?(String)
+               File.new(file, 'r')
+             else
+               file
+             end
+
+      hash = YAML.load(file)
+      file_path = hash[:source_file_path]
+      content = hash[:code_string]
+
+      new(content, file_path)
+    end
+
+    # @param [String] code
+    #
+    def initialize(code, source_file_path = nil)
+      @code_string = code
+      @source_file_path = source_file_path
+    end
+
+    # @param [String, File] file  file instance or path to file
+    #
+    def write_yaml_to_file(file)
+      file = if file.is_a?(String)
+               File.new(file, 'w')
+             else
+               file
+             end
+
+      content = {
+          source_file_path: source_file_path,
+          code_string: code_string,
+      }.to_yaml
+
+      file.write(content)
+      file.flush
+    end
+  end
+end

data/lib/bade/renderer.rb

@@ -1,12 +1,36 @@
+# frozen_string_literal: true
 
-require_relative 'node'
+require 'pathname'
 require_relative 'parser'
 require_relative 'generator'
 require_relative 'runtime'
+require_relative 'precompiled'
 
 
 module Bade
   class Renderer
+    class LoadError < ::LoadError
+      # @return [String]
+      #
+      attr_reader :loading_path
+
+      # @return [String]
+      #
+      attr_reader :reference_path
+
+      # @param [String] loading_path  currently loaded path
+      # @param [String] reference_path  reference file from which is load performed
+      # @param [String] msg  standard message
+      #
+      def initialize(loading_path, reference_path, msg=nil)
+        super(msg)
+        @loading_path = loading_path
+        @reference_path = reference_path
+      end
+    end
+
+    TEMPLATE_FILE_NAME = '(__template__)'
+
     # @return [String]
     #
     attr_accessor :source_text
@@ -19,9 +43,31 @@ module Bade
     #
     attr_accessor :locals
 
-    # @param source [String]
+    # @return [Binding]
     #
-    # @return [self]
+    attr_accessor :lambda_binding
+
+    # @return [RenderBinding]
+    #
+    attr_accessor :render_binding
+
+
+    # ----------------------------------------------------------------------------- #
+    # Internal attributes
+
+    # @return [Hash<String, Document>] absolute path => document
+    #
+    def parsed_documents
+      @parsed_documents ||= {}
+    end
+
+
+    # ----------------------------------------------------------------------------- #
+    # Factory methods
+
+    # @param [String] source  source string that should be parsed
+    #
+    # @return [Renderer] preconfigured instance of this class
     #
     def self.from_source(source, file_path = nil)
       inst = new
@@ -30,9 +76,9 @@ module Bade
       inst
     end
 
-    # @param file [String, File]
+    # @param [String, File] file  file path or file instance, file that should be loaded and parsed
     #
-    # @return [self]
+    # @return [Renderer] preconfigured instance of this class
     #
     def self.from_file(file)
       path = if file.is_a?(File)
@@ -44,13 +90,18 @@ module Bade
       from_source(nil, path)
     end
 
-
-    def initialize
-      # absolute path => document
-      @parsed_documents = {}
+    # Method to create Renderer from Precompiled object, for example when you want to reuse precompiled object from disk
+    #
+    # @param [Precompiled] precompiled
+    #
+    # @return [Renderer] preconfigured instance of this class
+    #
+    def self.from_precompiled(precompiled)
+      inst = new
+      inst.precompiled = precompiled
+      inst
     end
 
-
     # ----------------------------------------------------------------------------- #
     # DSL methods
 
@@ -60,76 +111,145 @@ module Bade
     # @return [self]
     #
     def with_locals(locals = {})
+      self.render_binding = nil
+
       self.locals = locals
       self
     end
 
+    def with_binding(binding)
+      self.lambda_binding = binding
+      self
+    end
+
 
     # ----------------------------------------------------------------------------- #
     # Getters
 
-    # @return [Bade::Node]
+    # @return [Bade::AST::Node]
     #
     def root_document
-      @parsed ||= _parsed_document(source_text, file_path)
+      @root_document ||= _parsed_document(source_text, file_path)
+    end
+
+    # @return [Precompiled]
+    #
+    attr_writer :precompiled
+
+    # @return [Precompiled]
+    #
+    def precompiled
+      @precompiled ||= Precompiled.new(Generator.document_to_lambda_string(root_document), file_path)
     end
 
     # @return [String]
     #
-    def lambda_string(new_line: '\n', indent: '  ')
-      RubyGenerator.document_to_lambda_string(root_document, new_line: new_line, indent: indent)
+    def lambda_string
+      precompiled.code_string
     end
 
+    # @return [RenderBinding]
+    #
+    def render_binding
+      @render_binding ||= Runtime::RenderBinding.new(locals || {})
+    end
+
+    # @return [Proc]
+    #
+    def lambda_instance
+      if lambda_binding
+        lambda_binding.eval(lambda_string, file_path || TEMPLATE_FILE_NAME)
+      else
+        render_binding.instance_eval(lambda_string, file_path || TEMPLATE_FILE_NAME)
+      end
+    end
 
     # ----------------------------------------------------------------------------- #
     # Render
 
-    # @return [String]
+    # @param [Binding] binding  custom binding for evaluating the template, but it is not recommended to use, use :locals and #with_locals instead
+    # @param [String] new_line  newline string, default is \n
+    # @param [String] indent  indent string, default is two spaces
     #
-    def render(binding: nil, new_line: '\n', indent: '  ')
-      lambda_str = lambda_string(new_line: new_line, indent: indent)
-      scope = binding || Runtime::RenderBinding.new(locals || {}).get_binding
+    # @return [String] rendered content of template
+    #
+    def render(binding: nil, new_line: nil, indent: nil)
+      self.lambda_binding = binding unless binding.nil? # backward compatibility
+
+      run_vars = {
+          Generator::NEW_LINE_NAME.to_sym => new_line,
+          Generator::BASE_INDENT_NAME.to_sym => indent,
+      }
+      run_vars.reject! { |_key, value| value.nil? } # remove nil values
 
-      lambda_instance = eval(lambda_str, scope, file_path || '(__template__)')
-      lambda_instance.call
+      lambda_instance.call(**run_vars)
     end
 
 
 
     private
 
-    # @param file_path [String]
+    # @param [String] content  source code of the template
+    # @param [String] file_path  reference path to template file
     #
-    # @return [Bade::Document]
+    # @return [Bade::AST::Document]
     #
     def _parsed_document(content, file_path)
       content = if file_path.nil? && content.nil?
-                  raise LoadError, "Don't know what to do with nil values for both content and path"
+                  raise LoadError.new(nil, file_path, "Don't know what to do with nil values for both content and path")
                 elsif !file_path.nil? && content.nil?
                   File.read(file_path)
                 else
                   content
                 end
 
-      parsed_document = @parsed_documents[file_path]
+      parsed_document = parsed_documents[file_path]
       return parsed_document unless parsed_document.nil?
 
       parser = Parser.new(file_path: file_path)
-
       document = parser.parse(content)
 
       parser.dependency_paths.each do |path|
-        sub_path = File.expand_path(path, File.dirname(file_path))
-        new_path = if File.exists?(sub_path)
-                     sub_path
-                   elsif File.exists?("#{sub_path}.bade")
-                     "#{sub_path}.bade"
-                   end
+        new_path = _find_file!(path, file_path)
+        next if new_path.nil?
 
         document.sub_documents << _parsed_document(nil, new_path)
       end
 
       document
     end
+
+    # Tries to find file with name, if no file could be found or there are multiple files matching the name error is raised
+    #
+    # @param [String] name  name of the file that should be found
+    # @param [String] reference_path  path to file from which is loading/finding
+    #
+    # @return [String, nil] returns nil when this file should be skipped otherwise absolute path to file
+    #
+    def _find_file!(name, reference_path)
+      sub_path = File.expand_path(name, File.dirname(reference_path))
+
+      if File.exists?(sub_path)
+        return if sub_path.end_with?('.rb') # handled in Generator
+        sub_path
+      else
+        bade_path = "#{sub_path}.bade"
+        rb_path = "#{sub_path}.rb"
+
+        bade_exist = File.exists?(bade_path)
+        rb_exist = File.exists?(rb_path)
+        relative = Pathname.new(reference_path).relative_path_from(Pathname.new(File.dirname(self.file_path))).to_s
+
+        if bade_exist && rb_exist
+          raise LoadError.new(name, reference_path, "Found both .bade and .rb files for `#{name}` in file #{relative}, change the import path so it references uniq file.")
+        elsif bade_exist
+          return bade_path
+        elsif rb_exist
+          return # handled in Generator
+        else
+          raise LoadError.new(name, reference_path, "Can't find file matching name `#{name}` referenced from file #{relative}")
+        end
+      end
+    end
   end
 end

data/lib/bade/ruby_extensions/array.rb

@@ -0,0 +1,45 @@
+# frozen_string_literal: true
+
+class Array
+  # Returns index of last matching item when iterating from back to start of +self+.
+  #
+  # Returns nil when the first item does not match (when iterating from back).
+  #
+  # @return [Fixnum]
+  #
+  def rindex_last_matching(&block)
+    return nil if empty?
+
+    index = nil
+
+    current_index = count - 1
+    reverse_each do |item|
+      if block.call(item)
+        index = current_index
+        current_index -= 1
+      else
+        break
+      end
+    end
+
+    index
+  end
+
+  # Returns count of items that matches, iteration starts at the end and stops on first not matching item.
+  #
+  # @return [Fixnum] count of items
+  #
+  def rcount_matching(&block)
+    count = 0
+
+    reverse_each do |item|
+      if block.call(item)
+        count += 1
+      else
+        break
+      end
+    end
+
+    count
+  end
+end

data/lib/bade/ruby_extensions/string.rb

@@ -1,4 +1,8 @@
+# frozen_string_literal: true
+
 class String
+  SPACE_CHAR = ' '
+  TAB_CHAR = "\t"
 
   # Creates new string surrounded by single quotes
   #
@@ -9,30 +13,37 @@ class String
   end
 
 
-  # Remove indent
-  #
-  # @param [Int] indent
-  # @param [Int] tabsize
-  #
-  def remove_indent(indent, tabsize)
-    self.dup.remove_indent!(indent, tabsize)
+  def blank?
+    strip.length == 0
   end
 
 
-  # Remove indent
-  #
-  # @param [Int] indent
-  # @param [Int] tabsize
-  #
-  def remove_indent!(indent, tabsize)
+  def remove_last(count = 1)
+    slice(0, length - count)
+  end
+
+  def remove_last!(count = 1)
+    slice!(length - count, count)
+  end
+
+
+  def remove_first(count = 1)
+    slice(count, length - count)
+  end
+
+  def remove_first!(count = 1)
+    slice!(0, count)
+  end
+
+  def __chars_count_for_indent(indent, tabsize)
     count = 0
     self.each_char do |char|
+      break if indent <= 0
 
-      if indent <= 0
-        break
-      elsif char == ' '
+      case char
+      when SPACE_CHAR
         indent -= 1
-      elsif char == "\t"
+      when TAB_CHAR
         if indent - tabsize < 0
           raise StandardError, 'malformed tabs'
         end
@@ -45,7 +56,26 @@ class String
       count += 1
     end
 
-    self[0 ... self.length] = self[count ... self.length]
+    count
+  end
+
+  # Remove indent
+  #
+  # @param [Int] indent
+  # @param [Int] tabsize
+  #
+  def remove_indent(indent, tabsize)
+    remove_first(__chars_count_for_indent(indent, tabsize))
+  end
+
+
+  # Remove indent
+  #
+  # @param [Int] indent
+  # @param [Int] tabsize
+  #
+  def remove_indent!(indent, tabsize)
+    remove_first!(__chars_count_for_indent(indent, tabsize))
   end
 
 
@@ -59,9 +89,9 @@ class String
     count = 0
 
     self.each_char do |char|
-      if char == ' '
+      if char == SPACE_CHAR
         count += 1
-      elsif char == "\t"
+      elsif char == TAB_CHAR
         count += tabsize
       else
         break