pax_global_header00006660000000000000000000000064150710360570014516gustar00rootroot0000000000000052 comment=ddfc1ba57ec00314a833c82fb02c460b3e82ba71 erb-5.0.3/000077500000000000000000000000001507103605700122735ustar00rootroot00000000000000erb-5.0.3/.document000066400000000000000000000000561507103605700141130ustar00rootroot00000000000000LICENSE.txt NEWS.md README.md ext/ lib/ _doc/ erb-5.0.3/.github/000077500000000000000000000000001507103605700136335ustar00rootroot00000000000000erb-5.0.3/.github/dependabot.yml000066400000000000000000000001671507103605700164670ustar00rootroot00000000000000version: 2 updates: - package-ecosystem: 'github-actions' directory: '/' schedule: interval: 'monthly' erb-5.0.3/.github/workflows/000077500000000000000000000000001507103605700156705ustar00rootroot00000000000000erb-5.0.3/.github/workflows/dependabot_automerge.yml000066400000000000000000000015651507103605700225770ustar00rootroot00000000000000name: Dependabot auto-merge on: pull_request: permissions: contents: write pull-requests: write jobs: automerge: runs-on: ubuntu-latest if: github.event.pull_request.user.login == 'dependabot[bot]' && github.repository == 'ruby/erb' steps: - name: Dependabot metadata uses: dependabot/fetch-metadata@v2 id: metadata - name: Wait for status checks uses: lewagon/wait-on-check-action@v1 with: repo-token: ${{ secrets.GITHUB_TOKEN }} ref: ${{ github.event.pull_request.head.sha || github.sha }} check-regexp: 'build \(.*\)' wait-interval: 30 - name: Auto-merge for Dependabot PRs run: gh pr merge --auto --rebase "$PR_URL" env: PR_URL: ${{ github.event.pull_request.html_url }} GITHUB_TOKEN: ${{ secrets.MATZBOT_DEPENDABOT_MERGE_TOKEN }} erb-5.0.3/.github/workflows/sync-ruby.yml000066400000000000000000000016711507103605700203530ustar00rootroot00000000000000name: Sync ruby on: push: branches: [master] jobs: sync: name: Sync ruby runs-on: ubuntu-latest if: ${{ github.repository == 'ruby/erb' }} steps: - uses: actions/checkout@v5 - name: Create GitHub App token id: app-token uses: actions/create-github-app-token@v2 with: app-id: 2060836 private-key: ${{ secrets.RUBY_SYNC_DEFAULT_GEMS_PRIVATE_KEY }} owner: ruby repositories: ruby - name: Sync to ruby/ruby uses: convictional/trigger-workflow-and-wait@v1.6.5 with: owner: ruby repo: ruby workflow_file_name: sync_default_gems.yml github_token: ${{ steps.app-token.outputs.token }} ref: master client_payload: | {"gem":"erb","before":"${{ github.event.before }}","after":"${{ github.event.after }}"} propagate_failure: true wait_interval: 10 erb-5.0.3/.github/workflows/test.yml000066400000000000000000000014511507103605700173730ustar00rootroot00000000000000name: test on: push: branches: [master] pull_request: workflow_dispatch: jobs: ruby-versions: uses: ruby/actions/.github/workflows/ruby_versions.yml@master with: engine: cruby versions: '["jruby", "truffleruby-head"]' test: needs: ruby-versions name: build (${{ matrix.ruby }} / ${{ matrix.os }}) strategy: matrix: ruby: ${{ fromJson(needs.ruby-versions.outputs.versions) }} os: [ubuntu-latest] fail-fast: false runs-on: ${{ matrix.os }} steps: - uses: actions/checkout@v5 - name: Set up Ruby uses: ruby/setup-ruby@v1 with: ruby-version: ${{ matrix.ruby }} bundler-cache: true - name: Run test run: bundle exec rake test - name: RDoc coverage run: | rdoc -C . erb-5.0.3/.gitignore000066400000000000000000000001521507103605700142610ustar00rootroot00000000000000/.bundle/ /.yardoc /_yardoc/ /coverage/ /doc/ /pkg/ /spec/reports/ /tmp/ Gemfile.lock *.so *.bundle *.gem erb-5.0.3/.rdoc_options000066400000000000000000000000251507103605700147730ustar00rootroot00000000000000main_page: README.md erb-5.0.3/BDSL000066400000000000000000000024131507103605700127420ustar00rootroot00000000000000Copyright (C) 1993-2013 Yukihiro Matsumoto. All rights reserved. Redistribution and use in source and binary forms, with or without modification, are permitted provided that the following conditions are met: 1. Redistributions of source code must retain the above copyright notice, this list of conditions and the following disclaimer. 2. Redistributions in binary form must reproduce the above copyright notice, this list of conditions and the following disclaimer in the documentation and/or other materials provided with the distribution. THIS SOFTWARE IS PROVIDED BY THE AUTHOR AND CONTRIBUTORS ``AS IS'' AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE AUTHOR OR CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE. erb-5.0.3/COPYING000066400000000000000000000045731507103605700133370ustar00rootroot00000000000000Ruby is copyrighted free software by Yukihiro Matsumoto . You can redistribute it and/or modify it under either the terms of the 2-clause BSDL (see the file BSDL), or the conditions below: 1. You may make and give away verbatim copies of the source form of the software without restriction, provided that you duplicate all of the original copyright notices and associated disclaimers. 2. You may modify your copy of the software in any way, provided that you do at least ONE of the following: a. place your modifications in the Public Domain or otherwise make them Freely Available, such as by posting said modifications to Usenet or an equivalent medium, or by allowing the author to include your modifications in the software. b. use the modified software only within your corporation or organization. c. give non-standard binaries non-standard names, with instructions on where to get the original software distribution. d. make other distribution arrangements with the author. 3. You may distribute the software in object code or binary form, provided that you do at least ONE of the following: a. distribute the binaries and library files of the software, together with instructions (in the manual page or equivalent) on where to get the original distribution. b. accompany the distribution with the machine-readable source of the software. c. give non-standard binaries non-standard names, with instructions on where to get the original software distribution. d. make other distribution arrangements with the author. 4. You may modify and include the part of the software into any other software (possibly commercial). But some files in the distribution are not written by the author, so that they are not under these terms. For the list of those files and their copying conditions, see the file LEGAL. 5. The scripts and library files supplied as input to or produced as output from the software do not automatically fall under the copyright of the software, but belong to whomever generated them, and may be sold commercially, and may be aggregated with this software. 6. THIS SOFTWARE IS PROVIDED "AS IS" AND WITHOUT ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, WITHOUT LIMITATION, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE. erb-5.0.3/Gemfile000066400000000000000000000002401507103605700135620ustar00rootroot00000000000000source 'https://rubygems.org' gemspec group :development do gem 'rake' gem 'rake-compiler' gem 'rdoc' gem 'test-unit' gem "test-unit-ruby-core" end erb-5.0.3/LICENSE.txt000066400000000000000000000002231507103605700141130ustar00rootroot00000000000000All the files in this distribution are covered under either the Ruby's license (see the file COPYING) or BSD-2-Clause license (see the file BSDL). erb-5.0.3/NEWS.md000066400000000000000000000041501507103605700133710ustar00rootroot00000000000000# Change Log ## 5.0.3 * Update help of erb(1) [#85](https://github.com/ruby/erb/pull/85) ## 5.0.2 * Declare escape functions as Ractor-safe [#63](https://github.com/ruby/erb/pull/63) ## 5.0.1 * Rescue `LoadError` when failing to load `erb/escape` ## 5.0.0 * Bump `required_ruby_version` to Ruby 3.2+ [#60](https://github.com/ruby/erb/pull/60) * Drop `cgi` from runtime dependencies [#59](https://github.com/ruby/erb/pull/59) * Make `ERB::VERSION` public ## 4.0.4 * Skip building the C extension for JRuby [#52](https://github.com/ruby/erb/pull/52) ## 4.0.3 * Enable `frozen_string_literal` in all files [#49](https://github.com/ruby/erb/pull/49) ## 4.0.2 * Fix line numbers after multi-line `<%#` [#42](https://github.com/ruby/erb/pull/42) ## 4.0.1 * Stop building the C extension for TruffleRuby [#39](https://github.com/ruby/erb/pull/39) ## 4.0.0 * Optimize `ERB::Util.html_escape` [#27](https://github.com/ruby/erb/pull/27) * No longer duplicate an argument string when nothing is escaped. * This makes `ERB::Util.html_escape` faster than `CGI.escapeHTML` in no-escape cases. * It skips calling `#to_s` when an argument is already a String. * Define `ERB::Escape.html_escape` as an alias to `ERB::Util.html_escape` [#38](https://github.com/ruby/erb/pull/38) * `ERB::Util.html_escape` is known to be monkey-patched by Rails. `ERB::Escape.html_escape` is useful when you want a non-monkey-patched version. * Drop deprecated `-S` option from `erb` command ## 3.0.0 * Bump `required_ruby_version` to Ruby 2.7+ [#23](https://github.com/ruby/erb/pull/23) * `ERB::Util.url_encode` uses a native implementation [#23](https://github.com/ruby/erb/pull/23) * Fix a bug that a magic comment with a wrong format could be detected [#6](https://github.com/ruby/erb/pull/6) ## 2.2.3 * Bump `required_ruby_version` from 2.3 to 2.5 as it has never been supported [#3](https://github.com/ruby/erb/pull/3) ## 2.2.2 * `ERB.version` returns just a version number * `ERB::Revision` is deprecated ## 2.2.1 * `ERB#initialize` warns `safe_level` and later arguments even without -w ## 2.2.0 * Ruby 3.0 promoted ERB to a default gem erb-5.0.3/README.md000066400000000000000000000064441507103605700135620ustar00rootroot00000000000000# \ERB (Embedded Ruby) \ERB is an easy-to-use, but also very powerful, [template processor][template processor]. \ERB is commonly used to produce: - Customized or personalized email messages. - Customized or personalized web pages. - Software code (in code-generating applications). Like method [sprintf][sprintf], \ERB can format run-time data into a string. \ERB, however, is *much more powerful* ## How \ERB Works Using \ERB, you can create a *template*: a plain-text string that has specially-formatted *tags*, then store it into an \ERB object; when \ERB produces _result_ string, it: - Inserts run-time-evaluated expressions into the result. - Executes snippets of Ruby code. - Omits comments from the results. In the result: - All non-tag text is passed through, _unchanged_. - Each tag is either _replaced_ (expression tag), or _omitted_ entirely (execution tag or comment tag). There are three types of tags: | Tag | Form | Action | Text in Result | |----------------|:------------------------------------:|:-------------------------------------:|:--------------------:| | Expression tag | '<%= _ruby_expression_ %>' | Evaluates _ruby_expression_. | Value of expression. | | Execution tag | '<% _ruby_code_ %>' | Execute _ruby_code_. | None. | | Comment tag | '<%# _comment_text_ %>' | None. | None. | These examples use `erb`, the \ERB command-line interface; each "echoes" a string template and pipes it to `erb` as input: - Expression tag: $ echo "<%= $VERBOSE %>" | erb "false" $ echo "<%= 2 + 2 %>" | erb "4" - Execution tag: echo "<% if $VERBOSE %> Long message. <% else %> Short message. <% end %>" | erb " Short message. " - Comment tag: echo "<%# TODO: Fix this nonsense. %> Nonsense." | erb " Nonsense." ## How to Use \ERB You can use \ERB either: - In a program: see class ERB. - From the command line: see [ERB Executable][erb executable]. ## Installation \ERB is installed with Ruby, and so there's no further installation needed. ## Other Template Engines There are a variety of template engines available in various Ruby projects. For example, [RDoc][rdoc], distributed with Ruby, uses its own template engine, which can be reused elsewhere. Other popular template engines may be found in the [Ruby Toolbox][ruby toolbox]. ## Code The \ERB source code is in GitHub project [ruby/erb][ruby/erb]/ ## Bugs Bugs may be reported at [ERB Issues][erb issues]. ## License This software is available as open source under the terms of the [2-Clause BSD License][2-clause bsd license]. [2-clause bsd license]: https://opensource.org/licenses/BSD-2-Clause [erb executable]: rdoc-ref:erb_executable.md [erb issues]: https://github.com/ruby/erb/issues [rdoc]: https://ruby.github.io/rdoc/ [ruby/erb]: https://github.com/ruby/erb [ruby toolbox]: https://www.ruby-toolbox.com/categories/template_engines [sprintf]: https://docs.ruby-lang.org/en/master/Kernel.html#method-i-sprintf [template processor]: https://en.wikipedia.org/wiki/Template_processor_ erb-5.0.3/Rakefile000066400000000000000000000005771507103605700137510ustar00rootroot00000000000000require 'bundler/gem_tasks' require 'rake/testtask' Rake::TestTask.new(:test) do |t| t.libs << 'test/lib' t.ruby_opts << '-rhelper' t.test_files = FileList['test/**/test_*.rb'] end case RUBY_ENGINE when 'jruby', 'truffleruby' # not using C extension else require 'rake/extensiontask' Rake::ExtensionTask.new('erb/escape') task test: :compile end task default: :test erb-5.0.3/_doc/000077500000000000000000000000001507103605700131775ustar00rootroot00000000000000erb-5.0.3/_doc/cgi.rb000066400000000000000000000001231507103605700142620ustar00rootroot00000000000000# See {CGI document}[https://docs.ruby-lang.org/en/master/CGI.html] module CGI end erb-5.0.3/_doc/erb_executable.md000066400000000000000000000126011507103605700164720ustar00rootroot00000000000000# \ERB Executable The `erb` executable gives command-line access to ERB template processing. The executable is installed with \ERB, which is part of the Ruby installation. For a quick summary, type: ```bash $ erb --help ``` The format of the command is `erb [_options_] [_filepaths_]`, where: - _options_ are zero or more [options][options]. - _filepaths_ are zero or more paths to files, each containing an plain text that can include \ERB tags. ## Filepaths With one or more _filepaths_ given, `erb` reads all the given files as a single template; that is, `erb` processes multiple files into a single result: ```bash $ cat t.erb <%= RUBY_VERSION %> <%= Time.now %> $ cat u.erb % Encoding.list.take(4).each do |encoding| * <%= encoding %> % end $ erb t.erb u.erb 3.4.5 2025-09-24 00:23:00 +0100 * ASCII-8BIT * UTF-8 * US-ASCII * UTF-16BE ``` There is a special "filepath", `'-'`, that specifies the standard input: ```bash $ echo "<%= RUBY_VERSION %>" | erb u.erb - * ASCII-8BIT * UTF-8 * US-ASCII * UTF-16BE 3.4.5 ``` Any filepath, including `'-'`, may be repeated. With no _filepaths_ given, `erb` reads and processes the standard input: ```bash $ echo "<%= RUBY_VERSION %>" | erb # Prints the ERB version string. ``` ## Options ### `-d`, `--debug`: Set $DEBUG Use option `-d` or `--debug` to turn on debugging output: ```bash $ echo "<%= $DEBUG %>" | erb "false" $echo "<%= $DEBUG %>" | erb --debug "true" ``` ### `-E`, `--encoding`: Set Encodings Use option `-E` or `--encoding` to set the default external encoding to `_ex_` and, if `_in_` is given, to set the default internal encoding to `_in_`. Each encoding, `ex` and `in`, must be the name of an Encoding: ``` erb -E ASCII-8BIT:ASCII-8BIT t.erb ``` ### `-h`, `--help`: Print Help Use option `-h` or `--help` to print `erb` help text: ```bash $ erb --help ``` ### `-n`: Print Source with Line Numbers Use option `-n` with option `-x` to print the output of ERB#src, with numbered lines: ```bash $ cat t.erb <%= RUBY_VERSION %> <%= Time.now %> $ erb -n -x t.erb 1 #coding:UTF-8 2 _erbout = +''; _erbout.<<(( RUBY_VERSION ).to_s); _erbout.<< "\n".freeze 3 ; _erbout.<<(( Time.now ).to_s); _erbout.<< "\n".freeze 4 ; _erbout ``` Using option `-n` without option `-x` has no effect: ```bash $ erb -n t.erb 3.4.5 2025-09-23 02:44:57 +0100 ``` ### `-P`: Disable Execution Tag Shorthand By default, `erb` enables [execution tag shorthand][execution tag shorthand]: ``` $ cat u.erb % Encoding.list.take(4).each do |encoding| * <%= encoding %> % end $ erb u.erb * ASCII-8BIT * UTF-8 * US-ASCII * UTF-16BE ``` You can use option `-P` to disable the shorthand: ``` $ erb -P u.erb # Raises NameError: "undefined local variable or method 'encoding'" ``` ### `-r`: Load Library You can use option `-r` to load a library; the option may be given multiple times, to load multiple libraries: ``` $ erb -r csv -r bigdecimal t.erb ``` ### `-T`: Set Trim Mode You can use option `-T` to set the trim mode. The values for the option are: - `'0'`, meaning `'%'`; enable execution tag shorthand; see [execution tag shorthand][execution tag shorthand]. - `'1'`, meaning `'%>'`: enable execution tag shorthand and omit newline for each line ending with `'%>'`; see [suppressing unwanted newlines][suppressing unwanted newlines]. - `'2'`, meaning `'<>'`: to suppress the trailing newline for each line that both begins with `'<%'` and ends with `'%>'`; see [suppressing unwanted newlines][suppressing unwanted newlines]. - `'-'`, meaning `'%-'`: enable execution tag shorthand and omit each blank line ending with `'-%>'`. see [execution tag shorthand][execution tag shorthand] and [suppressing unwanted blank lines][suppressing unwanted blank lines]. Example: ```bash $ erb -T 0 t.erb ``` ### `-U`: Set Default Encodings to UTF-8 You can use option `-U` to set both external and internal encodings to UTF-8: ```bash $ erb -U t.erb ``` ### `-v`: Set $VERBOSE Use option `-v` to turn on verbose output: ```bash $ $ "<%= $VERBOSE %>" | erb "false" $ echo "<%= $VERBOSE %>" | erb -v "true" ``` ### `-v`: Print \ERB Version Use option `--version` to print the \ERB version string: ```bash $ erb --version ``` ### `-x`: Print Source Use option `-x` to print the output of ERB#src, which is the Ruby code that is to be run when ERB#result is called: ```bash $ cat t.erb <%= RUBY_VERSION %> <%= Time.now %> $ erb -x t.erb #coding:UTF-8 _erbout = +''; _erbout.<<(( RUBY_VERSION ).to_s); _erbout.<< "\n".freeze ; _erbout.<<(( Time.now ).to_s); _erbout.<< "\n".freeze ; _erbout ``` ### `--`: End of Options You can use option `'--'` to declare the end of options in the `erb` command; `erb` treats each word following as a filepath (even if it looks like an option): ``` erb -- --help # Raises Errno::ENOENT: "No such file or directory @ rb_sysopen - --help" ``` ### `name=value`: Set the Value of a Variable You can use option `name=value` to set the value of the variable named `name` to the given `value`. The option may be given multiple times to set multiple variables: ```bash $ echo "<%= foo %> <%= bar %>" | erb foo=1 bar=2 "1 2" ``` [erb.new]: https://docs.ruby-lang.org/en/master/ERB.html#method-c-new. [execution tag shorthand]: rdoc-ref:ERB@Shorthand+Format+for+Execution+Tags [options]: rdoc-ref:erb_executable.md@Options [suppressing unwanted blank lines]: rdoc-ref:ERB@Suppressing+Unwanted+Blank+Lines [suppressing unwanted newlines]: rdoc-ref:ERB@Suppressing+Unwanted+Newlineserb-5.0.3/bin/000077500000000000000000000000001507103605700130435ustar00rootroot00000000000000erb-5.0.3/bin/console000077500000000000000000000005221507103605700144320ustar00rootroot00000000000000#!/usr/bin/env ruby require "bundler/setup" require "erb" # You can add fixtures and/or initialization code here to make experimenting # with your gem easier. You can also use a different console, if you like. # (If you use this, don't forget to add pry to your Gemfile!) # require "pry" # Pry.start require "irb" IRB.start(__FILE__) erb-5.0.3/bin/setup000077500000000000000000000002031507103605700141240ustar00rootroot00000000000000#!/usr/bin/env bash set -euo pipefail IFS=$'\n\t' set -vx bundle install # Do any other automated setup that you need to do here erb-5.0.3/erb.gemspec000066400000000000000000000021731507103605700144130ustar00rootroot00000000000000begin require_relative 'lib/erb/version' rescue LoadError # for Ruby core repository require_relative 'version' end Gem::Specification.new do |spec| spec.name = 'erb' spec.version = ERB::VERSION spec.authors = ['Masatoshi SEKI', 'Takashi Kokubun'] spec.email = ['seki@ruby-lang.org', 'k0kubun@ruby-lang.org'] spec.summary = %q{An easy to use but powerful templating system for Ruby.} spec.description = %q{An easy to use but powerful templating system for Ruby.} spec.homepage = 'https://github.com/ruby/erb' spec.licenses = ['Ruby', 'BSD-2-Clause'] spec.metadata['homepage_uri'] = spec.homepage spec.metadata['source_code_uri'] = spec.homepage spec.files = Dir.chdir(File.expand_path('..', __FILE__)) do `git ls-files -z`.split("\x0").reject { |f| f.match(%r{^(test|spec|features)/}) } end spec.bindir = 'libexec' spec.executables = ['erb'] spec.require_paths = ['lib'] spec.required_ruby_version = '>= 3.2.0' if RUBY_ENGINE == 'jruby' spec.platform = 'java' else spec.extensions = ['ext/erb/escape/extconf.rb'] end end erb-5.0.3/ext/000077500000000000000000000000001507103605700130735ustar00rootroot00000000000000erb-5.0.3/ext/erb/000077500000000000000000000000001507103605700136435ustar00rootroot00000000000000erb-5.0.3/ext/erb/escape/000077500000000000000000000000001507103605700151035ustar00rootroot00000000000000erb-5.0.3/ext/erb/escape/escape.c000066400000000000000000000050341507103605700165110ustar00rootroot00000000000000#include "ruby.h" #include "ruby/encoding.h" static VALUE rb_cERB, rb_mEscape, rb_cCGI; static ID id_escapeHTML; #define HTML_ESCAPE_MAX_LEN 6 static const struct { uint8_t len; char str[HTML_ESCAPE_MAX_LEN+1]; } html_escape_table[UCHAR_MAX+1] = { #define HTML_ESCAPE(c, str) [c] = {rb_strlen_lit(str), str} HTML_ESCAPE('\'', "'"), HTML_ESCAPE('&', "&"), HTML_ESCAPE('"', """), HTML_ESCAPE('<', "<"), HTML_ESCAPE('>', ">"), #undef HTML_ESCAPE }; static inline void preserve_original_state(VALUE orig, VALUE dest) { rb_enc_associate(dest, rb_enc_get(orig)); } static inline long escaped_length(VALUE str) { const long len = RSTRING_LEN(str); if (len >= LONG_MAX / HTML_ESCAPE_MAX_LEN) { ruby_malloc_size_overflow(len, HTML_ESCAPE_MAX_LEN); } return len * HTML_ESCAPE_MAX_LEN; } static VALUE optimized_escape_html(VALUE str) { VALUE vbuf; char *buf = ALLOCV_N(char, vbuf, escaped_length(str)); const char *cstr = RSTRING_PTR(str); const char *end = cstr + RSTRING_LEN(str); char *dest = buf; while (cstr < end) { const unsigned char c = *cstr++; uint8_t len = html_escape_table[c].len; if (len) { memcpy(dest, html_escape_table[c].str, len); dest += len; } else { *dest++ = c; } } VALUE escaped = str; if (RSTRING_LEN(str) < (dest - buf)) { escaped = rb_str_new(buf, dest - buf); preserve_original_state(str, escaped); } ALLOCV_END(vbuf); return escaped; } /* * ERB::Util.html_escape is similar to CGI.escapeHTML but different in the following two parts: * * * ERB::Util.html_escape converts an argument with #to_s first (only if it's not T_STRING) * * ERB::Util.html_escape does not allocate a new string when nothing needs to be escaped */ static VALUE erb_escape_html(VALUE self, VALUE str) { if (!RB_TYPE_P(str, T_STRING)) { str = rb_convert_type(str, T_STRING, "String", "to_s"); } if (rb_enc_str_asciicompat_p(str)) { return optimized_escape_html(str); } else { return rb_funcall(rb_cCGI, id_escapeHTML, 1, str); } } void Init_escape(void) { #ifdef HAVE_RB_EXT_RACTOR_SAFE rb_ext_ractor_safe(true); #endif rb_cERB = rb_define_class("ERB", rb_cObject); rb_mEscape = rb_define_module_under(rb_cERB, "Escape"); rb_define_module_function(rb_mEscape, "html_escape", erb_escape_html, 1); rb_cCGI = rb_define_class("CGI", rb_cObject); id_escapeHTML = rb_intern("escapeHTML"); } erb-5.0.3/ext/erb/escape/extconf.rb000066400000000000000000000003101507103605700170700ustar00rootroot00000000000000require 'mkmf' case RUBY_ENGINE when 'jruby', 'truffleruby' File.write('Makefile', dummy_makefile($srcdir).join) else have_func("rb_ext_ractor_safe", "ruby.h") create_makefile 'erb/escape' end erb-5.0.3/lib/000077500000000000000000000000001507103605700130415ustar00rootroot00000000000000erb-5.0.3/lib/erb.rb000066400000000000000000001045261507103605700141460ustar00rootroot00000000000000# -*- coding: us-ascii -*- # frozen_string_literal: true # = ERB -- Ruby Templating # # Author:: Masatoshi SEKI # Documentation:: James Edward Gray II, Gavin Sinclair, and Simon Chiang # # See ERB for primary documentation and ERB::Util for a couple of utility # routines. # # Copyright (c) 1999-2000,2002,2003 Masatoshi SEKI # # You can redistribute it and/or modify it under the same terms as Ruby. # A NOTE ABOUT TERMS: # # Formerly: The documentation in this file used the term _template_ to refer to an ERB object. # # Now: The documentation in this file uses the term _template_ # to refer to the string input to ERB.new. # # The reason for the change: When documenting the ERB executable erb, # we need a term that refers to its string input; # _source_ is not a good idea, because ERB#src means something entirely different; # the two different sorts of sources would bring confusion. # # Therefore we use the term _template_ to refer to: # # - The string input to ERB.new # - The string input to executable erb. # require 'erb/version' require 'erb/compiler' require 'erb/def_method' require 'erb/util' # :markup: markdown # # Class **ERB** (the name stands for **Embedded Ruby**) # is an easy-to-use, but also very powerful, [template processor][template processor]. # # ## Usage # # Before you can use \ERB, you must first require it # (examples on this page assume that this has been done): # # ``` # require 'erb' # ``` # # ## In Brief # # Here's how \ERB works: # # - You can create a *template*: a plain-text string that includes specially formatted *tags*.. # - You can create an \ERB object to store the template. # - You can call instance method ERB#result to get the *result*. # # \ERB supports tags of three kinds: # # - [Expression tags][expression tags]: # each begins with `'<%'`, ends with `'%>'`; contains a Ruby expression; # in the result, the value of the expression replaces the entire tag: # # template = 'The magic word is <%= magic_word %>.' # erb = ERB.new(template) # magic_word = 'xyzzy' # erb.result(binding) # => "The magic word is xyzzy." # # The above call to #result passes argument `binding`, # which contains the binding of variable `magic_word` to its string value `'xyzzy'`. # # The below call to #result need not pass a binding, # because its expression `Date::DAYNAMES` is globally defined. # # ERB.new('Today is <%= Date::DAYNAMES[Date.today.wday] %>.').result # => "Today is Monday." # # - [Execution tags][execution tags]: # each begins with `'<%='`, ends with `'%>'`; contains Ruby code to be executed: # # template = '<% File.write("t.txt", "Some stuff.") %>' # ERB.new(template).result # File.read('t.txt') # => "Some stuff." # # - [Comment tags][comment tags]: # each begins with `'<%#'`, ends with `'%>'`; contains comment text; # in the result, the entire tag is omitted. # # template = 'Some stuff;<%# Note to self: figure out what the stuff is. %> more stuff.' # ERB.new(template).result # => "Some stuff; more stuff." # # ## Some Simple Examples # # Here's a simple example of \ERB in action: # # ``` # template = 'The time is <%= Time.now %>.' # erb = ERB.new(template) # erb.result # # => "The time is 2025-09-09 10:49:26 -0500." # ``` # # Details: # # 1. A plain-text string is assigned to variable `template`. # Its embedded [expression tag][expression tags] `'<%= Time.now %>'` includes a Ruby expression, `Time.now`. # 2. The string is put into a new \ERB object, and stored in variable `erb`. # 4. Method call `erb.result` generates a string that contains the run-time value of `Time.now`, # as computed at the time of the call. # # The # \ERB object may be re-used: # # ``` # erb.result # # => "The time is 2025-09-09 10:49:33 -0500." # ``` # # Another example: # # ``` # template = 'The magic word is <%= magic_word %>.' # erb = ERB.new(template) # magic_word = 'abracadabra' # erb.result(binding) # # => "The magic word is abracadabra." # ``` # # Details: # # 1. As before, a plain-text string is assigned to variable `template`. # Its embedded [expression tag][expression tags] `'<%= magic_word %>'` has a variable *name*, `magic_word`. # 2. The string is put into a new \ERB object, and stored in variable `erb`; # note that `magic_word` need not be defined before the \ERB object is created. # 3. `magic_word = 'abracadabra'` assigns a value to variable `magic_word`. # 4. Method call `erb.result(binding)` generates a string # that contains the *value* of `magic_word`. # # As before, the \ERB object may be re-used: # # ``` # magic_word = 'xyzzy' # erb.result(binding) # # => "The magic word is xyzzy." # ``` # # ## Bindings # # A call to method #result, which produces the formatted result string, # requires a [Binding object][binding object] as its argument. # # The binding object provides the bindings for expressions in [expression tags][expression tags]. # # There are three ways to provide the required binding: # # - [Default binding][default binding]. # - [Local binding][local binding]. # - [Augmented binding][augmented binding] # # ### Default Binding # # When you pass no `binding` argument to method #result, # the method uses its default binding: the one returned by method #new_toplevel. # This binding has the bindings defined by Ruby itself, # which are those for Ruby's constants and variables. # # That binding is sufficient for an expression tag that refers only to Ruby's constants and variables; # these expression tags refer only to Ruby's global constant `RUBY_COPYRIGHT` and global variable `$0`: # # ``` # template = <