erubis 1.1.0 → 2.0.0

data/lib/erubis/helper.rb

@@ -0,0 +1,53 @@
+##
+## $Rev: 21 $
+## $Release: 2.0.0 $
+## copyright(c) 2006 kuwata-lab all rights reserved.
+##
+
+
+module Erubis
+
+  ##
+  ## helper for xml
+  ##
+  module XmlHelper
+
+    module_function
+
+    ESCAPE_TABLE = {
+      '&' => '&',
+      '<' => '&lt;',
+      '>' => '&gt;',
+      '"' => '&quot;',
+      "'" => '&#039;',
+    }
+
+    def escape_xml(obj)
+      #table = ESCAPE_TABLE
+      #obj.to_s.gsub(/[&<>"]/) { |s| table[s] }    # or /[&<>"']/
+      obj.to_s.gsub(/[&<>"]/) { |s| ESCAPE_TABLE[s] }   # or /[&<>"']/
+      #obj.to_s.gsub(SCAN_REGEXP) { |s| ESCAPE_TABLE[s] }
+      #obj.to_s.gsub(/[&<>"]/) { ESCAPE_TABLE[$&] }
+    end
+
+    #--
+    #def escape_xml(obj)
+    #  str = obj.to_s.dup
+    #  #str = obj.to_s
+    #  #str = str.dup if obj.__id__ == str.__id__
+    #  str.gsub!(/&/, '&amp;')
+    #  str.gsub!(/</, '&lt;')
+    #  str.gsub!(/>/, '&gt;')
+    #  str.gsub!(/"/, '&quot;')
+    #  str.gsub!(/'/, '&#039;')
+    #  return str
+    #end
+    #++
+
+    alias h escape_xml
+    alias html_escape escape_xml
+
+  end
+
+
+end

data/lib/erubis/local-setting.rb

@@ -0,0 +1,10 @@
+##
+## $Rev: 13 $
+## $Release: 2.0.0 $
+## copyright(c) 2006 kuwata-lab all rights reserved.
+##
+
+##
+## you can add site-local settings here.
+## this files is 'require'd by erubis.rb
+##

data/lib/erubis/main.rb

@@ -0,0 +1,368 @@
+###
+### $Rev: 21 $
+### $Release: 2.0.0 $
+### copyright(c) 2006 kuwata-lab all rights reserved.
+###
+
+require 'yaml'
+require 'erubis'
+require 'erubis/tiny'
+require 'erubis/engine/enhanced'
+require 'erubis/engine/optimized'
+require 'erubis/engine/eruby'
+require 'erubis/engine/ephp'
+require 'erubis/engine/ec'
+require 'erubis/engine/ejava'
+require 'erubis/engine/escheme'
+require 'erubis/engine/eperl'
+require 'erubis/engine/ejavascript'
+
+
+module Erubis
+
+
+  Ejs = Ejavascript
+  EscapedEjs = EscapedEjavascript
+
+
+  class CommandOptionError < ErubisError
+  end
+
+
+  ##
+  ## main class of command
+  ##
+  ## ex.
+  ##   Main.main(ARGV)
+  ##
+  class Main
+
+    def self.main(argv=ARGV)
+      status = 0
+      begin
+        Main.new.execute(ARGV)
+      rescue CommandOptionError => ex
+        $stderr.puts ex.message
+        status = 1
+      end
+      exit(status)
+    end
+
+    def initialize
+      @single_options = "hvxTtSbeB"
+      @arg_options    = "pcrfKIlaE"
+      @option_names   = {
+        ?h => :help,
+        ?v => :version,
+        ?x => :source,
+        ?T => :notrim,
+        ?t => :untabify,
+        ?S => :intern,
+        ?b => :bodyonly,
+        ?B => :binding,
+        ?p => :pattern,
+        ?c => :class,
+        ?e => :escape,
+        ?r => :requires,
+        ?f => :yamlfiles,
+        ?K => :kanji,
+        ?I => :includes,
+        ?l => :lang,
+        ?a => :action,
+        ?E => :enhancers,
+      }
+      assert unless @single_options.length + @arg_options.length == @option_names.length
+      (@single_options + @arg_options).each_byte do |ch|
+        assert unless @option_names.key?(ch)
+      end
+    end
+
+
+    def execute(argv=ARGV)
+      ## parse command-line options
+      options, properties = parse_argv(argv, @single_options, @arg_options)
+      filenames = argv
+      options[?h] = true if properties[:help]
+      opts = Object.new
+      arr = @option_names.collect { |ch, name| "def #{name}; @#{name}; end\n" }
+      opts.instance_eval arr.join
+      options.each do |ch, val|
+        name = @option_names[ch]
+        opts.instance_variable_set("@#{name}", val)
+      end
+
+      ## help, version, enhancer list
+      if opts.help || opts.version
+        puts version()         if opts.version
+        puts usage()           if opts.help
+        puts show_properties() if opts.help
+        puts show_enhancers()  if opts.help
+        return
+      end
+
+      ## include path
+      opts.includes.split(/,/).each do |path|
+        $: << path
+      end if opts.includes
+
+      ## require library
+      opts.requires.split(/,/).each do |library|
+        require library
+      end if opts.requires
+
+      ## action
+      action = opts.action
+      action ||= 'compile' if opts.source
+
+      ## lang
+      lang = opts.lang || 'ruby'
+      action ||= 'compile' if opts.lang
+
+      ## class name of Eruby
+      classname = opts.class
+      klass = get_classobj(classname, lang)
+
+      ## kanji code
+      $KCODE = opts.kanji if opts.kanji
+
+      ## read context values from yaml file
+      yamlfiles = opts.yamlfiles
+      context = load_yamlfiles(yamlfiles, opts)
+
+      ## properties for engine
+      properties[:pattern]  = opts.pattern if opts.pattern
+      properties[:trim]     = false        if opts.notrim
+      properties[:preamble] = properties[:postamble] = false if opts.bodyonly
+
+      ## create engine and extend enhancers
+      engine = klass.new(nil, properties)
+      enhancers = get_enhancers(opts.enhancers)
+      enhancers.push(Erubis::EscapeEnhancer) if opts.escape
+      enhancers.each do |enhancer|
+        engine.extend(enhancer)
+        engine.bipattern = properties[:bipattern] if enhancer == Erubis::BiPatternEnhancer
+      end
+
+      ## compile and execute
+      val = nil
+      if filenames && !filenames.empty?
+        filenames.each do |filename|
+          test(?f, filename)  or raise CommandOptionError.new("#{filename}: file not found.")
+          engine.filename = filename
+          engine.compile!(File.read(filename))
+          print val if val = do_action(action, engine, context, opts)
+        end
+      else
+        engine.filename = '(stdin)'
+        engine.compile!($stdin.read())
+        print val if val = do_action(action, engine, context, opts)
+      end
+
+    end
+
+    private
+
+    def do_action(action, engine, context, opts)
+      case action
+      when 'compile'
+        s = engine.src
+      when nil, 'exec', 'execute'
+        s = opts.binding ? engine.result(context) : engine.evaluate(context)
+      else
+        raise "*** internal error"
+      end
+      return s
+    end
+
+    def usage
+      command = File.basename($0)
+      s = <<'END'
+erubis - embedded program compiler for multi-language
+Usage: #{command} [..options..] [file ...]
+  -h, --help    : help
+  -v            : version
+  -x            : compiled code
+  -T            : don't trim spaces around '<% %>'
+  -b            : body only (no preamble nor postamble)
+  -e            : escape (equal to '--E Escape')
+  -p pattern    : embedded pattern (default '<% %>')
+  -l lang       : compile but no execute (ruby/php/c/java/scheme/perl/js)
+  -E enhancer,... : enhancer name (Escape, PercentLine, BiPattern, ...)
+  -I path       : library include path
+  -K kanji      : kanji code (euc/sjis/utf8) (default none)
+  -f file.yaml  : YAML file for context values (read stdin if filename is '-')
+  -t            : expand tab character in YAML file
+  -S            : convert mapping key from string to symbol in YAML file
+  -B            : invoke 'result(binding)' instead of 'evaluate(context)'
+
+END
+      #  -c class      : class name (XmlEruby/PercentLineEruby/...) (default Eruby)
+      #  -r library    : require library
+      #  -a            : action (compile/execute)
+      return s
+    end
+
+    def show_properties
+      s = "supported properties:\n"
+      %w[(common) ruby php c java scheme perl javascript].each do |lang|
+        list = Erubis::Engine.supported_properties
+        if lang != '(common)'
+          klass = Erubis.const_get("E#{lang}")
+          list = klass.supported_properties - list
+        end
+        s << "  * #{lang}\n"
+        list.each do |name, default_val, desc|
+          s << ("     --%-23s : %s\n" % ["#{name}=#{default_val.inspect}", desc])
+        end
+      end
+      s << "\n"
+      return s
+    end
+
+    def show_enhancers
+      s = "enhancers:\n"
+      list = []
+      ObjectSpace.each_object(Module) do |m| list << m end
+      list.sort_by { |m| m.name }.each do |m|
+        next unless m.name =~ /\AErubis::(.*)Enhancer\z/
+        name = $1
+        desc = m.desc
+        s << ("  %-13s : %s\n" % [name, desc])
+      end
+      return s
+    end
+
+    def version
+      release = ('$Release: 2.0.0 $' =~ /([.\d]+)/) && $1
+      return release
+    end
+
+    def parse_argv(argv, arg_none='', arg_required='', arg_optional='')
+      options = {}
+      context = {}
+      while argv[0] && argv[0][0] == ?-
+        optstr = argv.shift
+        optstr = optstr[1, optstr.length-1]
+        #
+        if optstr[0] == ?-    # context
+          unless optstr =~ /\A\-([-\w]+)(?:=(.*))?/
+            raise CommandOptionError.new("-#{optstr}: invalid context value.")
+          end
+          name = $1;  value = $2
+          name  = name.gsub(/-/, '_').intern
+          #value = value.nil? ? true : YAML.load(value)   # error, why?
+          value = value.nil? ? true : YAML.load("---\n#{value}\n")
+          context[name] = value
+          #
+        else                  # options
+          while optstr && !optstr.empty?
+            optchar = optstr[0]
+            optstr[0,1] = ""
+            if arg_none.include?(optchar)
+              options[optchar] = true
+            elsif arg_required.include?(optchar)
+              arg = optstr.empty? ? argv.shift : optstr
+              unless arg
+                mesg = "-#{optchar.chr}: #{@option_args[optchar]} required."
+                raise CommandOptionError.new(mesg)
+              end
+              options[optchar] = arg
+              optstr = nil
+            elsif arg_optional.include?(optchar)
+              arg = optstr.empty? ? true : optstr
+              options[optchar] = arg
+              optstr = nil
+            else
+              raise CommandOptionError.new("-#{optchar.chr}: unknown option.")
+            end
+          end
+        end
+        #
+      end  # end of while
+
+      return options, context
+    end
+
+    def untabify(text, width=8)
+      sb = ''
+      text.scan(/(.*?)\t/m) do |s, |
+        len = (n = s.rindex(?\n)) ? s.length - n - 1 : s.length
+        sb << s << (" " * (width - len % width))
+      end
+      return $' ? (sb << $') : text
+    end
+
+    def get_classobj(classname, lang)
+      unless classname
+        classname = lang =~ /\Axml(.*)/ ? "EscapedE#{$1}" : "E#{lang}"
+      end
+      begin
+        klass = Erubis.const_get(classname)
+      rescue NameError
+        klass = nil
+      end
+      unless klass
+        if lang
+          msg = "-l #{lang}: invalid language name (class Erubis::#{classname} not found)."
+        else
+          msg = "-c #{classname}: invalid class name."
+        end
+        raise CommandOptionError.new(msg)
+      end
+      return klass
+    end
+
+    def get_enhancers(enhancer_names)
+      return [] unless enhancer_names
+      enhancers = []
+      shortname = nil
+      begin
+        enhancer_names.split(/,/).each do |shortname|
+          enhancers << Erubis.const_get("#{shortname}Enhancer")
+        end
+      rescue NameError
+        raise CommandOptionError.new("#{shortname}: no such Enhancer (try '-E' to show all enhancers).")
+      end
+      return enhancers
+    end
+
+    def load_yamlfiles(yamlfiles, opts)
+      hash = {}
+      return hash unless yamlfiles
+      yamlfiles.split(/,/).each do |yamlfile|
+        if yamlfile == '-'
+          str = $stdin.read()
+        else
+          test(?f, yamlfile)  or raise CommandOptionError.new("#{yamlfile}: file not found.")
+          str = File.read(yamlfile)
+        end
+        str = yamlfile == '-' ? $stdin.read() : File.read(yamlfile)
+        str = untabify(str) if opts.untabify
+        ydoc = YAML.load(str)
+        unless ydoc.is_a?(Hash)
+          raise CommandOptionError.new("#{yamlfile}: root object is not a mapping.")
+        end
+        convert_mapping_key_from_string_to_symbol(ydoc) if opts.intern
+        hash.update(ydoc)
+      end
+      context = hash
+      return context
+    end
+
+    def convert_mapping_key_from_string_to_symbol(ydoc)
+      if ydoc.is_a?(Hash)
+        ydoc.each do |key, val|
+          ydoc[key.intern] = ydoc.delete(key) if key.is_a?(String)
+          convert_mapping_key_from_string_to_symbol(val)
+        end
+      elsif ydoc.is_a?(Array)
+        ydoc.each do |val|
+          convert_mapping_key_from_string_to_symbol(val)
+        end
+      end
+      return ydoc
+    end
+
+  end
+
+end

data/lib/erubis/tiny.rb

@@ -0,0 +1,65 @@
+##
+## $Rev: 21 $
+## $Release: 2.0.0 $
+## copyright(c) 2006 kuwata-lab all rights reserved.
+##
+
+module Erubis
+
+  ##
+  ## tiny and the simplest implementation of eRuby
+  ##
+  ## ex.
+  ##   eruby = TinyEruby.new(File.read('example.rhtml'))
+  ##   print eruby.src                 # print ruby code
+  ##   print eruby.result(binding())   # eval ruby code with Binding object
+  ##   print eruby.evalute(context)    # eval ruby code with context object
+  ##
+  class TinyEruby
+
+    def initialize(input)
+      @src = compile(input)
+    end
+    attr_reader :src
+
+    EMBEDDED_PATTERN = /(.*?)<%(=+|\#)?(.*?)-?%>/m
+
+    def compile(input)
+      src = "_buf = [];"           # preamble
+      input.scan(EMBEDDED_PATTERN) do |text, indicator, code|
+        src << " _buf << '" << escape_text(text) << "';"
+        if !indicator              # <% %>
+          src << code << ";"
+        elsif indicator[0] == ?\#  # <%# %>
+          n = code.count("\n")
+          add_stmt(src, "\n" * n)
+        else                       # <%= %>
+          src << " _buf << (" << code << ").to_s;"
+        end
+      end
+      rest = $' || input
+      src << " _buf << '" << escape_text(rest) << "';"
+      src << "\n_buf.join\n"       # postamble
+      return src
+    end
+
+    def escape_text(text)
+      return text.gsub!(/['\\]/, '\\\\\&') || text
+    end
+
+    def result(binding=TOPLEVEL_BINDING)
+      eval @src, binding
+    end
+
+    def evaluate(context=Object.new)
+      if context.is_a?(Hash)
+        obj = Object.new
+        context.each do |k, v| obj.instance_variable_set("@#{k}", v) end
+        context = obj
+      end
+      context.instance_eval @src
+    end
+
+  end
+
+end