erbse 0.0.1 → 0.0.2

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA1:
-  metadata.gz: 8cc096d1012a8f395e01e9a7445d2bd23a3b8024
-  data.tar.gz: f8a42d194e45b147f5ee05c4d2fbab25aca5d231
+  metadata.gz: 37f385edabdf30c0807542d7c5560537b5db5f82
+  data.tar.gz: 0bd510e68988198ff9e4ef3f3e796900fde9a41a
 SHA512:
-  metadata.gz: ccddec411ad1e76c807ae5b7abb38e5ecfd3e9feb6204748b4335706d85489bc9a24b050ecd59883454b57808ba4797c436133034dd12f51fb771025a247e3d5
-  data.tar.gz: 5937981a7f6f5847db0841aa32d2fe412da30cbb83e4b81753677e91349121f801150243080b5dce3d04e374578621e55f119bc79fd798d2dbddede370cb2479
+  metadata.gz: 69a822ab5ad04ec4495f484353b9cdce8780a9b78cb25018b57193ec670224a18e10470e0c88b84c01639cfb817456d322a77057e912e04852627209f2ae7bfb
+  data.tar.gz: 80e5540f89a2ac0922730960d1c291e7bdd117a3db70b4b9c74f03245dc1945a279d7f59a008b806d5153d53da17b0dcfe7915b6c6814a9c692dddcdf7487c59

data/CHANGES.md

@@ -0,0 +1,3 @@
+# 0.0.2
+
+* First release. No escaping is happening and I'm not sure how capture works, yet. But: it's great!

data/Gemfile

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

data/README.md

@@ -2,50 +2,68 @@
 
 _An updated version of Erubis._
 
-
+Erbse compiles an ERB string to a string of Ruby. It is completely decoupled from any framework and does only one thing. Pretty boring, I know.
 
 ## Added features
 
-* block support a la Rails.
+* Block support a la Rails.
+
+  ```erb
+  <%= form_tag .. do |f| %>
+    <%= f.fields_for do %>
+     ...
+    <% end %>
+  <% end %>
+  ```
+
+## API
+
+The API is extremely simple.
 
+```ruby
+Erbse::Template.new("<% ... %>").call #=> string of compiled ruby.
+```
 
-== About Erubis
+Template only accepts a content string which is the ERB template. The only public `#call` method returns a string of the compiled template that can then be evaluated in a context.
 
-Erubis is an implementation of eRuby. It has the following features.
-* Very fast, almost three times faster than ERB and even 10% faster than eruby
-* Multi-language support (Ruby/PHP/C/Java/Scheme/Perl/Javascript)
-* Auto escaping support
-* Auto trimming spaces around '<% %>'
-* Embedded pattern changeable (default '<% %>')
-* Enable to handle Processing Instructions (PI) as embedded pattern (ex. '<?rb ... ?>')
-* Context object available and easy to combine eRuby template with YAML datafile
-* Print statement available
-* Easy to extend and customize in subclass
-* Ruby on Rails support
+The user layer, like Tilt, has to take care of caching the `Erbse::Template` instances.
 
-Erubis is implemented in pure Ruby.  It requires Ruby 1.8 or higher.
-Erubis now supports Ruby 1.9.
 
-See doc/users-guide.html for details.
+## Planned
 
+Block inheritance.
 
+```erb
+<h1><%= title %></h1>
 
+<% fragment :subheader do %>
+  Or: <%= subheader %>
+<% end %>
+```
 
+This fragment could then be overridden.
 
-== Benchmark
+Feel free to contribute!!!
 
-'benchmark/erubybenchmark.rb' is a benchmark script of Erubis.
-Try 'ruby erubybenchmark.rb' in benchmark directory.
 
+## Used where?
+
+Erbse is the ERB engine in [Cells 4](https://github.com/apotonick/cells).
+
+It also hopefully gets used in Rails 5/6, so we can remove those horrible hacks from AV.
 
 
 # License
 
 MIT License
 
+# Contributors
+
+* @iazel
+* @seuros
 
 
 # Authors
 
-Copyright 2015 Nick Sutterer <apotonick@gmail.com>
-Copyright 2006-2011 makoto kuwata <kwa(at)kuwata-lab.com>
+* Copyright 2015 Nick Sutterer <apotonick@gmail.com>
+* Copyright 2006-2011 makoto kuwata <kwa(at)kuwata-lab.com>

data/Rakefile

@@ -0,0 +1,13 @@
+require 'bundler'
+Bundler::GemHelper.install_tasks
+
+require 'rake/testtask'
+
+desc 'Default: run unit tests.'
+task :default => :test
+
+Rake::TestTask.new(:test) do |test|
+  test.libs << 'test'
+  test.pattern = 'test/*_test.rb'
+  test.verbose = true
+end

data/lib/erbse.rb

@@ -44,9 +44,6 @@
 module Erbse
 end
 
-require 'erbse/engine'
-# require 'erbse/helper'
-# require 'erbse/enhancer'
-require 'erbse/engine/eruby'
-
-# require 'erbse/local-setting'
+require "erbse/converter"
+require "erbse/template"
+require "erbse/eruby"

data/lib/erbse/converter.rb

@@ -1,46 +1,31 @@
-##
-## $Release: 2.7.0 $
-## copyright(c) 2006-2011 kuwata-lab.com all rights reserved.
-##
-
-require 'erubis/util'
-
-module Erubis
-
+module Erbse
+  # convert input string into target language
+  class Converter
+    def initialize(properties={}, generator)
+      init_converter!(properties)
+      @generator = generator
+    end
 
-  ##
-  ## convert
-  ##
-  module Converter
+    def convert(input) # TODO: rename to #call.
+      codebuf = ""    # or []
+      @preamble.nil? ? generator.add_preamble(codebuf) : (@preamble && (codebuf << @preamble))
+      convert_input(codebuf, input)
+      @postamble.nil? ? generator.add_postamble(codebuf) : (@postamble && (codebuf << @postamble))
+      @_proc = nil    # clear cached proc object
+      return codebuf  # or codebuf.join()
+    end
 
+  private
     attr_accessor :preamble, :postamble, :escape
 
-    def self.supported_properties    # :nodoc:
-      return [
-              [:preamble,  nil,    "preamble (no preamble when false)"],
-              [:postamble, nil,    "postamble (no postamble when false)"],
-              [:escape,    nil,    "escape expression or not in default"],
-             ]
-    end
+    attr_reader :generator
 
-    def init_converter(properties={})
+    def init_converter!(properties)
       @preamble  = properties[:preamble]
       @postamble = properties[:postamble]
       @escape    = properties[:escape]
     end
 
-    ## convert input string into target language
-    def convert(input)
-      codebuf = ""    # or []
-      @preamble.nil? ? add_preamble(codebuf) : (@preamble && (codebuf << @preamble))
-      convert_input(codebuf, input)
-      @postamble.nil? ? add_postamble(codebuf) : (@postamble && (codebuf << @postamble))
-      @_proc = nil    # clear cached proc object
-      return codebuf  # or codebuf.join()
-    end
-
-    protected
-
     ##
     ## detect spaces at beginning of line
     ##
@@ -70,14 +55,6 @@ module Erubis
       end
       return lspace
     end
-
-    ##
-    ## (abstract) convert input to code
-    ##
-    def convert_input(codebuf, input)
-      not_implemented
-    end
-
   end
 
 
@@ -88,9 +65,7 @@ module Erubis
   ##
   ## basic converter which supports '<% ... %>' notation.
   ##
-  module Basic::Converter
-    include Erubis::Converter
-
+  class Basic::Converter < Converter
     def self.supported_properties    # :nodoc:
       return [
               [:pattern,  '<% %>', "embed pattern"],
@@ -98,32 +73,27 @@ module Erubis
              ]
     end
 
+
+  private
+
     attr_accessor :pattern, :trim
 
-    def init_converter(properties={})
+    def init_converter!(properties={})
       super(properties)
       @pattern = properties[:pattern]
       @trim    = properties[:trim] != false
     end
 
-    protected
+
 
     ## return regexp of pattern to parse eRuby script
-    def pattern_regexp(pattern)
+    def self.pattern_regexp(pattern)
       @prefix, @postfix = pattern.split()   # '<% %>' => '<%', '%>'
-      #return /(.*?)(^[ \t]*)?#{@prefix}(=+|\#)?(.*?)-?#{@postfix}([ \t]*\r?\n)?/m
-      #return /(^[ \t]*)?#{@prefix}(=+|\#)?(.*?)-?#{@postfix}([ \t]*\r?\n)?/m
       return /#{@prefix}(=+|-|\#|%)?(.*?)([-=])?#{@postfix}([ \t]*\r?\n)?/m
     end
-    module_function :pattern_regexp
 
-    #DEFAULT_REGEXP = /(.*?)(^[ \t]*)?<%(=+|\#)?(.*?)-?%>([ \t]*\r?\n)?/m
-    #DEFAULT_REGEXP = /(^[ \t]*)?<%(=+|\#)?(.*?)-?%>([ \t]*\r?\n)?/m
-    #DEFAULT_REGEXP = /<%(=+|\#)?(.*?)-?%>([ \t]*\r?\n)?/m
     DEFAULT_REGEXP = pattern_regexp('<% %>')
 
-    public
-
     def convert_input(src, input)
       pat = @pattern
       regexp = pat.nil? || pat == '<% %>' ? DEFAULT_REGEXP : pattern_regexp(pat)
@@ -137,221 +107,51 @@ module Erubis
         ch   = indicator ? indicator[0] : nil
         lspace = ch == ?= ? nil : detect_spaces_at_bol(text, is_bol)
         is_bol = rspace ? true : false
-        add_text(src, text) if text && !text.empty?
+        generator.add_text(src, text) if text && !text.empty?
         ## * when '<%= %>', do nothing
         ## * when '<% %>' or '<%# %>', delete spaces iff only spaces are around '<% %>'
         if ch == ?=              # <%= %>
           rspace = nil if tailch && !tailch.empty?
-          add_text(src, lspace) if lspace
+          generator.add_text(src, lspace) if lspace
           add_expr(src, code, indicator)
-          add_text(src, rspace) if rspace
+          generator.add_text(src, rspace) if rspace
         elsif ch == ?\#          # <%# %>
           n = code.count("\n") + (rspace ? 1 : 0)
           if @trim && lspace && rspace
-            add_stmt(src, "\n" * n)
+            generator.add_stmt(src, "\n" * n)
           else
-            add_text(src, lspace) if lspace
-            add_stmt(src, "\n" * n)
-            add_text(src, rspace) if rspace
+            generator.add_text(src, lspace) if lspace
+            generator.add_stmt(src, "\n" * n)
+            generator.add_text(src, rspace) if rspace
           end
         elsif ch == ?%           # <%% %>
           s = "#{lspace}#{@prefix||='<%'}#{code}#{tailch}#{@postfix||='%>'}#{rspace}"
-          add_text(src, s)
+          generator.add_text(src, s)
         else                     # <% %>
           if @trim && lspace && rspace
-            add_stmt(src, "#{lspace}#{code}#{rspace}")
+            generator.add_stmt(src, "#{lspace}#{code}#{rspace}")
           else
-            add_text(src, lspace) if lspace
-            add_stmt(src, code)
-            add_text(src, rspace) if rspace
+            generator.add_text(src, lspace) if lspace
+            generator.add_stmt(src, code)
+            generator.add_text(src, rspace) if rspace
           end
         end
       end
       #rest = $' || input                        # ruby1.8
       rest = pos == 0 ? input : input[pos..-1]   # ruby1.9
-      add_text(src, rest)
+      generator.add_text(src, rest)
     end
 
     ## add expression code to src
     def add_expr(src, code, indicator)
       case indicator
       when '='
-        @escape ? add_expr_escaped(src, code) : add_expr_literal(src, code)
+        @escape ? generator.add_expr_escaped(src, code) : generator.add_expr_literal(src, code)
       when '=='
-        @escape ? add_expr_literal(src, code) : add_expr_escaped(src, code)
+        @escape ? generator.add_expr_literal(src, code) : generator.add_expr_escaped(src, code)
       when '==='
-        add_expr_debug(src, code)
-      end
-    end
-
-  end
-
-
-  module PI
-  end
-
-  ##
-  ## Processing Instructions (PI) converter for XML.
-  ## this class converts '<?rb ... ?>' and '${...}' notation.
-  ##
-  module PI::Converter
-    include Erubis::Converter
-
-    def self.desc   # :nodoc:
-      "use processing instructions (PI) instead of '<% %>'"
-    end
-
-    def self.supported_properties    # :nodoc:
-      return [
-              [:trim,      true,   "trim spaces around <% ... %>"],
-              [:pi,        'rb',   "PI (Processing Instrunctions) name"],
-              [:embchar,   '@',    "char for embedded expression pattern('@{...}@')"],
-              [:pattern,  '<% %>', "embed pattern"],
-             ]
-    end
-
-    attr_accessor :pi, :prefix
-
-    def init_converter(properties={})
-      super(properties)
-      @trim    = properties.fetch(:trim, true)
-      @pi      = properties[:pi] if properties[:pi]
-      @embchar = properties[:embchar] || '@'
-      @pattern = properties[:pattern]
-      @pattern = '<% %>' if @pattern.nil?  #|| @pattern == true
-    end
-
-    def convert(input)
-      code = super(input)
-      return @header || @footer ? "#{@header}#{code}#{@footer}" : code
-    end
-
-    protected
-
-    def convert_input(codebuf, input)
-      unless @regexp
-        @pi ||= 'e'
-        ch = Regexp.escape(@embchar)
-        if @pattern
-          left, right = @pattern.split(' ')
-          @regexp = /<\?#{@pi}(?:-(\w+))?(\s.*?)\?>([ \t]*\r?\n)?|#{ch}(!*)?\{(.*?)\}#{ch}|#{left}(=+)(.*?)#{right}/m
-        else
-          @regexp = /<\?#{@pi}(?:-(\w+))?(\s.*?)\?>([ \t]*\r?\n)?|#{ch}(!*)?\{(.*?)\}#{ch}/m
-        end
-      end
-      #
-      is_bol = true
-      pos = 0
-      input.scan(@regexp) do |pi_arg, stmt, rspace,
-                              indicator1, expr1, indicator2, expr2|
-        match = Regexp.last_match
-        len = match.begin(0) - pos
-        text = input[pos, len]
-        pos = match.end(0)
-        lspace = stmt ? detect_spaces_at_bol(text, is_bol) : nil
-        is_bol = stmt && rspace ? true : false
-        add_text(codebuf, text) # unless text.empty?
-        #
-        if stmt
-          if @trim && lspace && rspace
-            add_pi_stmt(codebuf, "#{lspace}#{stmt}#{rspace}", pi_arg)
-          else
-            add_text(codebuf, lspace) if lspace
-            add_pi_stmt(codebuf, stmt, pi_arg)
-            add_text(codebuf, rspace) if rspace
-          end
-        else
-          add_pi_expr(codebuf, expr1 || expr2, indicator1 || indicator2)
-        end
+        generator.add_expr_debug(src, code)
       end
-      #rest = $' || input                        # ruby1.8
-      rest = pos == 0 ? input : input[pos..-1]   # ruby1.9
-      add_text(codebuf, rest)
     end
-
-    #--
-    #def convert_input(codebuf, input)
-    #  parse_stmts(codebuf, input)
-    #  #parse_stmts2(codebuf, input)
-    #end
-    #
-    #def parse_stmts(codebuf, input)
-    #  #regexp = pattern_regexp(@pattern)
-    #  @pi ||= 'e'
-    #  @stmt_pattern ||= /<\?#{@pi}(?:-(\w+))?(\s.*?)\?>([ \t]*\r?\n)?/m
-    #  is_bol = true
-    #  pos = 0
-    #  input.scan(@stmt_pattern) do |pi_arg, code, rspace|
-    #    match = Regexp.last_match
-    #    len  = match.begin(0) - pos
-    #    text = input[pos, len]
-    #    pos  = match.end(0)
-    #    lspace = detect_spaces_at_bol(text, is_bol)
-    #    is_bol = rspace ? true : false
-    #    parse_exprs(codebuf, text) # unless text.empty?
-    #    if @trim && lspace && rspace
-    #      add_pi_stmt(codebuf, "#{lspace}#{code}#{rspace}", pi_arg)
-    #    else
-    #      add_text(codebuf, lspace)
-    #      add_pi_stmt(codebuf, code, pi_arg)
-    #      add_text(codebuf, rspace)
-    #    end
-    #  end
-    #  rest = $' || input
-    #  parse_exprs(codebuf, rest)
-    #end
-    #
-    #def parse_exprs(codebuf, input)
-    #  unless @expr_pattern
-    #    ch = Regexp.escape(@embchar)
-    #    if @pattern
-    #      left, right = @pattern.split(' ')
-    #      @expr_pattern = /#{ch}(!*)?\{(.*?)\}#{ch}|#{left}(=+)(.*?)#{right}/
-    #    else
-    #      @expr_pattern = /#{ch}(!*)?\{(.*?)\}#{ch}/
-    #    end
-    #  end
-    #  pos = 0
-    #  input.scan(@expr_pattern) do |indicator1, code1, indicator2, code2|
-    #    indicator = indicator1 || indicator2
-    #    code = code1 || code2
-    #    match = Regexp.last_match
-    #    len  = match.begin(0) - pos
-    #    text = input[pos, len]
-    #    pos  = match.end(0)
-    #    add_text(codebuf, text) # unless text.empty?
-    #    add_pi_expr(codebuf, code, indicator)
-    #  end
-    #  rest = $' || input
-    #  add_text(codebuf, rest)
-    #end
-    #++
-
-    def add_pi_stmt(codebuf, code, pi_arg)  # :nodoc:
-      case pi_arg
-      when nil      ;  add_stmt(codebuf, code)
-      when 'header' ;  @header = code
-      when 'footer' ;  @footer = code
-      when 'comment';  add_stmt(codebuf, "\n" * code.count("\n"))
-      when 'value'  ;  add_expr_literal(codebuf, code)
-      else          ;  add_stmt(codebuf, code)
-      end
-    end
-
-    def add_pi_expr(codebuf, code, indicator)  # :nodoc:
-      case indicator
-      when nil, '', '=='    # @{...}@ or <%== ... %>
-        @escape == false ? add_expr_literal(codebuf, code) : add_expr_escaped(codebuf, code)
-      when '!', '='         # @!{...}@ or <%= ... %>
-        @escape == false ? add_expr_escaped(codebuf, code) : add_expr_literal(codebuf, code)
-      when '!!', '==='      # @!!{...}@ or <%=== ... %>
-        add_expr_debug(codebuf, code)
-      else
-        # ignore
-      end
-    end
-
   end
-
-
 end