mirror of
https://github.com/kemko/liquid.git
synced 2026-01-02 08:15:41 +03:00
Compare commits
1 Commits
filter-err
...
v3.0.0.rc1
| Author | SHA1 | Date | |
|---|---|---|---|
|
17db93cf6f |
92
.rubocop.yml
92
.rubocop.yml
@@ -1,92 +0,0 @@
|
||||
inherit_from: ./.rubocop_todo.yml
|
||||
|
||||
AllCops:
|
||||
Exclude:
|
||||
- 'performance/shopify/*'
|
||||
|
||||
Lint/AssignmentInCondition:
|
||||
Enabled: false
|
||||
|
||||
Lint/UnusedBlockArgument:
|
||||
Enabled: false
|
||||
|
||||
Lint/EndAlignment:
|
||||
AlignWith: variable
|
||||
|
||||
Style/SingleLineBlockParams:
|
||||
Enabled: false
|
||||
|
||||
Style/StringLiteralsInInterpolation:
|
||||
Enabled: false
|
||||
|
||||
Style/SignalException:
|
||||
Enabled: false
|
||||
|
||||
Style/StringLiterals:
|
||||
Enabled: false
|
||||
|
||||
Style/BracesAroundHashParameters:
|
||||
Enabled: false
|
||||
|
||||
Style/NumericLiterals:
|
||||
Enabled: false
|
||||
|
||||
Style/SpaceInsideBrackets:
|
||||
Enabled: false
|
||||
|
||||
Style/SpaceBeforeBlockBraces:
|
||||
Enabled: false
|
||||
|
||||
Style/Documentation:
|
||||
Enabled: false
|
||||
|
||||
Style/ClassAndModuleChildren:
|
||||
Enabled: false
|
||||
|
||||
Style/TrailingComma:
|
||||
Enabled: false
|
||||
|
||||
Style/IndentHash:
|
||||
EnforcedStyle: consistent
|
||||
|
||||
Style/FormatString:
|
||||
Enabled: false
|
||||
|
||||
Style/AlignParameters:
|
||||
EnforcedStyle: with_fixed_indentation
|
||||
|
||||
Style/MultilineOperationIndentation:
|
||||
EnforcedStyle: indented
|
||||
|
||||
Style/IfUnlessModifier:
|
||||
Enabled: false
|
||||
|
||||
Style/RaiseArgs:
|
||||
Enabled: false
|
||||
|
||||
Style/DeprecatedHashMethods:
|
||||
Enabled: false
|
||||
|
||||
Style/RegexpLiteral:
|
||||
Enabled: false
|
||||
|
||||
Style/SymbolLiteral:
|
||||
Enabled: false
|
||||
|
||||
Performance/Count:
|
||||
Enabled: false
|
||||
|
||||
Style/ConstantName:
|
||||
Enabled: false
|
||||
|
||||
Style/CaseIndentation:
|
||||
Enabled: false
|
||||
|
||||
Style/ClassVars:
|
||||
Enabled: false
|
||||
|
||||
Style/PerlBackrefs:
|
||||
Enabled: false
|
||||
|
||||
Style/WordArray:
|
||||
Enabled: false
|
||||
@@ -1,142 +0,0 @@
|
||||
# This configuration was generated by `rubocop --auto-gen-config`
|
||||
# on 2015-05-13 19:54:01 +0000 using RuboCop version 0.31.0.
|
||||
# The point is for the user to remove these configuration records
|
||||
# one by one as the offenses are removed from the code base.
|
||||
# Note that changes in the inspected code, or installation of new
|
||||
# versions of RuboCop, may require this file to be generated again.
|
||||
|
||||
# Offense count: 2
|
||||
Lint/AmbiguousOperator:
|
||||
Enabled: false
|
||||
|
||||
# Offense count: 2
|
||||
Lint/AmbiguousRegexpLiteral:
|
||||
Enabled: false
|
||||
|
||||
# Offense count: 1
|
||||
Lint/Eval:
|
||||
Enabled: false
|
||||
|
||||
# Offense count: 4
|
||||
Lint/ParenthesesAsGroupedExpression:
|
||||
Enabled: false
|
||||
|
||||
# Offense count: 3
|
||||
# Cop supports --auto-correct.
|
||||
Lint/UnusedMethodArgument:
|
||||
Enabled: false
|
||||
|
||||
# Offense count: 1
|
||||
Lint/UselessAccessModifier:
|
||||
Enabled: false
|
||||
|
||||
# Offense count: 6
|
||||
Lint/UselessAssignment:
|
||||
Enabled: false
|
||||
|
||||
# Offense count: 51
|
||||
Metrics/AbcSize:
|
||||
Max: 59
|
||||
|
||||
# Offense count: 2
|
||||
Metrics/BlockNesting:
|
||||
Max: 6
|
||||
|
||||
# Offense count: 16
|
||||
# Configuration parameters: CountComments.
|
||||
Metrics/ClassLength:
|
||||
Max: 304
|
||||
|
||||
# Offense count: 10
|
||||
Metrics/CyclomaticComplexity:
|
||||
Max: 15
|
||||
|
||||
# Offense count: 547
|
||||
# Configuration parameters: AllowURI, URISchemes.
|
||||
Metrics/LineLength:
|
||||
Max: 294
|
||||
|
||||
# Offense count: 76
|
||||
# Configuration parameters: CountComments.
|
||||
Metrics/MethodLength:
|
||||
Max: 46
|
||||
|
||||
# Offense count: 1
|
||||
# Configuration parameters: CountComments.
|
||||
Metrics/ModuleLength:
|
||||
Max: 216
|
||||
|
||||
# Offense count: 6
|
||||
Metrics/PerceivedComplexity:
|
||||
Max: 13
|
||||
|
||||
# Offense count: 1
|
||||
Style/AccessorMethodName:
|
||||
Enabled: false
|
||||
|
||||
# Offense count: 2
|
||||
# Cop supports --auto-correct.
|
||||
# Configuration parameters: EnforcedStyle, SupportedStyles.
|
||||
Style/AndOr:
|
||||
Enabled: false
|
||||
|
||||
# Offense count: 2
|
||||
# Cop supports --auto-correct.
|
||||
# Configuration parameters: EnforcedStyle, SupportedStyles, ProceduralMethods, FunctionalMethods, IgnoredMethods.
|
||||
Style/BlockDelimiters:
|
||||
Enabled: false
|
||||
|
||||
# Offense count: 1
|
||||
Style/DoubleNegation:
|
||||
Enabled: false
|
||||
|
||||
# Offense count: 1
|
||||
# Cop supports --auto-correct.
|
||||
# Configuration parameters: EnforcedStyle, SupportedStyles.
|
||||
Style/EmptyLinesAroundClassBody:
|
||||
Enabled: false
|
||||
|
||||
# Offense count: 2
|
||||
# Configuration parameters: MinBodyLength.
|
||||
Style/GuardClause:
|
||||
Enabled: false
|
||||
|
||||
# Offense count: 1
|
||||
# Cop supports --auto-correct.
|
||||
# Configuration parameters: EnforcedStyle, SupportedStyles, UseHashRocketsWithSymbolValues.
|
||||
Style/HashSyntax:
|
||||
Enabled: false
|
||||
|
||||
# Offense count: 13
|
||||
# Configuration parameters: EnforcedStyle, SupportedStyles.
|
||||
Style/MethodName:
|
||||
Enabled: false
|
||||
|
||||
# Offense count: 1
|
||||
Style/MultilineBlockChain:
|
||||
Enabled: false
|
||||
|
||||
# Offense count: 3
|
||||
# Configuration parameters: EnforcedStyle, MinBodyLength, SupportedStyles.
|
||||
Style/Next:
|
||||
Enabled: false
|
||||
|
||||
# Offense count: 3
|
||||
# Configuration parameters: NamePrefix, NamePrefixBlacklist.
|
||||
Style/PredicateName:
|
||||
Enabled: false
|
||||
|
||||
# Offense count: 1
|
||||
Style/RescueModifier:
|
||||
Enabled: false
|
||||
|
||||
# Offense count: 7
|
||||
# Cop supports --auto-correct.
|
||||
# Configuration parameters: AllowAsExpressionSeparator.
|
||||
Style/Semicolon:
|
||||
Enabled: false
|
||||
|
||||
# Offense count: 3
|
||||
# Cop supports --auto-correct.
|
||||
Style/SpecialGlobalVars:
|
||||
Enabled: false
|
||||
10
.travis.yml
10
.travis.yml
@@ -1,17 +1,13 @@
|
||||
language: ruby
|
||||
|
||||
rvm:
|
||||
- 1.9
|
||||
- 2.0
|
||||
- 2.1
|
||||
- 2.2
|
||||
- ruby-head
|
||||
- jruby-19mode
|
||||
- jruby-head
|
||||
- rbx-2
|
||||
|
||||
sudo: false
|
||||
|
||||
matrix:
|
||||
allow_failures:
|
||||
- rvm: rbx-2
|
||||
- rvm: jruby-head
|
||||
|
||||
script: "rake test"
|
||||
|
||||
2
Gemfile
2
Gemfile
@@ -5,6 +5,4 @@ gem 'stackprof', platforms: :mri_21
|
||||
|
||||
group :test do
|
||||
gem 'spy', '0.4.1'
|
||||
gem 'benchmark-ips'
|
||||
gem 'rubocop'
|
||||
end
|
||||
|
||||
88
History.md
88
History.md
@@ -1,74 +1,42 @@
|
||||
# Liquid Change Log
|
||||
# Liquid Version History
|
||||
|
||||
## 4.0.0 / not yet released / branch "master"
|
||||
## 3.0.0 / not yet released / branch "master"
|
||||
|
||||
### Changed
|
||||
* Add sort_natural filter (#554) [Martin Hanzel, arthanzel]
|
||||
* Add forloop.parentloop as a reference to the parent loop (#520) [Justin Li, pushrax]
|
||||
* Block parsing moved to BlockBody class (#458) [Dylan Thacker-Smith, dylanahsmith]
|
||||
* Add concat filter to concatenate arrays (#429) [Diogo Beato, dvbeato]
|
||||
* Ruby 1.9 support dropped (#491) [Justin Li, pushrax]
|
||||
* Liquid::Template.file_system's read_template_file method is no longer passed the context. (#441) [James Reid-Smith, sunblaze]
|
||||
* Remove support for `liquid_methods`
|
||||
|
||||
### Fixed
|
||||
* Fix naming of the "context variable" when dynamically including a template (#559) [Justin Li, pushrax]
|
||||
* Gracefully accept empty strings in the date filter (#555) [Loren Hale, boobooninja]
|
||||
* Fix capturing into variables with a hyphen in the name (#505) [Florian Weingarten, fw42]
|
||||
* Fix case sensitivity regression in date standard filter (#499) [Kelley Reynolds, kreynolds]
|
||||
* Disallow filters with no variable in strict mode (#475) [Justin Li, pushrax]
|
||||
* Disallow variable names in the strict parser that are not valid in the lax parser (#463) [Justin Li, pushrax]
|
||||
* Fix BlockBody#warnings taking exponential time to compute (#486) [Justin Li, pushrax]
|
||||
|
||||
## 3.0.2 / 2015-04-24 / branch "3-0-stable"
|
||||
|
||||
* Expose VariableLookup private members (#551) [Justin Li, pushrax]
|
||||
* Documentation fixes
|
||||
|
||||
## 3.0.1 / 2015-01-23
|
||||
|
||||
* Remove duplicate `index0` key in TableRow tag (#502) [Alfred Xing]
|
||||
|
||||
## 3.0.0 / 2014-11-12
|
||||
|
||||
* Removed Block#end_tag. Instead, override parse with `super` followed by your code. See #446 [Dylan Thacker-Smith, dylanahsmith]
|
||||
* Fixed condition with wrong data types (#423) [Bogdan Gusiev]
|
||||
* Add url_encode to standard filters (#421) [Derrick Reimer, djreimer]
|
||||
* Add uniq to standard filters [Florian Weingarten, fw42]
|
||||
* Add exception_handler feature (#397) and #254 [Bogdan Gusiev, bogdan and Florian Weingarten, fw42]
|
||||
* ...
|
||||
* Add exception_handler feature, see #397 and #254 [Bogdan Gusiev, bogdan and Florian Weingarten, fw42]
|
||||
* Optimize variable parsing to avoid repeated regex evaluation during template rendering #383 [Jason Hiltz-Laforge, jasonhl]
|
||||
* Optimize checking for block interrupts to reduce object allocation #380 [Jason Hiltz-Laforge, jasonhl]
|
||||
* Properly set context rethrow_errors on render! #349 [Thierry Joyal, tjoyal]
|
||||
* Fix broken rendering of variables which are equal to false (#345) [Florian Weingarten, fw42]
|
||||
* Fix broken rendering of variables which are equal to false, see #345 [Florian Weingarten, fw42]
|
||||
* Remove ActionView template handler [Dylan Thacker-Smith, dylanahsmith]
|
||||
* Freeze lots of string literals for new Ruby 2.1 optimization (#297) [Florian Weingarten, fw42]
|
||||
* Allow newlines in tags and variables (#324) [Dylan Thacker-Smith, dylanahsmith]
|
||||
* Freeze lots of string literals for new Ruby 2.1 optimization, see #297 [Florian Weingarten, fw42]
|
||||
* Allow newlines in tags and variables, see #324 [Dylan Thacker-Smith, dylanahsmith]
|
||||
* Tag#parse is called after initialize, which now takes options instead of tokens as the 3rd argument. See #321 [Dylan Thacker-Smith, dylanahsmith]
|
||||
* Raise `Liquid::ArgumentError` instead of `::ArgumentError` when filter has wrong number of arguments #309 [Bogdan Gusiev, bogdan]
|
||||
* Add a to_s default for liquid drops (#306) [Adam Doeler, releod]
|
||||
* Add a to_s default for liquid drops, see #306 [Adam Doeler, releod]
|
||||
* Add strip, lstrip, and rstrip to standard filters [Florian Weingarten, fw42]
|
||||
* Make if, for & case tags return complete and consistent nodelists (#250) [Nick Jones, dntj]
|
||||
* Prevent arbitrary method invocation on condition objects (#274) [Dylan Thacker-Smith, dylanahsmith]
|
||||
* Don't call to_sym when creating conditions for security reasons (#273) [Bouke van der Bijl, bouk]
|
||||
* Fix resource counting bug with respond_to?(:length) (#263) [Florian Weingarten, fw42]
|
||||
* Allow specifying custom patterns for template filenames (#284) [Andrei Gladkyi, agladkyi]
|
||||
* Allow drops to optimize loading a slice of elements (#282) [Tom Burns, boourns]
|
||||
* Support for passing variables to snippets in subdirs (#271) [Joost Hietbrink, joost]
|
||||
* Add a class cache to avoid runtime extend calls (#249) [James Tucker, raggi]
|
||||
* Remove some legacy Ruby 1.8 compatibility code (#276) [Florian Weingarten, fw42]
|
||||
* Add default filter to standard filters (#267) [Derrick Reimer, djreimer]
|
||||
* Add optional strict parsing and warn parsing (#235) [Tristan Hume, trishume]
|
||||
* Add I18n syntax error translation (#241) [Simon Hørup Eskildsen, Sirupsen]
|
||||
* Make sort filter work on enumerable drops (#239) [Florian Weingarten, fw42]
|
||||
* Fix clashing method names in enumerable drops (#238) [Florian Weingarten, fw42]
|
||||
* Make map filter work on enumerable drops (#233) [Florian Weingarten, fw42]
|
||||
* Make if, for & case tags return complete and consistent nodelists, see #250 [Nick Jones, dntj]
|
||||
* Prevent arbitrary method invocation on condition objects, see #274 [Dylan Thacker-Smith, dylanahsmith]
|
||||
* Don't call to_sym when creating conditions for security reasons, see #273 [Bouke van der Bijl, bouk]
|
||||
* Fix resource counting bug with respond_to?(:length), see #263 [Florian Weingarten, fw42]
|
||||
* Allow specifying custom patterns for template filenames, see #284 [Andrei Gladkyi, agladkyi]
|
||||
* Allow drops to optimize loading a slice of elements, see #282 [Tom Burns, boourns]
|
||||
* Support for passing variables to snippets in subdirs, see #271 [Joost Hietbrink, joost]
|
||||
* Add a class cache to avoid runtime extend calls, see #249 [James Tucker, raggi]
|
||||
* Remove some legacy Ruby 1.8 compatibility code, see #276 [Florian Weingarten, fw42]
|
||||
* Add default filter to standard filters, see #267 [Derrick Reimer, djreimer]
|
||||
* Add optional strict parsing and warn parsing, see #235 [Tristan Hume, trishume]
|
||||
* Add I18n syntax error translation, see #241 [Simon Hørup Eskildsen, Sirupsen]
|
||||
* Make sort filter work on enumerable drops, see #239 [Florian Weingarten, fw42]
|
||||
* Fix clashing method names in enumerable drops, see #238 [Florian Weingarten, fw42]
|
||||
* Make map filter work on enumerable drops, see #233 [Florian Weingarten, fw42]
|
||||
* Improved whitespace stripping for blank blocks, related to #216 [Florian Weingarten, fw42]
|
||||
|
||||
## 2.6.1 / 2014-01-10 / branch "2-6-stable"
|
||||
|
||||
Security fix, cherry-picked from master (4e14a65):
|
||||
* Don't call to_sym when creating conditions for security reasons (#273) [Bouke van der Bijl, bouk]
|
||||
* Prevent arbitrary method invocation on condition objects (#274) [Dylan Thacker-Smith, dylanahsmith]
|
||||
* Don't call to_sym when creating conditions for security reasons, see #273 [Bouke van der Bijl, bouk]
|
||||
* Prevent arbitrary method invocation on condition objects, see #274 [Dylan Thacker-Smith, dylanahsmith]
|
||||
|
||||
## 2.6.0 / 2013-11-25
|
||||
|
||||
@@ -97,12 +65,12 @@ The following releases will only be tested against Ruby 1.9 and Ruby 2.0 and are
|
||||
## 2.5.5 / 2014-01-10 / branch "2-5-stable"
|
||||
|
||||
Security fix, cherry-picked from master (4e14a65):
|
||||
* Don't call to_sym when creating conditions for security reasons (#273) [Bouke van der Bijl, bouk]
|
||||
* Prevent arbitrary method invocation on condition objects (#274) [Dylan Thacker-Smith, dylanahsmith]
|
||||
* Don't call to_sym when creating conditions for security reasons, see #273 [Bouke van der Bijl, bouk]
|
||||
* Prevent arbitrary method invocation on condition objects, see #274 [Dylan Thacker-Smith, dylanahsmith]
|
||||
|
||||
## 2.5.4 / 2013-11-11
|
||||
|
||||
* Fix "can't convert Fixnum into String" for "replace" (#173), [wǒ_is神仙, jsw0528]
|
||||
* Fix "can't convert Fixnum into String" for "replace", see #173, [wǒ_is神仙, jsw0528]
|
||||
|
||||
## 2.5.3 / 2013-10-09
|
||||
|
||||
|
||||
@@ -1,5 +1,5 @@
|
||||
[](http://travis-ci.org/Shopify/liquid)
|
||||
[](http://inch-ci.org/github/Shopify/liquid)
|
||||
[](http://travis-ci.org/Shopify/liquid)
|
||||
[](http://inch-ci.org/github/Shopify/liquid)
|
||||
|
||||
# Liquid template engine
|
||||
|
||||
|
||||
17
Rakefile
17
Rakefile
@@ -3,7 +3,7 @@ require 'rake/testtask'
|
||||
$LOAD_PATH.unshift File.expand_path("../lib", __FILE__)
|
||||
require "liquid/version"
|
||||
|
||||
task default: [:rubocop, :test]
|
||||
task :default => 'test'
|
||||
|
||||
desc 'run test suite with default parser'
|
||||
Rake::TestTask.new(:base_test) do |t|
|
||||
@@ -18,11 +18,6 @@ task :warn_test do
|
||||
Rake::Task['base_test'].invoke
|
||||
end
|
||||
|
||||
task :rubocop do
|
||||
require 'rubocop/rake_task'
|
||||
RuboCop::RakeTask.new
|
||||
end
|
||||
|
||||
desc 'runs test suite with both strict and lax parsers'
|
||||
task :test do
|
||||
ENV['LIQUID_PARSER_MODE'] = 'lax'
|
||||
@@ -32,16 +27,16 @@ task :test do
|
||||
Rake::Task['base_test'].invoke
|
||||
end
|
||||
|
||||
task gem: :build
|
||||
task :gem => :build
|
||||
task :build do
|
||||
system "gem build liquid.gemspec"
|
||||
end
|
||||
|
||||
task install: :build do
|
||||
task :install => :build do
|
||||
system "gem install liquid-#{Liquid::VERSION}.gem"
|
||||
end
|
||||
|
||||
task release: :build do
|
||||
task :release => :build do
|
||||
system "git tag -a v#{Liquid::VERSION} -m 'Tagging #{Liquid::VERSION}'"
|
||||
system "git push --tags"
|
||||
system "gem push liquid-#{Liquid::VERSION}.gem"
|
||||
@@ -49,6 +44,7 @@ task release: :build do
|
||||
end
|
||||
|
||||
namespace :benchmark do
|
||||
|
||||
desc "Run the liquid benchmark with lax parsing"
|
||||
task :run do
|
||||
ruby "./performance/benchmark.rb lax"
|
||||
@@ -60,7 +56,9 @@ namespace :benchmark do
|
||||
end
|
||||
end
|
||||
|
||||
|
||||
namespace :profile do
|
||||
|
||||
desc "Run the liquid profile/performance coverage"
|
||||
task :run do
|
||||
ruby "./performance/profile.rb"
|
||||
@@ -70,6 +68,7 @@ namespace :profile do
|
||||
task :strict do
|
||||
ruby "./performance/profile.rb strict"
|
||||
end
|
||||
|
||||
end
|
||||
|
||||
desc "Run example"
|
||||
|
||||
@@ -1,3 +0,0 @@
|
||||
machine:
|
||||
ruby:
|
||||
version: ruby-2.0
|
||||
@@ -4,7 +4,7 @@ module ProductsFilter
|
||||
end
|
||||
|
||||
def prettyprint(text)
|
||||
text.gsub(/\*(.*)\*/, '<b>\1</b>')
|
||||
text.gsub( /\*(.*)\*/, '<b>\1</b>' )
|
||||
end
|
||||
|
||||
def count(array)
|
||||
@@ -17,28 +17,25 @@ module ProductsFilter
|
||||
end
|
||||
|
||||
class Servlet < LiquidServlet
|
||||
|
||||
def index
|
||||
{ 'date' => Time.now }
|
||||
end
|
||||
|
||||
def products
|
||||
{ 'products' => products_list, 'more_products' => more_products_list, 'description' => description, 'section' => 'Snowboards', 'cool_products' => true }
|
||||
{ 'products' => products_list, 'description' => description, 'section' => 'Snowboards', 'cool_products' => true}
|
||||
end
|
||||
|
||||
private
|
||||
|
||||
def products_list
|
||||
[{ 'name' => 'Arbor Draft', 'price' => 39900, 'description' => 'the *arbor draft* is a excellent product' },
|
||||
{ 'name' => 'Arbor Element', 'price' => 40000, 'description' => 'the *arbor element* rocks for freestyling' },
|
||||
{ 'name' => 'Arbor Diamond', 'price' => 59900, 'description' => 'the *arbor diamond* is a made up product because im obsessed with arbor and have no creativity' }]
|
||||
end
|
||||
|
||||
def more_products_list
|
||||
[{ 'name' => 'Arbor Catalyst', 'price' => 39900, 'description' => 'the *arbor catalyst* is an advanced drop-through for freestyle and flatground performance and versatility' },
|
||||
{ 'name' => 'Arbor Fish', 'price' => 40000, 'description' => 'the *arbor fish* is a compact pin that features an extended wheelbase and time-honored teardrop shape' }]
|
||||
[{'name' => 'Arbor Draft', 'price' => 39900, 'description' => 'the *arbor draft* is a excellent product' },
|
||||
{'name' => 'Arbor Element', 'price' => 40000, 'description' => 'the *arbor element* rocks for freestyling'},
|
||||
{'name' => 'Arbor Diamond', 'price' => 59900, 'description' => 'the *arbor diamond* is a made up product because im obsessed with arbor and have no creativity'}]
|
||||
end
|
||||
|
||||
def description
|
||||
"List of Products ~ This is a list of products with price and description."
|
||||
end
|
||||
|
||||
end
|
||||
|
||||
@@ -11,8 +11,7 @@ class LiquidServlet < WEBrick::HTTPServlet::AbstractServlet
|
||||
private
|
||||
|
||||
def handle(type, req, res)
|
||||
@request = req
|
||||
@response = res
|
||||
@request, @response = req, res
|
||||
|
||||
@request.path_info =~ /(\w+)\z/
|
||||
@action = $1 || 'index'
|
||||
@@ -24,6 +23,6 @@ class LiquidServlet < WEBrick::HTTPServlet::AbstractServlet
|
||||
end
|
||||
|
||||
def read_template(filename = @action)
|
||||
File.read("#{__dir__}/templates/#{filename}.liquid")
|
||||
File.read( File.dirname(__FILE__) + "/templates/#{filename}.liquid" )
|
||||
end
|
||||
end
|
||||
|
||||
@@ -1,12 +1,14 @@
|
||||
require 'webrick'
|
||||
require 'rexml/document'
|
||||
|
||||
require_relative '../../lib/liquid'
|
||||
require_relative 'liquid_servlet'
|
||||
require_relative 'example_servlet'
|
||||
DIR = File.expand_path(File.dirname(__FILE__))
|
||||
|
||||
require DIR + '/../../lib/liquid'
|
||||
require DIR + '/liquid_servlet'
|
||||
require DIR + '/example_servlet'
|
||||
|
||||
# Setup webrick
|
||||
server = WEBrick::HTTPServer.new(Port: ARGV[1] || 3000)
|
||||
server = WEBrick::HTTPServer.new( :Port => ARGV[1] || 3000 )
|
||||
server.mount('/', Servlet)
|
||||
trap("INT"){ server.shutdown }
|
||||
server.start
|
||||
|
||||
@@ -16,12 +16,12 @@
|
||||
</head>
|
||||
|
||||
<body>
|
||||
{% assign all_products = products | concat: more_products %}
|
||||
|
||||
<h1>{{ description | split: '~' | first }}</h1>
|
||||
|
||||
<h2>{{ description | split: '~' | last }}</h2>
|
||||
|
||||
<h2>There are currently {{all_products | count}} products in the {{section}} catalog</h2>
|
||||
<h2>There are currently {{products | count}} products in the {{section}} catalog</h2>
|
||||
|
||||
{% if cool_products %}
|
||||
Cool products :)
|
||||
@@ -31,7 +31,7 @@
|
||||
|
||||
<ul id="products">
|
||||
|
||||
{% for product in all_products %}
|
||||
{% for product in products %}
|
||||
<li>
|
||||
<h2>{{product.name}}</h2>
|
||||
Only {{product.price | price }}
|
||||
|
||||
@@ -52,24 +52,18 @@ require 'liquid/extensions'
|
||||
require 'liquid/errors'
|
||||
require 'liquid/interrupts'
|
||||
require 'liquid/strainer'
|
||||
require 'liquid/expression'
|
||||
require 'liquid/context'
|
||||
require 'liquid/parser_switching'
|
||||
require 'liquid/tag'
|
||||
require 'liquid/block'
|
||||
require 'liquid/block_body'
|
||||
require 'liquid/document'
|
||||
require 'liquid/variable'
|
||||
require 'liquid/variable_lookup'
|
||||
require 'liquid/range_lookup'
|
||||
require 'liquid/file_system'
|
||||
require 'liquid/resource_limits'
|
||||
require 'liquid/template'
|
||||
require 'liquid/standardfilters'
|
||||
require 'liquid/condition'
|
||||
require 'liquid/module_ex'
|
||||
require 'liquid/utils'
|
||||
require 'liquid/token'
|
||||
|
||||
# Load all the tags of the standard library
|
||||
#
|
||||
Dir["#{__dir__}/liquid/tags/*.rb"].each { |f| require f }
|
||||
Dir[File.dirname(__FILE__) + '/liquid/tags/*.rb'].each { |f| require f }
|
||||
|
||||
@@ -1,26 +1,65 @@
|
||||
module Liquid
|
||||
class Block < Tag
|
||||
def initialize(tag_name, markup, options)
|
||||
super
|
||||
@blank = true
|
||||
end
|
||||
|
||||
def parse(tokens)
|
||||
@body = BlockBody.new
|
||||
while more = parse_body(@body, tokens)
|
||||
end
|
||||
end
|
||||
|
||||
def render(context)
|
||||
@body.render(context)
|
||||
end
|
||||
FullToken = /\A#{TagStart}\s*(\w+)\s*(.*)?#{TagEnd}\z/om
|
||||
ContentOfVariable = /\A#{VariableStart}(.*)#{VariableEnd}\z/om
|
||||
TAGSTART = "{%".freeze
|
||||
VARSTART = "{{".freeze
|
||||
|
||||
def blank?
|
||||
@blank
|
||||
end
|
||||
|
||||
def nodelist
|
||||
@body.nodelist
|
||||
def parse(tokens)
|
||||
@blank = true
|
||||
@nodelist ||= []
|
||||
@nodelist.clear
|
||||
|
||||
# All child tags of the current block.
|
||||
@children = []
|
||||
|
||||
while token = tokens.shift
|
||||
unless token.empty?
|
||||
case
|
||||
when token.start_with?(TAGSTART)
|
||||
if token =~ FullToken
|
||||
|
||||
# if we found the proper block delimiter just end parsing here and let the outer block
|
||||
# proceed
|
||||
if block_delimiter == $1
|
||||
end_tag
|
||||
return
|
||||
end
|
||||
|
||||
# fetch the tag from registered blocks
|
||||
if tag = Template.tags[$1]
|
||||
new_tag = tag.parse($1, $2, tokens, @options)
|
||||
@blank &&= new_tag.blank?
|
||||
@nodelist << new_tag
|
||||
@children << new_tag
|
||||
else
|
||||
# this tag is not registered with the system
|
||||
# pass it to the current block for special handling or error reporting
|
||||
unknown_tag($1, $2, tokens)
|
||||
end
|
||||
else
|
||||
raise SyntaxError.new(options[:locale].t("errors.syntax.tag_termination".freeze, :token => token, :tag_end => TagEnd.inspect))
|
||||
end
|
||||
when token.start_with?(VARSTART)
|
||||
new_var = create_variable(token)
|
||||
@nodelist << new_var
|
||||
@children << new_var
|
||||
@blank = false
|
||||
else
|
||||
@nodelist << token
|
||||
@blank &&= (token =~ /\A\s*\z/)
|
||||
end
|
||||
end
|
||||
end
|
||||
|
||||
# Make sure that it's ok to end parsing in the current block.
|
||||
# Effectively this method will throw an exception unless the current block is
|
||||
# of type Document
|
||||
assert_missing_delimitation!
|
||||
end
|
||||
|
||||
# warnings of this block and all sub-tags
|
||||
@@ -28,24 +67,27 @@ module Liquid
|
||||
all_warnings = []
|
||||
all_warnings.concat(@warnings) if @warnings
|
||||
|
||||
(nodelist || []).each do |node|
|
||||
all_warnings.concat(node.warnings || []) if node.respond_to?(:warnings)
|
||||
(@children || []).each do |node|
|
||||
all_warnings.concat(node.warnings || [])
|
||||
end
|
||||
|
||||
all_warnings
|
||||
end
|
||||
|
||||
def unknown_tag(tag, _params, _tokens)
|
||||
def end_tag
|
||||
end
|
||||
|
||||
def unknown_tag(tag, params, tokens)
|
||||
case tag
|
||||
when 'else'.freeze
|
||||
raise SyntaxError.new(options[:locale].t("errors.syntax.unexpected_else".freeze,
|
||||
block_name: block_name))
|
||||
:block_name => block_name))
|
||||
when 'end'.freeze
|
||||
raise SyntaxError.new(options[:locale].t("errors.syntax.invalid_delimiter".freeze,
|
||||
block_name: block_name,
|
||||
block_delimiter: block_delimiter))
|
||||
:block_name => block_name,
|
||||
:block_delimiter => block_delimiter))
|
||||
else
|
||||
raise SyntaxError.new(options[:locale].t("errors.syntax.unknown_tag".freeze, tag: tag))
|
||||
raise SyntaxError.new(options[:locale].t("errors.syntax.unknown_tag".freeze, :tag => tag))
|
||||
end
|
||||
end
|
||||
|
||||
@@ -57,23 +99,58 @@ module Liquid
|
||||
@block_delimiter ||= "end#{block_name}"
|
||||
end
|
||||
|
||||
def create_variable(token)
|
||||
token.scan(ContentOfVariable) do |content|
|
||||
return Variable.new(content.first, @options)
|
||||
end
|
||||
raise SyntaxError.new(options[:locale].t("errors.syntax.variable_termination".freeze, :token => token, :tag_end => VariableEnd.inspect))
|
||||
end
|
||||
|
||||
def render(context)
|
||||
render_all(@nodelist, context)
|
||||
end
|
||||
|
||||
protected
|
||||
|
||||
def parse_body(body, tokens)
|
||||
body.parse(tokens, options) do |end_tag_name, end_tag_params|
|
||||
@blank &&= body.blank?
|
||||
def assert_missing_delimitation!
|
||||
raise SyntaxError.new(options[:locale].t("errors.syntax.tag_never_closed".freeze, :block_name => block_name))
|
||||
end
|
||||
|
||||
return false if end_tag_name == block_delimiter
|
||||
unless end_tag_name
|
||||
raise SyntaxError.new(@options[:locale].t("errors.syntax.tag_never_closed".freeze, block_name: block_name))
|
||||
def render_all(list, context)
|
||||
output = []
|
||||
context.resource_limits[:render_length_current] = 0
|
||||
context.resource_limits[:render_score_current] += list.length
|
||||
|
||||
list.each do |token|
|
||||
# Break out if we have any unhanded interrupts.
|
||||
break if context.has_interrupt?
|
||||
|
||||
begin
|
||||
# If we get an Interrupt that means the block must stop processing. An
|
||||
# Interrupt is any command that stops block execution such as {% break %}
|
||||
# or {% continue %}
|
||||
if token.is_a? Continue or token.is_a? Break
|
||||
context.push_interrupt(token.interrupt)
|
||||
break
|
||||
end
|
||||
|
||||
token_output = (token.respond_to?(:render) ? token.render(context) : token)
|
||||
context.increment_used_resources(:render_length_current, token_output)
|
||||
if context.resource_limits_reached?
|
||||
context.resource_limits[:reached] = true
|
||||
raise MemoryError.new("Memory limits exceeded".freeze)
|
||||
end
|
||||
unless token.is_a?(Block) && token.blank?
|
||||
output << token_output
|
||||
end
|
||||
rescue MemoryError => e
|
||||
raise e
|
||||
rescue ::StandardError => e
|
||||
output << (context.handle_error(e))
|
||||
end
|
||||
|
||||
# this tag is not registered with the system
|
||||
# pass it to the current block for special handling or error reporting
|
||||
unknown_tag(end_tag_name, end_tag_params, tokens)
|
||||
end
|
||||
|
||||
true
|
||||
output.join
|
||||
end
|
||||
end
|
||||
end
|
||||
|
||||
@@ -1,131 +0,0 @@
|
||||
module Liquid
|
||||
class BlockBody
|
||||
FullToken = /\A#{TagStart}\s*(\w+)\s*(.*)?#{TagEnd}\z/om
|
||||
ContentOfVariable = /\A#{VariableStart}(.*)#{VariableEnd}\z/om
|
||||
TAGSTART = "{%".freeze
|
||||
VARSTART = "{{".freeze
|
||||
|
||||
attr_reader :nodelist
|
||||
|
||||
def initialize
|
||||
@nodelist = []
|
||||
@blank = true
|
||||
end
|
||||
|
||||
def parse(tokens, options)
|
||||
while token = tokens.shift
|
||||
begin
|
||||
unless token.empty?
|
||||
case
|
||||
when token.start_with?(TAGSTART)
|
||||
if token =~ FullToken
|
||||
tag_name = $1
|
||||
markup = $2
|
||||
# fetch the tag from registered blocks
|
||||
if tag = Template.tags[tag_name]
|
||||
markup = token.child(markup) if token.is_a?(Token)
|
||||
new_tag = tag.parse(tag_name, markup, tokens, options)
|
||||
new_tag.line_number = token.line_number if token.is_a?(Token)
|
||||
@blank &&= new_tag.blank?
|
||||
@nodelist << new_tag
|
||||
else
|
||||
# end parsing if we reach an unknown tag and let the caller decide
|
||||
# determine how to proceed
|
||||
return yield tag_name, markup
|
||||
end
|
||||
else
|
||||
raise_missing_tag_terminator(token, options)
|
||||
end
|
||||
when token.start_with?(VARSTART)
|
||||
new_var = create_variable(token, options)
|
||||
new_var.line_number = token.line_number if token.is_a?(Token)
|
||||
@nodelist << new_var
|
||||
@blank = false
|
||||
else
|
||||
@nodelist << token
|
||||
@blank &&= !!(token =~ /\A\s*\z/)
|
||||
end
|
||||
end
|
||||
rescue SyntaxError => e
|
||||
e.set_line_number_from_token(token)
|
||||
raise
|
||||
end
|
||||
end
|
||||
|
||||
yield nil, nil
|
||||
end
|
||||
|
||||
def blank?
|
||||
@blank
|
||||
end
|
||||
|
||||
def warnings
|
||||
all_warnings = []
|
||||
nodelist.each do |node|
|
||||
all_warnings.concat(node.warnings || []) if node.respond_to?(:warnings)
|
||||
end
|
||||
all_warnings
|
||||
end
|
||||
|
||||
def render(context)
|
||||
output = []
|
||||
context.resource_limits.render_score += @nodelist.length
|
||||
|
||||
@nodelist.each do |token|
|
||||
# Break out if we have any unhanded interrupts.
|
||||
break if context.has_interrupt?
|
||||
|
||||
begin
|
||||
# If we get an Interrupt that means the block must stop processing. An
|
||||
# Interrupt is any command that stops block execution such as {% break %}
|
||||
# or {% continue %}
|
||||
if token.is_a?(Continue) || token.is_a?(Break)
|
||||
context.push_interrupt(token.interrupt)
|
||||
break
|
||||
end
|
||||
|
||||
token_output = render_token(token, context)
|
||||
|
||||
unless token.is_a?(Block) && token.blank?
|
||||
output << token_output
|
||||
end
|
||||
rescue MemoryError => e
|
||||
raise e
|
||||
rescue ::StandardError => e
|
||||
output << context.handle_error(e, token)
|
||||
end
|
||||
end
|
||||
|
||||
output.join
|
||||
end
|
||||
|
||||
private
|
||||
|
||||
def render_token(token, context)
|
||||
token_output = (token.respond_to?(:render) ? token.render(context) : token)
|
||||
token_str = token_output.is_a?(Array) ? token_output.join : token_output.to_s
|
||||
|
||||
context.resource_limits.render_length += token_str.length
|
||||
if context.resource_limits.reached?
|
||||
raise MemoryError.new("Memory limits exceeded".freeze)
|
||||
end
|
||||
token_str
|
||||
end
|
||||
|
||||
def create_variable(token, options)
|
||||
token.scan(ContentOfVariable) do |content|
|
||||
markup = token.is_a?(Token) ? token.child(content.first) : content.first
|
||||
return Variable.new(markup, options)
|
||||
end
|
||||
raise_missing_variable_terminator(token, options)
|
||||
end
|
||||
|
||||
def raise_missing_tag_terminator(token, options)
|
||||
raise SyntaxError.new(options[:locale].t("errors.syntax.tag_termination".freeze, token: token, tag_end: TagEnd.inspect))
|
||||
end
|
||||
|
||||
def raise_missing_variable_terminator(token, options)
|
||||
raise SyntaxError.new(options[:locale].t("errors.syntax.variable_termination".freeze, token: token, tag_end: VariableEnd.inspect))
|
||||
end
|
||||
end
|
||||
end
|
||||
@@ -3,21 +3,19 @@ module Liquid
|
||||
#
|
||||
# Example:
|
||||
#
|
||||
# c = Condition.new(1, '==', 1)
|
||||
# c = Condition.new('1', '==', '1')
|
||||
# c.evaluate #=> true
|
||||
#
|
||||
class Condition #:nodoc:
|
||||
@@operators = {
|
||||
'=='.freeze => ->(cond, left, right) { cond.send(:equal_variables, left, right) },
|
||||
'!='.freeze => ->(cond, left, right) { !cond.send(:equal_variables, left, right) },
|
||||
'<>'.freeze => ->(cond, left, right) { !cond.send(:equal_variables, left, right) },
|
||||
'=='.freeze => lambda { |cond, left, right| cond.send(:equal_variables, left, right) },
|
||||
'!='.freeze => lambda { |cond, left, right| !cond.send(:equal_variables, left, right) },
|
||||
'<>'.freeze => lambda { |cond, left, right| !cond.send(:equal_variables, left, right) },
|
||||
'<'.freeze => :<,
|
||||
'>'.freeze => :>,
|
||||
'>='.freeze => :>=,
|
||||
'<='.freeze => :<=,
|
||||
'contains'.freeze => lambda do |cond, left, right|
|
||||
left && right && left.respond_to?(:include?) ? left.include?(right) : false
|
||||
end
|
||||
'contains'.freeze => lambda { |cond, left, right| left && right ? left.include?(right) : false }
|
||||
}
|
||||
|
||||
def self.operators
|
||||
@@ -28,9 +26,7 @@ module Liquid
|
||||
attr_accessor :left, :operator, :right
|
||||
|
||||
def initialize(left = nil, operator = nil, right = nil)
|
||||
@left = left
|
||||
@operator = operator
|
||||
@right = right
|
||||
@left, @operator, @right = left, operator, right
|
||||
@child_relation = nil
|
||||
@child_condition = nil
|
||||
end
|
||||
@@ -49,13 +45,11 @@ module Liquid
|
||||
end
|
||||
|
||||
def or(condition)
|
||||
@child_relation = :or
|
||||
@child_condition = condition
|
||||
@child_relation, @child_condition = :or, condition
|
||||
end
|
||||
|
||||
def and(condition)
|
||||
@child_relation = :and
|
||||
@child_condition = condition
|
||||
@child_relation, @child_condition = :and, condition
|
||||
end
|
||||
|
||||
def attach(attachment)
|
||||
@@ -96,32 +90,35 @@ module Liquid
|
||||
# If the operator is empty this means that the decision statement is just
|
||||
# a single variable. We can just poll this variable from the context and
|
||||
# return this as the result.
|
||||
return context.evaluate(left) if op.nil?
|
||||
return context[left] if op == nil
|
||||
|
||||
left = context.evaluate(left)
|
||||
right = context.evaluate(right)
|
||||
left, right = context[left], context[right]
|
||||
|
||||
operation = self.class.operators[op] || raise(Liquid::ArgumentError.new("Unknown operator #{op}"))
|
||||
|
||||
if operation.respond_to?(:call)
|
||||
operation.call(self, left, right)
|
||||
elsif left.respond_to?(operation) && right.respond_to?(operation)
|
||||
elsif left.respond_to?(operation) and right.respond_to?(operation)
|
||||
begin
|
||||
left.send(operation, right)
|
||||
rescue ::ArgumentError => e
|
||||
raise Liquid::ArgumentError.new(e.message)
|
||||
end
|
||||
else
|
||||
nil
|
||||
end
|
||||
end
|
||||
end
|
||||
|
||||
|
||||
class ElseCondition < Condition
|
||||
def else?
|
||||
true
|
||||
end
|
||||
|
||||
def evaluate(_context)
|
||||
def evaluate(context)
|
||||
true
|
||||
end
|
||||
end
|
||||
|
||||
end
|
||||
|
||||
@@ -1,4 +1,5 @@
|
||||
module Liquid
|
||||
|
||||
# Context keeps the variable stack and resolves variables, as well as keywords
|
||||
#
|
||||
# context['variable'] = 'testing'
|
||||
@@ -13,18 +14,17 @@ module Liquid
|
||||
# context['bob'] #=> nil class Context
|
||||
class Context
|
||||
attr_reader :scopes, :errors, :registers, :environments, :resource_limits
|
||||
attr_accessor :exception_handler, :render_errors
|
||||
attr_accessor :exception_handler
|
||||
|
||||
def initialize(environments = {}, outer_scope = {}, registers = {}, rethrow_errors = false, resource_limits = nil)
|
||||
@environments = [environments].flatten
|
||||
@scopes = [(outer_scope || {})]
|
||||
@registers = registers
|
||||
@errors = []
|
||||
@resource_limits = resource_limits || ResourceLimits.new(Template.default_resource_limits)
|
||||
SQUARE_BRACKETED = /\A\[(.*)\]\z/m
|
||||
|
||||
def initialize(environments = {}, outer_scope = {}, registers = {}, rethrow_errors = false, resource_limits = {})
|
||||
@environments = [environments].flatten
|
||||
@scopes = [(outer_scope || {})]
|
||||
@registers = registers
|
||||
@errors = []
|
||||
@resource_limits = (resource_limits || {}).merge!({ :render_score_current => 0, :assign_score_current => 0 })
|
||||
squash_instance_assigns_with_environments
|
||||
@render_errors = true
|
||||
|
||||
@this_stack_used = false
|
||||
|
||||
if rethrow_errors
|
||||
self.exception_handler = ->(e) { true }
|
||||
@@ -32,6 +32,21 @@ module Liquid
|
||||
|
||||
@interrupts = []
|
||||
@filters = []
|
||||
@parsed_variables = Hash.new{ |cache, markup| cache[markup] = variable_parse(markup) }
|
||||
end
|
||||
|
||||
def increment_used_resources(key, obj)
|
||||
@resource_limits[key] += if obj.kind_of?(String) || obj.kind_of?(Array) || obj.kind_of?(Hash)
|
||||
obj.length
|
||||
else
|
||||
1
|
||||
end
|
||||
end
|
||||
|
||||
def resource_limits_reached?
|
||||
(@resource_limits[:render_length_limit] && @resource_limits[:render_length_current] > @resource_limits[:render_length_limit]) ||
|
||||
(@resource_limits[:render_score_limit] && @resource_limits[:render_score_current] > @resource_limits[:render_score_limit] ) ||
|
||||
(@resource_limits[:assign_score_limit] && @resource_limits[:assign_score_current] > @resource_limits[:assign_score_limit] )
|
||||
end
|
||||
|
||||
def strainer
|
||||
@@ -44,8 +59,21 @@ module Liquid
|
||||
# for that
|
||||
def add_filters(filters)
|
||||
filters = [filters].flatten.compact
|
||||
@filters += filters
|
||||
@strainer = nil
|
||||
filters.each do |f|
|
||||
raise ArgumentError, "Expected module but got: #{f.class}" unless f.is_a?(Module)
|
||||
Strainer.add_known_filter(f)
|
||||
end
|
||||
|
||||
# If strainer is already setup then there's no choice but to use a runtime
|
||||
# extend call. If strainer is not yet created, we can utilize strainers
|
||||
# cached class based API, which avoids busting the method cache.
|
||||
if @strainer
|
||||
filters.each do |f|
|
||||
strainer.extend(f)
|
||||
end
|
||||
else
|
||||
@filters.concat filters
|
||||
end
|
||||
end
|
||||
|
||||
# are there any not handled interrupts?
|
||||
@@ -63,22 +91,25 @@ module Liquid
|
||||
@interrupts.pop
|
||||
end
|
||||
|
||||
def handle_error(e, token = nil)
|
||||
if e.is_a?(Liquid::Error)
|
||||
e.set_line_number_from_token(token)
|
||||
end
|
||||
|
||||
def handle_error(e)
|
||||
errors.push(e)
|
||||
|
||||
raise if exception_handler && exception_handler.call(e)
|
||||
render_errors ? Liquid::Error.render(e) : ''
|
||||
|
||||
case e
|
||||
when SyntaxError
|
||||
"Liquid syntax error: #{e.message}"
|
||||
else
|
||||
"Liquid error: #{e.message}"
|
||||
end
|
||||
end
|
||||
|
||||
def invoke(method, *args)
|
||||
strainer.invoke(method, *args).to_liquid
|
||||
strainer.invoke(method, *args)
|
||||
end
|
||||
|
||||
# Push new local scope on the stack. use <tt>Context#stack</tt> instead
|
||||
def push(new_scope = {})
|
||||
def push(new_scope={})
|
||||
@scopes.unshift(new_scope)
|
||||
raise StackLevelError, "Nesting too deep".freeze if @scopes.length > 100
|
||||
end
|
||||
@@ -102,19 +133,11 @@ module Liquid
|
||||
# end
|
||||
#
|
||||
# context['var] #=> nil
|
||||
def stack(new_scope = nil)
|
||||
old_stack_used = @this_stack_used
|
||||
if new_scope
|
||||
push(new_scope)
|
||||
@this_stack_used = true
|
||||
else
|
||||
@this_stack_used = false
|
||||
end
|
||||
|
||||
def stack(new_scope={})
|
||||
push(new_scope)
|
||||
yield
|
||||
ensure
|
||||
pop if @this_stack_used
|
||||
@this_stack_used = old_stack_used
|
||||
pop
|
||||
end
|
||||
|
||||
def clear_instance_assigns
|
||||
@@ -123,80 +146,161 @@ module Liquid
|
||||
|
||||
# Only allow String, Numeric, Hash, Array, Proc, Boolean or <tt>Liquid::Drop</tt>
|
||||
def []=(key, value)
|
||||
unless @this_stack_used
|
||||
@this_stack_used = true
|
||||
push({})
|
||||
end
|
||||
@scopes[0][key] = value
|
||||
end
|
||||
|
||||
# Look up variable, either resolve directly after considering the name. We can directly handle
|
||||
# Strings, digits, floats and booleans (true,false).
|
||||
# If no match is made we lookup the variable in the current scope and
|
||||
# later move up to the parent blocks to see if we can resolve the variable somewhere up the tree.
|
||||
# Some special keywords return symbols. Those symbols are to be called on the rhs object in expressions
|
||||
#
|
||||
# Example:
|
||||
# products == empty #=> products.empty?
|
||||
def [](expression)
|
||||
evaluate(Expression.parse(expression))
|
||||
def [](key)
|
||||
resolve(key)
|
||||
end
|
||||
|
||||
def has_key?(key)
|
||||
self[key] != nil
|
||||
end
|
||||
|
||||
def evaluate(object)
|
||||
object.respond_to?(:evaluate) ? object.evaluate(self) : object
|
||||
end
|
||||
|
||||
# Fetches an object starting at the local scope and then moving up the hierachy
|
||||
def find_variable(key)
|
||||
# This was changed from find() to find_index() because this is a very hot
|
||||
# path and find_index() is optimized in MRI to reduce object allocation
|
||||
index = @scopes.find_index { |s| s.has_key?(key) }
|
||||
scope = @scopes[index] if index
|
||||
|
||||
variable = nil
|
||||
|
||||
if scope.nil?
|
||||
@environments.each do |e|
|
||||
variable = lookup_and_evaluate(e, key)
|
||||
unless variable.nil?
|
||||
scope = e
|
||||
break
|
||||
end
|
||||
end
|
||||
end
|
||||
|
||||
scope ||= @environments.last || @scopes.last
|
||||
variable ||= lookup_and_evaluate(scope, key)
|
||||
|
||||
variable = variable.to_liquid
|
||||
variable.context = self if variable.respond_to?(:context=)
|
||||
|
||||
variable
|
||||
end
|
||||
|
||||
def lookup_and_evaluate(obj, key)
|
||||
if (value = obj[key]).is_a?(Proc) && obj.respond_to?(:[]=)
|
||||
obj[key] = (value.arity == 0) ? value.call : value.call(self)
|
||||
else
|
||||
value
|
||||
end
|
||||
resolve(key) != nil
|
||||
end
|
||||
|
||||
private
|
||||
LITERALS = {
|
||||
nil => nil, 'nil'.freeze => nil, 'null'.freeze => nil, ''.freeze => nil,
|
||||
'true'.freeze => true,
|
||||
'false'.freeze => false,
|
||||
'blank'.freeze => :blank?,
|
||||
'empty'.freeze => :empty?
|
||||
}
|
||||
|
||||
def squash_instance_assigns_with_environments
|
||||
@scopes.last.each_key do |k|
|
||||
@environments.each do |env|
|
||||
if env.has_key?(k)
|
||||
scopes.last[k] = lookup_and_evaluate(env, k)
|
||||
break
|
||||
# Look up variable, either resolve directly after considering the name. We can directly handle
|
||||
# Strings, digits, floats and booleans (true,false).
|
||||
# If no match is made we lookup the variable in the current scope and
|
||||
# later move up to the parent blocks to see if we can resolve the variable somewhere up the tree.
|
||||
# Some special keywords return symbols. Those symbols are to be called on the rhs object in expressions
|
||||
#
|
||||
# Example:
|
||||
# products == empty #=> products.empty?
|
||||
def resolve(key)
|
||||
if LITERALS.key?(key)
|
||||
LITERALS[key]
|
||||
else
|
||||
case key
|
||||
when /\A'(.*)'\z/m # Single quoted strings
|
||||
$1
|
||||
when /\A"(.*)"\z/m # Double quoted strings
|
||||
$1
|
||||
when /\A(-?\d+)\z/ # Integer and floats
|
||||
$1.to_i
|
||||
when /\A\((\S+)\.\.(\S+)\)\z/ # Ranges
|
||||
(resolve($1).to_i..resolve($2).to_i)
|
||||
when /\A(-?\d[\d\.]+)\z/ # Floats
|
||||
$1.to_f
|
||||
else
|
||||
variable(key)
|
||||
end
|
||||
end
|
||||
end
|
||||
end # squash_instance_assigns_with_environments
|
||||
|
||||
# Fetches an object starting at the local scope and then moving up the hierachy
|
||||
def find_variable(key)
|
||||
|
||||
# This was changed from find() to find_index() because this is a very hot
|
||||
# path and find_index() is optimized in MRI to reduce object allocation
|
||||
index = @scopes.find_index { |s| s.has_key?(key) }
|
||||
scope = @scopes[index] if index
|
||||
|
||||
variable = nil
|
||||
|
||||
if scope.nil?
|
||||
@environments.each do |e|
|
||||
variable = lookup_and_evaluate(e, key)
|
||||
unless variable.nil?
|
||||
scope = e
|
||||
break
|
||||
end
|
||||
end
|
||||
end
|
||||
|
||||
scope ||= @environments.last || @scopes.last
|
||||
variable ||= lookup_and_evaluate(scope, key)
|
||||
|
||||
variable = variable.to_liquid
|
||||
variable.context = self if variable.respond_to?(:context=)
|
||||
|
||||
return variable
|
||||
end
|
||||
|
||||
def variable_parse(markup)
|
||||
parts = markup.scan(VariableParser)
|
||||
needs_resolution = false
|
||||
if parts.first =~ SQUARE_BRACKETED
|
||||
needs_resolution = true
|
||||
parts[0] = $1
|
||||
end
|
||||
{:first => parts.shift, :needs_resolution => needs_resolution, :rest => parts}
|
||||
end
|
||||
|
||||
# Resolves namespaced queries gracefully.
|
||||
#
|
||||
# Example
|
||||
# @context['hash'] = {"name" => 'tobi'}
|
||||
# assert_equal 'tobi', @context['hash.name']
|
||||
# assert_equal 'tobi', @context['hash["name"]']
|
||||
def variable(markup)
|
||||
parts = @parsed_variables[markup]
|
||||
|
||||
first_part = parts[:first]
|
||||
if parts[:needs_resolution]
|
||||
first_part = resolve(parts[:first])
|
||||
end
|
||||
|
||||
if object = find_variable(first_part)
|
||||
|
||||
parts[:rest].each do |part|
|
||||
part = resolve($1) if part_resolved = (part =~ SQUARE_BRACKETED)
|
||||
|
||||
# If object is a hash- or array-like object we look for the
|
||||
# presence of the key and if its available we return it
|
||||
if object.respond_to?(:[]) and
|
||||
((object.respond_to?(:has_key?) and object.has_key?(part)) or
|
||||
(object.respond_to?(:fetch) and part.is_a?(Integer)))
|
||||
|
||||
# if its a proc we will replace the entry with the proc
|
||||
res = lookup_and_evaluate(object, part)
|
||||
object = res.to_liquid
|
||||
|
||||
# Some special cases. If the part wasn't in square brackets and
|
||||
# no key with the same name was found we interpret following calls
|
||||
# as commands and call them on the current object
|
||||
elsif !part_resolved and object.respond_to?(part) and ['size'.freeze, 'first'.freeze, 'last'.freeze].include?(part)
|
||||
|
||||
object = object.send(part.intern).to_liquid
|
||||
|
||||
# No key was present with the desired value and it wasn't one of the directly supported
|
||||
# keywords either. The only thing we got left is to return nil
|
||||
else
|
||||
return nil
|
||||
end
|
||||
|
||||
# If we are dealing with a drop here we have to
|
||||
object.context = self if object.respond_to?(:context=)
|
||||
end
|
||||
end
|
||||
|
||||
object
|
||||
end # variable
|
||||
|
||||
def lookup_and_evaluate(obj, key)
|
||||
if (value = obj[key]).is_a?(Proc) && obj.respond_to?(:[]=)
|
||||
obj[key] = (value.arity == 0) ? value.call : value.call(self)
|
||||
else
|
||||
value
|
||||
end
|
||||
end # lookup_and_evaluate
|
||||
|
||||
def squash_instance_assigns_with_environments
|
||||
@scopes.last.each_key do |k|
|
||||
@environments.each do |env|
|
||||
if env.has_key?(k)
|
||||
scopes.last[k] = lookup_and_evaluate(env, k)
|
||||
break
|
||||
end
|
||||
end
|
||||
end
|
||||
end # squash_instance_assigns_with_environments
|
||||
end # Context
|
||||
end # Liquid
|
||||
|
||||
@@ -1,24 +1,17 @@
|
||||
module Liquid
|
||||
class Document < BlockBody
|
||||
def self.parse(tokens, options)
|
||||
doc = new
|
||||
doc.parse(tokens, options)
|
||||
doc
|
||||
class Document < Block
|
||||
def self.parse(tokens, options={})
|
||||
# we don't need markup to open this block
|
||||
super(nil, nil, tokens, options)
|
||||
end
|
||||
|
||||
def parse(tokens, options)
|
||||
super do |end_tag_name, end_tag_params|
|
||||
unknown_tag(end_tag_name, options) if end_tag_name
|
||||
end
|
||||
# There isn't a real delimiter
|
||||
def block_delimiter
|
||||
[]
|
||||
end
|
||||
|
||||
def unknown_tag(tag, options)
|
||||
case tag
|
||||
when 'else'.freeze, 'end'.freeze
|
||||
raise SyntaxError.new(options[:locale].t("errors.syntax.unexpected_outer_tag".freeze, tag: tag))
|
||||
else
|
||||
raise SyntaxError.new(options[:locale].t("errors.syntax.unknown_tag".freeze, tag: tag))
|
||||
end
|
||||
# Document blocks don't need to be terminated since they are not actually opened
|
||||
def assert_missing_delimitation!
|
||||
end
|
||||
end
|
||||
end
|
||||
|
||||
@@ -1,6 +1,7 @@
|
||||
require 'set'
|
||||
|
||||
module Liquid
|
||||
|
||||
# A drop in liquid is a class which allows you to export DOM like things to liquid.
|
||||
# Methods of drops are callable.
|
||||
# The main use for liquid drops is to implement lazy loaded objects.
|
||||
@@ -26,7 +27,7 @@ module Liquid
|
||||
EMPTY_STRING = ''.freeze
|
||||
|
||||
# Catch all for the method
|
||||
def before_method(_method)
|
||||
def before_method(method)
|
||||
nil
|
||||
end
|
||||
|
||||
@@ -39,7 +40,7 @@ module Liquid
|
||||
end
|
||||
end
|
||||
|
||||
def has_key?(_name)
|
||||
def has_key?(name)
|
||||
true
|
||||
end
|
||||
|
||||
@@ -55,16 +56,12 @@ module Liquid
|
||||
self.class.name
|
||||
end
|
||||
|
||||
alias_method :[], :invoke_drop
|
||||
alias :[] :invoke_drop
|
||||
|
||||
private
|
||||
|
||||
# Check for method existence without invoking respond_to?, which creates symbols
|
||||
def self.invokable?(method_name)
|
||||
invokable_methods.include?(method_name.to_s)
|
||||
end
|
||||
|
||||
def self.invokable_methods
|
||||
unless @invokable_methods
|
||||
blacklist = Liquid::Drop.public_instance_methods + [:each]
|
||||
if include?(Enumerable)
|
||||
@@ -74,7 +71,7 @@ module Liquid
|
||||
whitelist = [:to_liquid] + (public_instance_methods - blacklist)
|
||||
@invokable_methods = Set.new(whitelist.map(&:to_s))
|
||||
end
|
||||
@invokable_methods
|
||||
@invokable_methods.include?(method_name.to_s)
|
||||
end
|
||||
end
|
||||
end
|
||||
|
||||
@@ -1,64 +1,12 @@
|
||||
module Liquid
|
||||
class Error < ::StandardError
|
||||
attr_accessor :line_number
|
||||
attr_accessor :markup_context
|
||||
class Error < ::StandardError; end
|
||||
|
||||
def to_s(with_prefix = true)
|
||||
str = ""
|
||||
str << message_prefix if with_prefix
|
||||
str << super()
|
||||
|
||||
if markup_context
|
||||
str << " "
|
||||
str << markup_context
|
||||
end
|
||||
|
||||
str
|
||||
end
|
||||
|
||||
def set_line_number_from_token(token)
|
||||
return unless token.respond_to?(:line_number)
|
||||
return if line_number
|
||||
self.line_number = token.line_number
|
||||
end
|
||||
|
||||
def self.render(e)
|
||||
if e.is_a?(Liquid::Error)
|
||||
e.to_s
|
||||
else
|
||||
"Liquid error: #{e}"
|
||||
end
|
||||
end
|
||||
|
||||
private
|
||||
|
||||
def message_prefix
|
||||
str = ""
|
||||
if is_a?(SyntaxError)
|
||||
str << "Liquid syntax error"
|
||||
else
|
||||
str << "Liquid error"
|
||||
end
|
||||
|
||||
if line_number
|
||||
str << " (line #{line_number})"
|
||||
end
|
||||
|
||||
str << ": "
|
||||
str
|
||||
end
|
||||
end
|
||||
|
||||
class FilterError < Error
|
||||
attr_accessor :original_exception
|
||||
end
|
||||
|
||||
ArgumentError = Class.new(Error)
|
||||
ContextError = Class.new(Error)
|
||||
FileSystemError = Class.new(Error)
|
||||
StandardError = Class.new(Error)
|
||||
SyntaxError = Class.new(Error)
|
||||
StackLevelError = Class.new(Error)
|
||||
TaintedError = Class.new(Error)
|
||||
MemoryError = Class.new(Error)
|
||||
class ArgumentError < Error; end
|
||||
class ContextError < Error; end
|
||||
class FilterNotFound < Error; end
|
||||
class FileSystemError < Error; end
|
||||
class StandardError < Error; end
|
||||
class SyntaxError < Error; end
|
||||
class StackLevelError < Error; end
|
||||
class MemoryError < Error; end
|
||||
end
|
||||
|
||||
@@ -1,32 +0,0 @@
|
||||
module Liquid
|
||||
class Expression
|
||||
LITERALS = {
|
||||
nil => nil, 'nil'.freeze => nil, 'null'.freeze => nil, ''.freeze => nil,
|
||||
'true'.freeze => true,
|
||||
'false'.freeze => false,
|
||||
'blank'.freeze => :blank?,
|
||||
'empty'.freeze => :empty?
|
||||
}
|
||||
|
||||
def self.parse(markup)
|
||||
if LITERALS.key?(markup)
|
||||
LITERALS[markup]
|
||||
else
|
||||
case markup
|
||||
when /\A'(.*)'\z/m # Single quoted strings
|
||||
$1
|
||||
when /\A"(.*)"\z/m # Double quoted strings
|
||||
$1
|
||||
when /\A(-?\d+)\z/ # Integer and floats
|
||||
$1.to_i
|
||||
when /\A\((\S+)\.\.(\S+)\)\z/ # Ranges
|
||||
RangeLookup.parse($1, $2)
|
||||
when /\A(-?\d[\d\.]+)\z/ # Floats
|
||||
$1.to_f
|
||||
else
|
||||
VariableLookup.parse(markup)
|
||||
end
|
||||
end
|
||||
end
|
||||
end
|
||||
end
|
||||
@@ -14,7 +14,7 @@ module Liquid
|
||||
# This will parse the template with a LocalFileSystem implementation rooted at 'template_path'.
|
||||
class BlankFileSystem
|
||||
# Called by Liquid to retrieve a template file
|
||||
def read_template_file(_template_path)
|
||||
def read_template_file(template_path, context)
|
||||
raise FileSystemError, "This liquid context does not allow includes."
|
||||
end
|
||||
end
|
||||
@@ -49,9 +49,9 @@ module Liquid
|
||||
@pattern = pattern
|
||||
end
|
||||
|
||||
def read_template_file(template_path)
|
||||
def read_template_file(template_path, context)
|
||||
full_path = full_path(template_path)
|
||||
raise FileSystemError, "No such template '#{template_path}'" unless File.exist?(full_path)
|
||||
raise FileSystemError, "No such template '#{template_path}'" unless File.exists?(full_path)
|
||||
|
||||
File.read(full_path)
|
||||
end
|
||||
|
||||
@@ -2,9 +2,10 @@ require 'yaml'
|
||||
|
||||
module Liquid
|
||||
class I18n
|
||||
DEFAULT_LOCALE = File.join(File.expand_path(__dir__), "locales", "en.yml")
|
||||
DEFAULT_LOCALE = File.join(File.expand_path(File.dirname(__FILE__)), "locales", "en.yml")
|
||||
|
||||
TranslationError = Class.new(StandardError)
|
||||
class TranslationError < StandardError
|
||||
end
|
||||
|
||||
attr_reader :path
|
||||
|
||||
@@ -22,7 +23,6 @@ module Liquid
|
||||
end
|
||||
|
||||
private
|
||||
|
||||
def interpolate(name, vars)
|
||||
name.gsub(/%\{(\w+)\}/) {
|
||||
# raise TranslationError, "Undefined key #{$1} for interpolation in translation #{name}" unless vars[$1.to_sym]
|
||||
|
||||
@@ -1,9 +1,10 @@
|
||||
module Liquid
|
||||
|
||||
# An interrupt is any command that breaks processing of a block (ex: a for loop).
|
||||
class Interrupt
|
||||
attr_reader :message
|
||||
|
||||
def initialize(message = nil)
|
||||
def initialize(message=nil)
|
||||
@message = message || "interrupt".freeze
|
||||
end
|
||||
end
|
||||
|
||||
@@ -9,11 +9,9 @@ module Liquid
|
||||
'['.freeze => :open_square,
|
||||
']'.freeze => :close_square,
|
||||
'('.freeze => :open_round,
|
||||
')'.freeze => :close_round,
|
||||
'?'.freeze => :question,
|
||||
'-'.freeze => :dash
|
||||
')'.freeze => :close_round
|
||||
}
|
||||
IDENTIFIER = /[a-zA-Z_][\w-]*\??/
|
||||
IDENTIFIER = /[\w\-?!]+/
|
||||
SINGLE_STRING_LITERAL = /'[^\']*'/
|
||||
DOUBLE_STRING_LITERAL = /"[^\"]*"/
|
||||
NUMBER_LITERAL = /-?\d+(\.\d+)?/
|
||||
@@ -27,7 +25,7 @@ module Liquid
|
||||
def tokenize
|
||||
@output = []
|
||||
|
||||
until @ss.eos?
|
||||
while !@ss.eos?
|
||||
@ss.skip(/\s*/)
|
||||
tok = case
|
||||
when t = @ss.scan(COMPARISON_OPERATOR) then [:comparison, t]
|
||||
@@ -39,7 +37,7 @@ module Liquid
|
||||
else
|
||||
c = @ss.getch
|
||||
if s = SPECIALS[c]
|
||||
[s, c]
|
||||
[s,c]
|
||||
else
|
||||
raise SyntaxError, "Unexpected character #{c}"
|
||||
end
|
||||
|
||||
@@ -14,8 +14,7 @@
|
||||
include: "Error in tag 'include' - Valid syntax: include '[template]' (with|for) [object|collection]"
|
||||
unknown_tag: "Unknown tag '%{tag}'"
|
||||
invalid_delimiter: "'end' is not a valid delimiter for %{block_name} tags. use %{block_delimiter}"
|
||||
unexpected_else: "%{block_name} tag does not expect 'else' tag"
|
||||
unexpected_outer_tag: "Unexpected outer '%{tag}' tag"
|
||||
unexpected_else: "%{block_name} tag does not expect else tag"
|
||||
tag_termination: "Tag '%{token}' was not properly terminated with regexp: %{tag_end}"
|
||||
variable_termination: "Variable '%{token}' was not properly terminated with regexp: %{tag_end}"
|
||||
tag_never_closed: "'%{block_name}' tag was never closed"
|
||||
|
||||
62
lib/liquid/module_ex.rb
Normal file
62
lib/liquid/module_ex.rb
Normal file
@@ -0,0 +1,62 @@
|
||||
# Copyright 2007 by Domizio Demichelis
|
||||
# This library is free software. It may be used, redistributed and/or modified
|
||||
# under the same terms as Ruby itself
|
||||
#
|
||||
# This extension is used in order to expose the object of the implementing class
|
||||
# to liquid as it were a Drop. It also limits the liquid-callable methods of the instance
|
||||
# to the allowed method passed with the liquid_methods call
|
||||
# Example:
|
||||
#
|
||||
# class SomeClass
|
||||
# liquid_methods :an_allowed_method
|
||||
#
|
||||
# def an_allowed_method
|
||||
# 'this comes from an allowed method'
|
||||
# end
|
||||
# def unallowed_method
|
||||
# 'this will never be an output'
|
||||
# end
|
||||
# end
|
||||
#
|
||||
# if you want to extend the drop to other methods you can defines more methods
|
||||
# in the class <YourClass>::LiquidDropClass
|
||||
#
|
||||
# class SomeClass::LiquidDropClass
|
||||
# def another_allowed_method
|
||||
# 'and this from another allowed method'
|
||||
# end
|
||||
# end
|
||||
# end
|
||||
#
|
||||
# usage:
|
||||
# @something = SomeClass.new
|
||||
#
|
||||
# template:
|
||||
# {{something.an_allowed_method}}{{something.unallowed_method}} {{something.another_allowed_method}}
|
||||
#
|
||||
# output:
|
||||
# 'this comes from an allowed method and this from another allowed method'
|
||||
#
|
||||
# You can also chain associations, by adding the liquid_method call in the
|
||||
# association models.
|
||||
#
|
||||
class Module
|
||||
|
||||
def liquid_methods(*allowed_methods)
|
||||
drop_class = eval "class #{self.to_s}::LiquidDropClass < Liquid::Drop; self; end"
|
||||
define_method :to_liquid do
|
||||
drop_class.new(self)
|
||||
end
|
||||
drop_class.class_eval do
|
||||
def initialize(object)
|
||||
@object = object
|
||||
end
|
||||
allowed_methods.each do |sym|
|
||||
define_method sym do
|
||||
@object.send sym
|
||||
end
|
||||
end
|
||||
end
|
||||
end
|
||||
|
||||
end
|
||||
@@ -1,32 +0,0 @@
|
||||
module Liquid
|
||||
module ParserSwitching
|
||||
def parse_with_selected_parser(markup)
|
||||
case @options[:error_mode] || Template.error_mode
|
||||
when :strict then strict_parse_with_error_context(markup)
|
||||
when :lax then lax_parse(markup)
|
||||
when :warn
|
||||
begin
|
||||
return strict_parse_with_error_context(markup)
|
||||
rescue SyntaxError => e
|
||||
e.set_line_number_from_token(markup)
|
||||
@warnings ||= []
|
||||
@warnings << e
|
||||
return lax_parse(markup)
|
||||
end
|
||||
end
|
||||
end
|
||||
|
||||
private
|
||||
|
||||
def strict_parse_with_error_context(markup)
|
||||
strict_parse(markup)
|
||||
rescue SyntaxError => e
|
||||
e.markup_context = markup_context(markup)
|
||||
raise e
|
||||
end
|
||||
|
||||
def markup_context(markup)
|
||||
"in \"#{markup.strip}\""
|
||||
end
|
||||
end
|
||||
end
|
||||
@@ -1,158 +0,0 @@
|
||||
require 'liquid/profiler/hooks'
|
||||
|
||||
module Liquid
|
||||
# Profiler enables support for profiling template rendering to help track down performance issues.
|
||||
#
|
||||
# To enable profiling, first require 'liquid/profiler'.
|
||||
# Then, to profile a parse/render cycle, pass the <tt>profile: true</tt> option to <tt>Liquid::Template.parse</tt>.
|
||||
# After <tt>Liquid::Template#render</tt> is called, the template object makes available an instance of this
|
||||
# class via the <tt>Liquid::Template#profiler</tt> method.
|
||||
#
|
||||
# template = Liquid::Template.parse(template_content, profile: true)
|
||||
# output = template.render
|
||||
# profile = template.profiler
|
||||
#
|
||||
# This object contains all profiling information, containing information on what tags were rendered,
|
||||
# where in the templates these tags live, and how long each tag took to render.
|
||||
#
|
||||
# This is a tree structure that is Enumerable all the way down, and keeps track of tags and rendering times
|
||||
# inside of <tt>{% include %}</tt> tags.
|
||||
#
|
||||
# profile.each do |node|
|
||||
# # Access to the token itself
|
||||
# node.code
|
||||
#
|
||||
# # Which template and line number of this node.
|
||||
# # If top level, this will be "<root>".
|
||||
# node.partial
|
||||
# node.line_number
|
||||
#
|
||||
# # Render time in seconds of this node
|
||||
# node.render_time
|
||||
#
|
||||
# # If the template used {% include %}, this node will also have children.
|
||||
# node.children.each do |child2|
|
||||
# # ...
|
||||
# end
|
||||
# end
|
||||
#
|
||||
# Profiler also exposes the total time of the template's render in <tt>Liquid::Profiler#total_render_time</tt>.
|
||||
#
|
||||
# All render times are in seconds. There is a small performance hit when profiling is enabled.
|
||||
#
|
||||
class Profiler
|
||||
include Enumerable
|
||||
|
||||
class Timing
|
||||
attr_reader :code, :partial, :line_number, :children
|
||||
|
||||
def initialize(token, partial)
|
||||
@code = token.respond_to?(:raw) ? token.raw : token
|
||||
@partial = partial
|
||||
@line_number = token.respond_to?(:line_number) ? token.line_number : nil
|
||||
@children = []
|
||||
end
|
||||
|
||||
def self.start(token, partial)
|
||||
new(token, partial).tap(&:start)
|
||||
end
|
||||
|
||||
def start
|
||||
@start_time = Time.now
|
||||
end
|
||||
|
||||
def finish
|
||||
@end_time = Time.now
|
||||
end
|
||||
|
||||
def render_time
|
||||
@end_time - @start_time
|
||||
end
|
||||
end
|
||||
|
||||
def self.profile_token_render(token)
|
||||
if Profiler.current_profile && token.respond_to?(:render)
|
||||
Profiler.current_profile.start_token(token)
|
||||
output = yield
|
||||
Profiler.current_profile.end_token(token)
|
||||
output
|
||||
else
|
||||
yield
|
||||
end
|
||||
end
|
||||
|
||||
def self.profile_children(template_name)
|
||||
if Profiler.current_profile
|
||||
Profiler.current_profile.push_partial(template_name)
|
||||
output = yield
|
||||
Profiler.current_profile.pop_partial
|
||||
output
|
||||
else
|
||||
yield
|
||||
end
|
||||
end
|
||||
|
||||
def self.current_profile
|
||||
Thread.current[:liquid_profiler]
|
||||
end
|
||||
|
||||
def initialize
|
||||
@partial_stack = ["<root>"]
|
||||
|
||||
@root_timing = Timing.new("", current_partial)
|
||||
@timing_stack = [@root_timing]
|
||||
|
||||
@render_start_at = Time.now
|
||||
@render_end_at = @render_start_at
|
||||
end
|
||||
|
||||
def start
|
||||
Thread.current[:liquid_profiler] = self
|
||||
@render_start_at = Time.now
|
||||
end
|
||||
|
||||
def stop
|
||||
Thread.current[:liquid_profiler] = nil
|
||||
@render_end_at = Time.now
|
||||
end
|
||||
|
||||
def total_render_time
|
||||
@render_end_at - @render_start_at
|
||||
end
|
||||
|
||||
def each(&block)
|
||||
@root_timing.children.each(&block)
|
||||
end
|
||||
|
||||
def [](idx)
|
||||
@root_timing.children[idx]
|
||||
end
|
||||
|
||||
def length
|
||||
@root_timing.children.length
|
||||
end
|
||||
|
||||
def start_token(token)
|
||||
@timing_stack.push(Timing.start(token, current_partial))
|
||||
end
|
||||
|
||||
def end_token(_token)
|
||||
timing = @timing_stack.pop
|
||||
timing.finish
|
||||
|
||||
@timing_stack.last.children << timing
|
||||
end
|
||||
|
||||
def current_partial
|
||||
@partial_stack.last
|
||||
end
|
||||
|
||||
def push_partial(partial_name)
|
||||
@partial_stack.push(partial_name)
|
||||
end
|
||||
|
||||
def pop_partial
|
||||
@partial_stack.pop
|
||||
end
|
||||
end
|
||||
end
|
||||
@@ -1,23 +0,0 @@
|
||||
module Liquid
|
||||
class BlockBody
|
||||
def render_token_with_profiling(token, context)
|
||||
Profiler.profile_token_render(token) do
|
||||
render_token_without_profiling(token, context)
|
||||
end
|
||||
end
|
||||
|
||||
alias_method :render_token_without_profiling, :render_token
|
||||
alias_method :render_token, :render_token_with_profiling
|
||||
end
|
||||
|
||||
class Include < Tag
|
||||
def render_with_profiling(context)
|
||||
Profiler.profile_children(context.evaluate(@template_name_expr).to_s) do
|
||||
render_without_profiling(context)
|
||||
end
|
||||
end
|
||||
|
||||
alias_method :render_without_profiling, :render
|
||||
alias_method :render, :render_with_profiling
|
||||
end
|
||||
end
|
||||
@@ -1,22 +0,0 @@
|
||||
module Liquid
|
||||
class RangeLookup
|
||||
def self.parse(start_markup, end_markup)
|
||||
start_obj = Expression.parse(start_markup)
|
||||
end_obj = Expression.parse(end_markup)
|
||||
if start_obj.respond_to?(:evaluate) || end_obj.respond_to?(:evaluate)
|
||||
new(start_obj, end_obj)
|
||||
else
|
||||
start_obj.to_i..end_obj.to_i
|
||||
end
|
||||
end
|
||||
|
||||
def initialize(start_obj, end_obj)
|
||||
@start_obj = start_obj
|
||||
@end_obj = end_obj
|
||||
end
|
||||
|
||||
def evaluate(context)
|
||||
context.evaluate(@start_obj).to_i..context.evaluate(@end_obj).to_i
|
||||
end
|
||||
end
|
||||
end
|
||||
@@ -1,23 +0,0 @@
|
||||
module Liquid
|
||||
class ResourceLimits
|
||||
attr_accessor :render_length, :render_score, :assign_score,
|
||||
:render_length_limit, :render_score_limit, :assign_score_limit
|
||||
|
||||
def initialize(limits)
|
||||
@render_length_limit = limits[:render_length_limit]
|
||||
@render_score_limit = limits[:render_score_limit]
|
||||
@assign_score_limit = limits[:assign_score_limit]
|
||||
reset
|
||||
end
|
||||
|
||||
def reached?
|
||||
(@render_length_limit && @render_length > @render_length_limit) ||
|
||||
(@render_score_limit && @render_score > @render_score_limit) ||
|
||||
(@assign_score_limit && @assign_score > @assign_score_limit)
|
||||
end
|
||||
|
||||
def reset
|
||||
@render_length = @render_score = @assign_score = 0
|
||||
end
|
||||
end
|
||||
end
|
||||
@@ -2,6 +2,7 @@ require 'cgi'
|
||||
require 'bigdecimal'
|
||||
|
||||
module Liquid
|
||||
|
||||
module StandardFilters
|
||||
HTML_ESCAPE = {
|
||||
'&'.freeze => '&'.freeze,
|
||||
@@ -33,39 +34,25 @@ module Liquid
|
||||
end
|
||||
|
||||
def escape(input)
|
||||
CGI.escapeHTML(input).untaint rescue input
|
||||
CGI.escapeHTML(input) rescue input
|
||||
end
|
||||
alias_method :h, :escape
|
||||
|
||||
def escape_once(input)
|
||||
input.to_s.gsub(HTML_ESCAPE_ONCE_REGEXP, HTML_ESCAPE)
|
||||
end
|
||||
|
||||
def url_encode(input)
|
||||
CGI.escape(input) rescue input
|
||||
end
|
||||
|
||||
def slice(input, offset, length = nil)
|
||||
offset = Integer(offset)
|
||||
length = length ? Integer(length) : 1
|
||||
|
||||
if input.is_a?(Array)
|
||||
input.slice(offset, length) || []
|
||||
else
|
||||
input.to_s.slice(offset, length) || ''
|
||||
end
|
||||
end
|
||||
alias_method :h, :escape
|
||||
|
||||
# Truncate a string down to x characters
|
||||
def truncate(input, length = 50, truncate_string = "...".freeze)
|
||||
return if input.nil?
|
||||
if input.nil? then return end
|
||||
l = length.to_i - truncate_string.length
|
||||
l = 0 if l < 0
|
||||
input.length > length.to_i ? input[0...l] + truncate_string : input
|
||||
end
|
||||
|
||||
def truncatewords(input, words = 15, truncate_string = "...".freeze)
|
||||
return if input.nil?
|
||||
if input.nil? then return end
|
||||
wordlist = input.to_s.split
|
||||
l = words.to_i - 1
|
||||
l = 0 if l < 0
|
||||
@@ -78,7 +65,7 @@ module Liquid
|
||||
# <div class="summary">{{ post | split '//' | first }}</div>
|
||||
#
|
||||
def split(input, pattern)
|
||||
input.to_s.split(pattern)
|
||||
input.split(pattern)
|
||||
end
|
||||
|
||||
def strip(input)
|
||||
@@ -114,35 +101,10 @@ module Liquid
|
||||
ary = InputIterator.new(input)
|
||||
if property.nil?
|
||||
ary.sort
|
||||
elsif ary.first.respond_to?(:[]) && !ary.first[property].nil?
|
||||
ary.sort { |a, b| a[property] <=> b[property] }
|
||||
elsif ary.first.respond_to?('[]'.freeze) && !ary.first[property].nil?
|
||||
ary.sort {|a,b| a[property] <=> b[property] }
|
||||
elsif ary.first.respond_to?(property)
|
||||
ary.sort { |a, b| a.send(property) <=> b.send(property) }
|
||||
end
|
||||
end
|
||||
|
||||
# Sort elements of an array ignoring case if strings
|
||||
# provide optional property with which to sort an array of hashes or drops
|
||||
def sort_natural(input, property = nil)
|
||||
ary = InputIterator.new(input)
|
||||
|
||||
if property.nil?
|
||||
ary.sort { |a, b| a.casecmp(b) }
|
||||
elsif ary.first.respond_to?(:[]) && !ary.first[property].nil?
|
||||
ary.sort { |a, b| a[property].casecmp(b[property]) }
|
||||
elsif ary.first.respond_to?(property)
|
||||
ary.sort { |a, b| a.send(property).casecmp(b.send(property)) }
|
||||
end
|
||||
end
|
||||
|
||||
# Remove duplicate elements from an array
|
||||
# provide optional property with which to determine uniqueness
|
||||
def uniq(input, property = nil)
|
||||
ary = InputIterator.new(input)
|
||||
if property.nil?
|
||||
input.uniq
|
||||
elsif input.first.respond_to?(:[])
|
||||
input.uniq{ |a| a[property] }
|
||||
ary.sort {|a,b| a.send(property) <=> b.send(property) }
|
||||
end
|
||||
end
|
||||
|
||||
@@ -190,10 +152,6 @@ module Liquid
|
||||
input.to_s + string.to_s
|
||||
end
|
||||
|
||||
def concat(input, array)
|
||||
InputIterator.new(input).concat(array)
|
||||
end
|
||||
|
||||
# prepend a string to another
|
||||
def prepend(input, string)
|
||||
string.to_s + input.to_s
|
||||
@@ -323,11 +281,6 @@ module Liquid
|
||||
def to_date(obj)
|
||||
return obj if obj.respond_to?(:strftime)
|
||||
|
||||
if obj.is_a?(String)
|
||||
return nil if obj.empty?
|
||||
obj = obj.downcase
|
||||
end
|
||||
|
||||
case obj
|
||||
when 'now'.freeze, 'today'.freeze
|
||||
Time.now
|
||||
@@ -335,6 +288,8 @@ module Liquid
|
||||
Time.at(obj.to_i)
|
||||
when String
|
||||
Time.parse(obj)
|
||||
else
|
||||
nil
|
||||
end
|
||||
rescue ArgumentError
|
||||
nil
|
||||
@@ -364,10 +319,6 @@ module Liquid
|
||||
to_a.join(glue)
|
||||
end
|
||||
|
||||
def concat(args)
|
||||
to_a.concat args
|
||||
end
|
||||
|
||||
def reverse
|
||||
reverse_each.to_a
|
||||
end
|
||||
|
||||
@@ -1,19 +1,19 @@
|
||||
require 'set'
|
||||
|
||||
module Liquid
|
||||
|
||||
# Strainer is the parent class for the filters system.
|
||||
# New filters are mixed into the strainer class which is then instantiated for each liquid template render run.
|
||||
#
|
||||
# The Strainer only allows method calls defined in filters given to it via Strainer.global_filter,
|
||||
# Context#add_filters or Template.register_filter
|
||||
class Strainer #:nodoc:
|
||||
@@global_strainer = Class.new(Strainer) do
|
||||
@filter_methods = Set.new
|
||||
end
|
||||
@@filters = []
|
||||
@@known_filters = Set.new
|
||||
@@known_methods = Set.new
|
||||
@@strainer_class_cache = Hash.new do |hash, filters|
|
||||
hash[filters] = Class.new(@@global_strainer) do
|
||||
@filter_methods = @@global_strainer.filter_methods.dup
|
||||
filters.each { |f| add_filter(f) }
|
||||
hash[filters] = Class.new(Strainer) do
|
||||
filters.each { |f| include f }
|
||||
end
|
||||
end
|
||||
|
||||
@@ -21,46 +21,43 @@ module Liquid
|
||||
@context = context
|
||||
end
|
||||
|
||||
class << self
|
||||
attr_reader :filter_methods
|
||||
def self.global_filter(filter)
|
||||
raise ArgumentError, "Passed filter is not a module" unless filter.is_a?(Module)
|
||||
add_known_filter(filter)
|
||||
@@filters << filter unless @@filters.include?(filter)
|
||||
end
|
||||
|
||||
def self.add_filter(filter)
|
||||
raise ArgumentError, "Expected module but got: #{f.class}" unless filter.is_a?(Module)
|
||||
unless self.class.include?(filter)
|
||||
send(:include, filter)
|
||||
@filter_methods.merge(filter.public_instance_methods.map(&:to_s))
|
||||
def self.add_known_filter(filter)
|
||||
unless @@known_filters.include?(filter)
|
||||
@@method_blacklist ||= Set.new(Strainer.instance_methods.map(&:to_s))
|
||||
new_methods = filter.instance_methods.map(&:to_s)
|
||||
new_methods.reject!{ |m| @@method_blacklist.include?(m) }
|
||||
@@known_methods.merge(new_methods)
|
||||
@@known_filters.add(filter)
|
||||
end
|
||||
end
|
||||
|
||||
def self.global_filter(filter)
|
||||
@@global_strainer.add_filter(filter)
|
||||
end
|
||||
|
||||
def self.invokable?(method)
|
||||
@filter_methods.include?(method.to_s)
|
||||
def self.strainer_class_cache
|
||||
@@strainer_class_cache
|
||||
end
|
||||
|
||||
def self.create(context, filters = [])
|
||||
@@strainer_class_cache[filters].new(context)
|
||||
filters = @@filters + filters
|
||||
strainer_class_cache[filters].new(context)
|
||||
end
|
||||
|
||||
def invoke(method, *args)
|
||||
if self.class.invokable?(method)
|
||||
begin
|
||||
send(method, *args)
|
||||
rescue ::ArgumentError => e
|
||||
raise Liquid::ArgumentError.new(e.message)
|
||||
rescue Liquid::Error
|
||||
raise
|
||||
rescue ::StandardError => exception
|
||||
error = Liquid::FilterError.new(exception.message)
|
||||
error.original_exception = exception
|
||||
raise error
|
||||
end
|
||||
if invokable?(method)
|
||||
send(method, *args)
|
||||
else
|
||||
args.first
|
||||
end
|
||||
rescue ::ArgumentError => e
|
||||
raise Liquid::ArgumentError.new(e.message)
|
||||
end
|
||||
|
||||
def invokable?(method)
|
||||
@@known_methods.include?(method.to_s) && respond_to?(method)
|
||||
end
|
||||
end
|
||||
end
|
||||
|
||||
@@ -1,8 +1,7 @@
|
||||
module Liquid
|
||||
class Tag
|
||||
attr_accessor :options, :line_number
|
||||
attr_accessor :options
|
||||
attr_reader :nodelist, :warnings
|
||||
include ParserSwitching
|
||||
|
||||
class << self
|
||||
def parse(tag_name, markup, tokens, options)
|
||||
@@ -20,23 +19,43 @@ module Liquid
|
||||
@options = options
|
||||
end
|
||||
|
||||
def parse(_tokens)
|
||||
end
|
||||
|
||||
def raw
|
||||
"#{@tag_name} #{@markup}"
|
||||
def parse(tokens)
|
||||
end
|
||||
|
||||
def name
|
||||
self.class.name.downcase
|
||||
end
|
||||
|
||||
def render(_context)
|
||||
def render(context)
|
||||
''.freeze
|
||||
end
|
||||
|
||||
def blank?
|
||||
false
|
||||
end
|
||||
|
||||
def parse_with_selected_parser(markup)
|
||||
case @options[:error_mode] || Template.error_mode
|
||||
when :strict then strict_parse_with_error_context(markup)
|
||||
when :lax then lax_parse(markup)
|
||||
when :warn
|
||||
begin
|
||||
return strict_parse_with_error_context(markup)
|
||||
rescue SyntaxError => e
|
||||
@warnings ||= []
|
||||
@warnings << e
|
||||
return lax_parse(markup)
|
||||
end
|
||||
end
|
||||
end
|
||||
|
||||
private
|
||||
|
||||
def strict_parse_with_error_context(markup)
|
||||
strict_parse(markup)
|
||||
rescue SyntaxError => e
|
||||
e.message << " in \"#{markup.strip}\""
|
||||
raise e
|
||||
end
|
||||
end
|
||||
end
|
||||
|
||||
@@ -1,4 +1,5 @@
|
||||
module Liquid
|
||||
|
||||
# Assign sets a variable in your template.
|
||||
#
|
||||
# {% assign foo = 'monkey' %}
|
||||
@@ -14,8 +15,7 @@ module Liquid
|
||||
super
|
||||
if markup =~ Syntax
|
||||
@to = $1
|
||||
@from = Variable.new($2, options)
|
||||
@from.line_number = line_number
|
||||
@from = Variable.new($2)
|
||||
else
|
||||
raise SyntaxError.new options[:locale].t("errors.syntax.assign".freeze)
|
||||
end
|
||||
@@ -24,10 +24,7 @@ module Liquid
|
||||
def render(context)
|
||||
val = @from.render(context)
|
||||
context.scopes.last[@to] = val
|
||||
|
||||
inc = val.instance_of?(String) || val.instance_of?(Array) || val.instance_of?(Hash) ? val.length : 1
|
||||
context.resource_limits.assign_score += inc
|
||||
|
||||
context.increment_used_resources(:assign_score_current, val)
|
||||
''.freeze
|
||||
end
|
||||
|
||||
|
||||
@@ -1,4 +1,5 @@
|
||||
module Liquid
|
||||
|
||||
# Break tag to be used to break out of a for loop.
|
||||
#
|
||||
# == Basic Usage:
|
||||
@@ -9,9 +10,11 @@ module Liquid
|
||||
# {% endfor %}
|
||||
#
|
||||
class Break < Tag
|
||||
|
||||
def interrupt
|
||||
BreakInterrupt.new
|
||||
end
|
||||
|
||||
end
|
||||
|
||||
Template.register_tag('break'.freeze, Break)
|
||||
|
||||
@@ -11,7 +11,7 @@ module Liquid
|
||||
# in a sidebar or footer.
|
||||
#
|
||||
class Capture < Block
|
||||
Syntax = /(#{VariableSignature}+)/o
|
||||
Syntax = /(\w+)/
|
||||
|
||||
def initialize(tag_name, markup, options)
|
||||
super
|
||||
@@ -25,7 +25,7 @@ module Liquid
|
||||
def render(context)
|
||||
output = super
|
||||
context.scopes.last[@to] = output
|
||||
context.resource_limits.assign_score += output.length
|
||||
context.increment_used_resources(:assign_score_current, output)
|
||||
''.freeze
|
||||
end
|
||||
|
||||
|
||||
@@ -8,24 +8,18 @@ module Liquid
|
||||
@blocks = []
|
||||
|
||||
if markup =~ Syntax
|
||||
@left = Expression.parse($1)
|
||||
@left = $1
|
||||
else
|
||||
raise SyntaxError.new(options[:locale].t("errors.syntax.case".freeze))
|
||||
end
|
||||
end
|
||||
|
||||
def parse(tokens)
|
||||
body = BlockBody.new
|
||||
while more = parse_body(body, tokens)
|
||||
body = @blocks.last.attachment
|
||||
end
|
||||
end
|
||||
|
||||
def nodelist
|
||||
@blocks.map(&:attachment)
|
||||
@blocks.map(&:attachment).flatten
|
||||
end
|
||||
|
||||
def unknown_tag(tag, markup, tokens)
|
||||
@nodelist = []
|
||||
case tag
|
||||
when 'when'.freeze
|
||||
record_when_condition(markup)
|
||||
@@ -43,10 +37,10 @@ module Liquid
|
||||
output = ''
|
||||
@blocks.each do |block|
|
||||
if block.else?
|
||||
return block.attachment.render(context) if execute_else_block
|
||||
return render_all(block.attachment, context) if execute_else_block
|
||||
elsif block.evaluate(context)
|
||||
execute_else_block = false
|
||||
output << block.attachment.render(context)
|
||||
output << render_all(block.attachment, context)
|
||||
end
|
||||
end
|
||||
output
|
||||
@@ -56,28 +50,27 @@ module Liquid
|
||||
private
|
||||
|
||||
def record_when_condition(markup)
|
||||
body = BlockBody.new
|
||||
|
||||
while markup
|
||||
unless markup =~ WhenSyntax
|
||||
# Create a new nodelist and assign it to the new block
|
||||
if not markup =~ WhenSyntax
|
||||
raise SyntaxError.new(options[:locale].t("errors.syntax.case_invalid_when".freeze))
|
||||
end
|
||||
|
||||
markup = $2
|
||||
|
||||
block = Condition.new(@left, '=='.freeze, Expression.parse($1))
|
||||
block.attach(body)
|
||||
@blocks << block
|
||||
block = Condition.new(@left, '=='.freeze, $1)
|
||||
block.attach(@nodelist)
|
||||
@blocks.push(block)
|
||||
end
|
||||
end
|
||||
|
||||
def record_else_condition(markup)
|
||||
unless markup.strip.empty?
|
||||
if not markup.strip.empty?
|
||||
raise SyntaxError.new(options[:locale].t("errors.syntax.case_invalid_else".freeze))
|
||||
end
|
||||
|
||||
block = ElseCondition.new
|
||||
block.attach(BlockBody.new)
|
||||
block.attach(@nodelist)
|
||||
@blocks << block
|
||||
end
|
||||
end
|
||||
|
||||
@@ -1,10 +1,10 @@
|
||||
module Liquid
|
||||
class Comment < Block
|
||||
def render(_context)
|
||||
def render(context)
|
||||
''.freeze
|
||||
end
|
||||
|
||||
def unknown_tag(_tag, _markup, _tokens)
|
||||
def unknown_tag(tag, markup, tokens)
|
||||
end
|
||||
|
||||
def blank?
|
||||
|
||||
@@ -20,10 +20,10 @@ module Liquid
|
||||
case markup
|
||||
when NamedSyntax
|
||||
@variables = variables_from_string($2)
|
||||
@name = Expression.parse($1)
|
||||
@name = $1
|
||||
when SimpleSyntax
|
||||
@variables = variables_from_string(markup)
|
||||
@name = @variables.to_s
|
||||
@name = "'#{@variables.to_s}'"
|
||||
else
|
||||
raise SyntaxError.new(options[:locale].t("errors.syntax.cycle".freeze))
|
||||
end
|
||||
@@ -33,9 +33,9 @@ module Liquid
|
||||
context.registers[:cycle] ||= Hash.new(0)
|
||||
|
||||
context.stack do
|
||||
key = context.evaluate(@name)
|
||||
key = context[@name]
|
||||
iteration = context.registers[:cycle][key]
|
||||
result = context.evaluate(@variables[iteration])
|
||||
result = context[@variables[iteration]]
|
||||
iteration += 1
|
||||
iteration = 0 if iteration >= @variables.size
|
||||
context.registers[:cycle][key] = iteration
|
||||
@@ -48,7 +48,7 @@ module Liquid
|
||||
def variables_from_string(markup)
|
||||
markup.split(',').collect do |var|
|
||||
var =~ /\s*(#{QuotedFragment})\s*/o
|
||||
$1 ? Expression.parse($1) : nil
|
||||
$1 ? $1 : nil
|
||||
end.compact
|
||||
end
|
||||
end
|
||||
|
||||
@@ -1,4 +1,5 @@
|
||||
module Liquid
|
||||
|
||||
# decrement is used in a place where one needs to insert a counter
|
||||
# into a template, and needs the counter to survive across
|
||||
# multiple instantiations of the template.
|
||||
@@ -25,10 +26,12 @@ module Liquid
|
||||
|
||||
def render(context)
|
||||
value = context.environments.first[@variable] ||= 0
|
||||
value -= 1
|
||||
value = value - 1
|
||||
context.environments.first[@variable] = value
|
||||
value.to_s
|
||||
end
|
||||
|
||||
private
|
||||
end
|
||||
|
||||
Template.register_tag('decrement'.freeze, Decrement)
|
||||
|
||||
@@ -1,4 +1,5 @@
|
||||
module Liquid
|
||||
|
||||
# "For" iterates over an array or collection.
|
||||
# Several useful variables are available to you within the loop.
|
||||
#
|
||||
@@ -41,7 +42,6 @@ module Liquid
|
||||
# where 0 is the last item.
|
||||
# forloop.first:: Returns true if the item is the first item.
|
||||
# forloop.last:: Returns true if the item is the last item.
|
||||
# forloop.parentloop:: Provides access to the parent loop, if present.
|
||||
#
|
||||
class For < Block
|
||||
Syntax = /\A(#{VariableSegment}+)\s+in\s+(#{QuotedFragment}+)\s*(reversed)?/o
|
||||
@@ -49,43 +49,38 @@ module Liquid
|
||||
def initialize(tag_name, markup, options)
|
||||
super
|
||||
parse_with_selected_parser(markup)
|
||||
@for_block = BlockBody.new
|
||||
end
|
||||
|
||||
def parse(tokens)
|
||||
return unless parse_body(@for_block, tokens)
|
||||
parse_body(@else_block, tokens)
|
||||
@nodelist = @for_block = []
|
||||
end
|
||||
|
||||
def nodelist
|
||||
@else_block ? [@for_block, @else_block] : [@for_block]
|
||||
if @else_block
|
||||
@for_block + @else_block
|
||||
else
|
||||
@for_block
|
||||
end
|
||||
end
|
||||
|
||||
def unknown_tag(tag, markup, tokens)
|
||||
return super unless tag == 'else'.freeze
|
||||
@else_block = BlockBody.new
|
||||
@nodelist = @else_block = []
|
||||
end
|
||||
|
||||
def render(context)
|
||||
for_offsets = context.registers[:for] ||= Hash.new(0)
|
||||
for_stack = context.registers[:for_stack] ||= []
|
||||
context.registers[:for] ||= Hash.new(0)
|
||||
|
||||
parent_loop = for_stack.last
|
||||
for_stack.push(nil)
|
||||
|
||||
collection = context.evaluate(@collection_name)
|
||||
collection = context[@collection_name]
|
||||
collection = collection.to_a if collection.is_a?(Range)
|
||||
|
||||
# Maintains Ruby 1.8.7 String#each behaviour on 1.9
|
||||
return render_else(context) unless iterable?(collection)
|
||||
|
||||
from = if @from == :continue
|
||||
for_offsets[@name].to_i
|
||||
from = if @attributes['offset'.freeze] == 'continue'.freeze
|
||||
context.registers[:for][@name].to_i
|
||||
else
|
||||
context.evaluate(@from).to_i
|
||||
context[@attributes['offset'.freeze]].to_i
|
||||
end
|
||||
|
||||
limit = context.evaluate(@limit)
|
||||
limit = context[@attributes['limit'.freeze]]
|
||||
to = limit ? limit.to_i + from : nil
|
||||
|
||||
segment = Utils.slice_collection(collection, from, to)
|
||||
@@ -99,27 +94,23 @@ module Liquid
|
||||
length = segment.length
|
||||
|
||||
# Store our progress through the collection for the continue flag
|
||||
for_offsets[@name] = from + segment.length
|
||||
context.registers[:for][@name] = from + segment.length
|
||||
|
||||
context.stack do
|
||||
segment.each_with_index do |item, index|
|
||||
context[@variable_name] = item
|
||||
loop_vars = {
|
||||
'name'.freeze => @name,
|
||||
'length'.freeze => length,
|
||||
'index'.freeze => index + 1,
|
||||
'index0'.freeze => index,
|
||||
'rindex'.freeze => length - index,
|
||||
'rindex0'.freeze => length - index - 1,
|
||||
'first'.freeze => (index == 0),
|
||||
'last'.freeze => (index == length - 1),
|
||||
'parentloop'.freeze => parent_loop
|
||||
context['forloop'.freeze] = {
|
||||
'name'.freeze => @name,
|
||||
'length'.freeze => length,
|
||||
'index'.freeze => index + 1,
|
||||
'index0'.freeze => index,
|
||||
'rindex'.freeze => length - index,
|
||||
'rindex0'.freeze => length - index - 1,
|
||||
'first'.freeze => (index == 0),
|
||||
'last'.freeze => (index == length - 1)
|
||||
}
|
||||
|
||||
context['forloop'.freeze] = loop_vars
|
||||
for_stack[-1] = loop_vars
|
||||
|
||||
result << @for_block.render(context)
|
||||
result << render_all(@for_block, context)
|
||||
|
||||
# Handle any interrupts if they exist.
|
||||
if context.has_interrupt?
|
||||
@@ -129,10 +120,7 @@ module Liquid
|
||||
end
|
||||
end
|
||||
end
|
||||
|
||||
result
|
||||
ensure
|
||||
for_stack.pop
|
||||
end
|
||||
|
||||
protected
|
||||
@@ -140,12 +128,12 @@ module Liquid
|
||||
def lax_parse(markup)
|
||||
if markup =~ Syntax
|
||||
@variable_name = $1
|
||||
collection_name = $2
|
||||
@collection_name = $2
|
||||
@name = "#{$1}-#{$2}"
|
||||
@reversed = $3
|
||||
@name = "#{@variable_name}-#{collection_name}"
|
||||
@collection_name = Expression.parse(collection_name)
|
||||
@attributes = {}
|
||||
markup.scan(TagAttributes) do |key, value|
|
||||
set_attribute(key, value)
|
||||
@attributes[key] = value
|
||||
end
|
||||
else
|
||||
raise SyntaxError.new(options[:locale].t("errors.syntax.for".freeze))
|
||||
@@ -156,38 +144,26 @@ module Liquid
|
||||
p = Parser.new(markup)
|
||||
@variable_name = p.consume(:id)
|
||||
raise SyntaxError.new(options[:locale].t("errors.syntax.for_invalid_in".freeze)) unless p.id?('in'.freeze)
|
||||
collection_name = p.expression
|
||||
@name = "#{@variable_name}-#{collection_name}"
|
||||
@collection_name = Expression.parse(collection_name)
|
||||
@collection_name = p.expression
|
||||
@name = "#{@variable_name}-#{@collection_name}"
|
||||
@reversed = p.id?('reversed'.freeze)
|
||||
|
||||
@attributes = {}
|
||||
while p.look(:id) && p.look(:colon, 1)
|
||||
unless attribute = p.id?('limit'.freeze) || p.id?('offset'.freeze)
|
||||
raise SyntaxError.new(options[:locale].t("errors.syntax.for_invalid_attribute".freeze))
|
||||
end
|
||||
p.consume
|
||||
set_attribute(attribute, p.expression)
|
||||
val = p.expression
|
||||
@attributes[attribute] = val
|
||||
end
|
||||
p.consume(:end_of_string)
|
||||
end
|
||||
|
||||
private
|
||||
|
||||
def set_attribute(key, expr)
|
||||
case key
|
||||
when 'offset'.freeze
|
||||
@from = if expr == 'continue'.freeze
|
||||
:continue
|
||||
else
|
||||
Expression.parse(expr)
|
||||
end
|
||||
when 'limit'.freeze
|
||||
@limit = Expression.parse(expr)
|
||||
end
|
||||
end
|
||||
|
||||
def render_else(context)
|
||||
@else_block ? @else_block.render(context) : ''.freeze
|
||||
return @else_block ? [render_all(@else_block, context)] : ''.freeze
|
||||
end
|
||||
|
||||
def iterable?(collection)
|
||||
|
||||
@@ -20,13 +20,8 @@ module Liquid
|
||||
push_block('if'.freeze, markup)
|
||||
end
|
||||
|
||||
def parse(tokens)
|
||||
while parse_body(@blocks.last.attachment, tokens)
|
||||
end
|
||||
end
|
||||
|
||||
def nodelist
|
||||
@blocks.map(&:attachment)
|
||||
@blocks.map(&:attachment).flatten
|
||||
end
|
||||
|
||||
def unknown_tag(tag, markup, tokens)
|
||||
@@ -41,7 +36,7 @@ module Liquid
|
||||
context.stack do
|
||||
@blocks.each do |block|
|
||||
if block.evaluate(context)
|
||||
return block.attachment.render(context)
|
||||
return render_all(block.attachment, context)
|
||||
end
|
||||
end
|
||||
''.freeze
|
||||
@@ -50,61 +45,61 @@ module Liquid
|
||||
|
||||
private
|
||||
|
||||
def push_block(tag, markup)
|
||||
block = if tag == 'else'.freeze
|
||||
ElseCondition.new
|
||||
else
|
||||
parse_with_selected_parser(markup)
|
||||
def push_block(tag, markup)
|
||||
block = if tag == 'else'.freeze
|
||||
ElseCondition.new
|
||||
else
|
||||
parse_with_selected_parser(markup)
|
||||
end
|
||||
|
||||
@blocks.push(block)
|
||||
@nodelist = block.attach(Array.new)
|
||||
end
|
||||
|
||||
@blocks.push(block)
|
||||
block.attach(BlockBody.new)
|
||||
end
|
||||
def lax_parse(markup)
|
||||
expressions = markup.scan(ExpressionsAndOperators).reverse
|
||||
raise(SyntaxError.new(options[:locale].t("errors.syntax.if".freeze))) unless expressions.shift =~ Syntax
|
||||
|
||||
def lax_parse(markup)
|
||||
expressions = markup.scan(ExpressionsAndOperators)
|
||||
raise(SyntaxError.new(options[:locale].t("errors.syntax.if".freeze))) unless expressions.pop =~ Syntax
|
||||
condition = Condition.new($1, $2, $3)
|
||||
|
||||
condition = Condition.new(Expression.parse($1), $2, Expression.parse($3))
|
||||
while not expressions.empty?
|
||||
operator = (expressions.shift).to_s.strip
|
||||
|
||||
until expressions.empty?
|
||||
operator = expressions.pop.to_s.strip
|
||||
raise(SyntaxError.new(options[:locale].t("errors.syntax.if".freeze))) unless expressions.shift.to_s =~ Syntax
|
||||
|
||||
raise(SyntaxError.new(options[:locale].t("errors.syntax.if".freeze))) unless expressions.pop.to_s =~ Syntax
|
||||
new_condition = Condition.new($1, $2, $3)
|
||||
raise(SyntaxError.new(options[:locale].t("errors.syntax.if".freeze))) unless BOOLEAN_OPERATORS.include?(operator)
|
||||
new_condition.send(operator, condition)
|
||||
condition = new_condition
|
||||
end
|
||||
|
||||
new_condition = Condition.new(Expression.parse($1), $2, Expression.parse($3))
|
||||
raise(SyntaxError.new(options[:locale].t("errors.syntax.if".freeze))) unless BOOLEAN_OPERATORS.include?(operator)
|
||||
new_condition.send(operator, condition)
|
||||
condition = new_condition
|
||||
condition
|
||||
end
|
||||
|
||||
condition
|
||||
end
|
||||
def strict_parse(markup)
|
||||
p = Parser.new(markup)
|
||||
|
||||
def strict_parse(markup)
|
||||
p = Parser.new(markup)
|
||||
condition = parse_comparison(p)
|
||||
|
||||
condition = parse_comparison(p)
|
||||
while op = (p.id?('and'.freeze) || p.id?('or'.freeze))
|
||||
new_cond = parse_comparison(p)
|
||||
new_cond.send(op, condition)
|
||||
condition = new_cond
|
||||
end
|
||||
p.consume(:end_of_string)
|
||||
|
||||
while op = (p.id?('and'.freeze) || p.id?('or'.freeze))
|
||||
new_cond = parse_comparison(p)
|
||||
new_cond.send(op, condition)
|
||||
condition = new_cond
|
||||
condition
|
||||
end
|
||||
p.consume(:end_of_string)
|
||||
|
||||
condition
|
||||
end
|
||||
|
||||
def parse_comparison(p)
|
||||
a = Expression.parse(p.expression)
|
||||
if op = p.consume?(:comparison)
|
||||
b = Expression.parse(p.expression)
|
||||
Condition.new(a, op, b)
|
||||
else
|
||||
Condition.new(a)
|
||||
def parse_comparison(p)
|
||||
a = p.expression
|
||||
if op = p.consume?(:comparison)
|
||||
b = p.expression
|
||||
Condition.new(a, op, b)
|
||||
else
|
||||
Condition.new(a)
|
||||
end
|
||||
end
|
||||
end
|
||||
end
|
||||
|
||||
Template.register_tag('if'.freeze, If)
|
||||
|
||||
@@ -1,8 +1,10 @@
|
||||
module Liquid
|
||||
class Ifchanged < Block
|
||||
|
||||
def render(context)
|
||||
context.stack do
|
||||
output = super
|
||||
|
||||
output = render_all(@nodelist, context)
|
||||
|
||||
if output != context.registers[:ifchanged]
|
||||
context.registers[:ifchanged] = output
|
||||
|
||||
@@ -1,4 +1,5 @@
|
||||
module Liquid
|
||||
|
||||
# Include allows templates to relate with other templates
|
||||
#
|
||||
# Simply include another template:
|
||||
@@ -21,15 +22,12 @@ module Liquid
|
||||
|
||||
if markup =~ Syntax
|
||||
|
||||
template_name = $1
|
||||
variable_name = $3
|
||||
|
||||
@variable_name_expr = variable_name ? Expression.parse(variable_name) : nil
|
||||
@template_name_expr = Expression.parse(template_name)
|
||||
@attributes = {}
|
||||
@template_name = $1
|
||||
@variable_name = $3
|
||||
@attributes = {}
|
||||
|
||||
markup.scan(TagAttributes) do |key, value|
|
||||
@attributes[key] = Expression.parse(value)
|
||||
@attributes[key] = value
|
||||
end
|
||||
|
||||
else
|
||||
@@ -37,26 +35,19 @@ module Liquid
|
||||
end
|
||||
end
|
||||
|
||||
def parse(_tokens)
|
||||
def parse(tokens)
|
||||
end
|
||||
|
||||
def render(context)
|
||||
partial = load_cached_partial(context)
|
||||
|
||||
template_name = context.evaluate(@template_name_expr)
|
||||
context_variable_name = template_name.split('/'.freeze).last
|
||||
|
||||
variable = if @variable_name_expr
|
||||
context.evaluate(@variable_name_expr)
|
||||
else
|
||||
context.find_variable(template_name)
|
||||
end
|
||||
variable = context[@variable_name || @template_name[1..-2]]
|
||||
|
||||
context.stack do
|
||||
@attributes.each do |key, value|
|
||||
context[key] = context.evaluate(value)
|
||||
context[key] = context[value]
|
||||
end
|
||||
|
||||
context_variable_name = @template_name[1..-2].split('/'.freeze).last
|
||||
if variable.is_a?(Array)
|
||||
variable.collect do |var|
|
||||
context[context_variable_name] = var
|
||||
@@ -70,36 +61,33 @@ module Liquid
|
||||
end
|
||||
|
||||
private
|
||||
def load_cached_partial(context)
|
||||
cached_partials = context.registers[:cached_partials] || {}
|
||||
template_name = context[@template_name]
|
||||
|
||||
def load_cached_partial(context)
|
||||
cached_partials = context.registers[:cached_partials] || {}
|
||||
template_name = context.evaluate(@template_name_expr)
|
||||
|
||||
if cached = cached_partials[template_name]
|
||||
return cached
|
||||
if cached = cached_partials[template_name]
|
||||
return cached
|
||||
end
|
||||
source = read_template_from_file_system(context)
|
||||
partial = Liquid::Template.parse(source)
|
||||
cached_partials[template_name] = partial
|
||||
context.registers[:cached_partials] = cached_partials
|
||||
partial
|
||||
end
|
||||
source = read_template_from_file_system(context)
|
||||
partial = Liquid::Template.parse(source, pass_options)
|
||||
cached_partials[template_name] = partial
|
||||
context.registers[:cached_partials] = cached_partials
|
||||
partial
|
||||
end
|
||||
|
||||
def read_template_from_file_system(context)
|
||||
file_system = context.registers[:file_system] || Liquid::Template.file_system
|
||||
def read_template_from_file_system(context)
|
||||
file_system = context.registers[:file_system] || Liquid::Template.file_system
|
||||
|
||||
file_system.read_template_file(context.evaluate(@template_name_expr))
|
||||
end
|
||||
|
||||
def pass_options
|
||||
dont_pass = @options[:include_options_blacklist]
|
||||
return { locale: @options[:locale] } if dont_pass == true
|
||||
opts = @options.merge(included: true, include_options_blacklist: false)
|
||||
if dont_pass.is_a?(Array)
|
||||
dont_pass.each { |o| opts.delete(o) }
|
||||
# make read_template_file call backwards-compatible.
|
||||
case file_system.method(:read_template_file).arity
|
||||
when 1
|
||||
file_system.read_template_file(context[@template_name])
|
||||
when 2
|
||||
file_system.read_template_file(context[@template_name], context)
|
||||
else
|
||||
raise ArgumentError, "file_system.read_template_file expects two parameters: (template_name, context)"
|
||||
end
|
||||
end
|
||||
opts
|
||||
end
|
||||
end
|
||||
|
||||
Template.register_tag('include'.freeze, Include)
|
||||
|
||||
@@ -3,27 +3,19 @@ module Liquid
|
||||
FullTokenPossiblyInvalid = /\A(.*)#{TagStart}\s*(\w+)\s*(.*)?#{TagEnd}\z/om
|
||||
|
||||
def parse(tokens)
|
||||
@body = ''
|
||||
@nodelist ||= []
|
||||
@nodelist.clear
|
||||
while token = tokens.shift
|
||||
if token =~ FullTokenPossiblyInvalid
|
||||
@body << $1 if $1 != "".freeze
|
||||
return if block_delimiter == $2
|
||||
@nodelist << $1 if $1 != "".freeze
|
||||
if block_delimiter == $2
|
||||
end_tag
|
||||
return
|
||||
end
|
||||
end
|
||||
@body << token unless token.empty?
|
||||
@nodelist << token if not token.empty?
|
||||
end
|
||||
end
|
||||
|
||||
def render(_context)
|
||||
@body
|
||||
end
|
||||
|
||||
def nodelist
|
||||
[@body]
|
||||
end
|
||||
|
||||
def blank?
|
||||
@body.empty?
|
||||
end
|
||||
end
|
||||
|
||||
Template.register_tag('raw'.freeze, Raw)
|
||||
|
||||
@@ -6,10 +6,10 @@ module Liquid
|
||||
super
|
||||
if markup =~ Syntax
|
||||
@variable_name = $1
|
||||
@collection_name = Expression.parse($2)
|
||||
@collection_name = $2
|
||||
@attributes = {}
|
||||
markup.scan(TagAttributes) do |key, value|
|
||||
@attributes[key] = Expression.parse(value)
|
||||
@attributes[key] = value
|
||||
end
|
||||
else
|
||||
raise SyntaxError.new(options[:locale].t("errors.syntax.table_row".freeze))
|
||||
@@ -17,22 +17,23 @@ module Liquid
|
||||
end
|
||||
|
||||
def render(context)
|
||||
collection = context.evaluate(@collection_name) or return ''.freeze
|
||||
collection = context[@collection_name] or return ''.freeze
|
||||
|
||||
from = @attributes.key?('offset'.freeze) ? context.evaluate(@attributes['offset'.freeze]).to_i : 0
|
||||
to = @attributes.key?('limit'.freeze) ? from + context.evaluate(@attributes['limit'.freeze]).to_i : nil
|
||||
from = @attributes['offset'.freeze] ? context[@attributes['offset'.freeze]].to_i : 0
|
||||
to = @attributes['limit'.freeze] ? from + context[@attributes['limit'.freeze]].to_i : nil
|
||||
|
||||
collection = Utils.slice_collection(collection, from, to)
|
||||
|
||||
length = collection.length
|
||||
|
||||
cols = context.evaluate(@attributes['cols'.freeze]).to_i
|
||||
cols = context[@attributes['cols'.freeze]].to_i
|
||||
|
||||
row = 1
|
||||
col = 0
|
||||
|
||||
result = "<tr class=\"row1\">\n"
|
||||
context.stack do
|
||||
|
||||
collection.each_with_index do |item, index|
|
||||
context[@variable_name] = item
|
||||
context['tablerowloop'.freeze] = {
|
||||
@@ -41,6 +42,7 @@ module Liquid
|
||||
'index0'.freeze => index,
|
||||
'col'.freeze => col + 1,
|
||||
'col0'.freeze => col,
|
||||
'index0'.freeze => index,
|
||||
'rindex'.freeze => length - index,
|
||||
'rindex0'.freeze => length - index - 1,
|
||||
'first'.freeze => (index == 0),
|
||||
@@ -49,15 +51,17 @@ module Liquid
|
||||
'col_last'.freeze => (col == cols - 1)
|
||||
}
|
||||
|
||||
|
||||
col += 1
|
||||
|
||||
result << "<td class=\"col#{col}\">" << super << '</td>'
|
||||
result << "<td class=\"col#{col}\">" << render_all(@nodelist, context) << '</td>'
|
||||
|
||||
if col == cols && (index != length - 1)
|
||||
if col == cols and (index != length - 1)
|
||||
col = 0
|
||||
row += 1
|
||||
result << "</tr>\n<tr class=\"row#{row}\">"
|
||||
end
|
||||
|
||||
end
|
||||
end
|
||||
result << "</tr>\n"
|
||||
|
||||
@@ -1,23 +1,24 @@
|
||||
require_relative 'if'
|
||||
require File.dirname(__FILE__) + '/if'
|
||||
|
||||
module Liquid
|
||||
# Unless is a conditional just like 'if' but works on the inverse logic.
|
||||
#
|
||||
# {% unless x < 0 %} x is greater than zero {% endunless %}
|
||||
# {% unless x < 0 %} x is greater than zero {% end %}
|
||||
#
|
||||
class Unless < If
|
||||
def render(context)
|
||||
context.stack do
|
||||
|
||||
# First condition is interpreted backwards ( if not )
|
||||
first_block = @blocks.first
|
||||
unless first_block.evaluate(context)
|
||||
return first_block.attachment.render(context)
|
||||
return render_all(first_block.attachment, context)
|
||||
end
|
||||
|
||||
# After the first condition unless works just like if
|
||||
@blocks[1..-1].each do |block|
|
||||
if block.evaluate(context)
|
||||
return block.attachment.render(context)
|
||||
return render_all(block.attachment, context)
|
||||
end
|
||||
end
|
||||
|
||||
|
||||
@@ -1,4 +1,5 @@
|
||||
module Liquid
|
||||
|
||||
# Templates are central to liquid.
|
||||
# Interpretating templates is a two step process. First you compile the
|
||||
# source code you got. During compile time some extensive error checking is performed.
|
||||
@@ -14,12 +15,10 @@ module Liquid
|
||||
#
|
||||
class Template
|
||||
DEFAULT_OPTIONS = {
|
||||
locale: I18n.new
|
||||
:locale => I18n.new
|
||||
}
|
||||
|
||||
attr_accessor :root, :render_errors
|
||||
attr_reader :resource_limits
|
||||
|
||||
attr_accessor :root, :resource_limits
|
||||
@@file_system = BlankFileSystem.new
|
||||
|
||||
class TagRegistry
|
||||
@@ -52,8 +51,6 @@ module Liquid
|
||||
end
|
||||
end
|
||||
|
||||
attr_reader :profiler
|
||||
|
||||
class << self
|
||||
# Sets how strict the parser should be.
|
||||
# :lax acts like liquid 2.5 and silently ignores malformed tags in most cases.
|
||||
@@ -61,12 +58,6 @@ module Liquid
|
||||
# :strict will enforce correct syntax.
|
||||
attr_writer :error_mode
|
||||
|
||||
# Sets how strict the taint checker should be.
|
||||
# :lax is the default, and ignores the taint flag completely
|
||||
# :warn adds a warning, but does not interrupt the rendering
|
||||
# :error raises an error when tainted output is used
|
||||
attr_writer :taint_mode
|
||||
|
||||
def file_system
|
||||
@@file_system
|
||||
end
|
||||
@@ -87,39 +78,27 @@ module Liquid
|
||||
@error_mode || :lax
|
||||
end
|
||||
|
||||
def taint_mode
|
||||
@taint_mode || :lax
|
||||
end
|
||||
|
||||
# Pass a module with filter methods which should be available
|
||||
# to all liquid views. Good for registering the standard library
|
||||
def register_filter(mod)
|
||||
Strainer.global_filter(mod)
|
||||
end
|
||||
|
||||
def default_resource_limits
|
||||
@default_resource_limits ||= {}
|
||||
end
|
||||
|
||||
# creates a new <tt>Template</tt> object from liquid source code
|
||||
# To enable profiling, pass in <tt>profile: true</tt> as an option.
|
||||
# See Liquid::Profiler for more information
|
||||
def parse(source, options = {})
|
||||
template = Template.new
|
||||
template.parse(source, options)
|
||||
end
|
||||
end
|
||||
|
||||
# creates a new <tt>Template</tt> from an array of tokens. Use <tt>Template.parse</tt> instead
|
||||
def initialize
|
||||
@resource_limits = ResourceLimits.new(self.class.default_resource_limits)
|
||||
@resource_limits = {}
|
||||
end
|
||||
|
||||
# Parse source code.
|
||||
# Returns self for easy chaining
|
||||
def parse(source, options = {})
|
||||
@options = options
|
||||
@profiling = options[:profile]
|
||||
@line_numbers = options[:line_numbers] || @profiling
|
||||
@root = Document.parse(tokenize(source), DEFAULT_OPTIONS.merge(options))
|
||||
@warnings = nil
|
||||
self
|
||||
@@ -151,9 +130,6 @@ module Liquid
|
||||
# if you use the same filters over and over again consider registering them globally
|
||||
# with <tt>Template.register_filter</tt>
|
||||
#
|
||||
# if profiling was enabled in <tt>Template#parse</tt> then the resulting profiling information
|
||||
# will be available via <tt>Template#profiler</tt>
|
||||
#
|
||||
# Following options can be passed:
|
||||
#
|
||||
# * <tt>filters</tt> : array with local filters
|
||||
@@ -183,14 +159,12 @@ module Liquid
|
||||
raise ArgumentError, "Expected Hash or Liquid::Context as parameter"
|
||||
end
|
||||
|
||||
context.render_errors = self.render_errors unless self.render_errors.nil?
|
||||
|
||||
case args.last
|
||||
when Hash
|
||||
options = args.pop
|
||||
|
||||
if options[:registers].is_a?(Hash)
|
||||
registers.merge!(options[:registers])
|
||||
self.registers.merge!(options[:registers])
|
||||
end
|
||||
|
||||
if options[:filters]
|
||||
@@ -206,15 +180,10 @@ module Liquid
|
||||
context.add_filters(args.pop)
|
||||
end
|
||||
|
||||
# Retrying a render resets resource usage
|
||||
context.resource_limits.reset
|
||||
|
||||
begin
|
||||
# render the nodelist.
|
||||
# for performance reasons we get an array back here. join will make a string out of it.
|
||||
result = with_profiling do
|
||||
@root.render(context)
|
||||
end
|
||||
result = @root.render(context)
|
||||
result.respond_to?(:join) ? result.join : result
|
||||
rescue Liquid::MemoryError => e
|
||||
context.handle_error(e)
|
||||
@@ -234,41 +203,13 @@ module Liquid
|
||||
def tokenize(source)
|
||||
source = source.source if source.respond_to?(:source)
|
||||
return [] if source.to_s.empty?
|
||||
|
||||
tokens = calculate_line_numbers(source.split(TemplateParser))
|
||||
tokens = source.split(TemplateParser)
|
||||
|
||||
# removes the rogue empty element at the beginning of the array
|
||||
tokens.shift if tokens[0] && tokens[0].empty?
|
||||
tokens.shift if tokens[0] and tokens[0].empty?
|
||||
|
||||
tokens
|
||||
end
|
||||
|
||||
def calculate_line_numbers(raw_tokens)
|
||||
return raw_tokens unless @line_numbers
|
||||
|
||||
current_line = 1
|
||||
raw_tokens.map do |token|
|
||||
Token.new(token, current_line).tap do
|
||||
current_line += token.count("\n")
|
||||
end
|
||||
end
|
||||
end
|
||||
|
||||
def with_profiling
|
||||
if @profiling && !@options[:included]
|
||||
raise "Profiler not loaded, require 'liquid/profiler' first" unless defined?(Liquid::Profiler)
|
||||
|
||||
@profiler = Profiler.new
|
||||
@profiler.start
|
||||
|
||||
begin
|
||||
yield
|
||||
ensure
|
||||
@profiler.stop
|
||||
end
|
||||
else
|
||||
yield
|
||||
end
|
||||
end
|
||||
end
|
||||
end
|
||||
|
||||
@@ -1,18 +0,0 @@
|
||||
module Liquid
|
||||
class Token < String
|
||||
attr_reader :line_number
|
||||
|
||||
def initialize(content, line_number)
|
||||
super(content)
|
||||
@line_number = line_number
|
||||
end
|
||||
|
||||
def raw
|
||||
"<raw>"
|
||||
end
|
||||
|
||||
def child(string)
|
||||
Token.new(string, @line_number)
|
||||
end
|
||||
end
|
||||
end
|
||||
@@ -1,7 +1,8 @@
|
||||
module Liquid
|
||||
module Utils
|
||||
|
||||
def self.slice_collection(collection, from, to)
|
||||
if (from != 0 || !to.nil?) && collection.respond_to?(:load_slice)
|
||||
if (from != 0 || to != nil) && collection.respond_to?(:load_slice)
|
||||
collection.load_slice(from, to)
|
||||
else
|
||||
slice_collection_using_each(collection, from, to)
|
||||
@@ -20,6 +21,7 @@ module Liquid
|
||||
return [collection] if non_blank_string?(collection)
|
||||
|
||||
collection.each do |item|
|
||||
|
||||
if to && to <= index
|
||||
break
|
||||
end
|
||||
|
||||
@@ -1,4 +1,5 @@
|
||||
module Liquid
|
||||
|
||||
# Holds variables. Variables are only loaded "just in time"
|
||||
# and are not evaluated as part of the render stage
|
||||
#
|
||||
@@ -10,113 +11,96 @@ module Liquid
|
||||
# {{ user | link }}
|
||||
#
|
||||
class Variable
|
||||
FilterParser = /(?:\s+|#{QuotedFragment}|#{ArgumentSeparator})+/o
|
||||
FilterParser = /(?:#{FilterSeparator}|(?:\s*(?:#{QuotedFragment}|#{ArgumentSeparator})\s*)+)/o
|
||||
EasyParse = /\A *(\w+(?:\.\w+)*) *\z/
|
||||
attr_accessor :filters, :name, :warnings
|
||||
attr_accessor :line_number
|
||||
include ParserSwitching
|
||||
|
||||
def initialize(markup, options = {})
|
||||
@markup = markup
|
||||
@name = nil
|
||||
@options = options || {}
|
||||
|
||||
parse_with_selected_parser(markup)
|
||||
end
|
||||
|
||||
def raw
|
||||
@markup
|
||||
end
|
||||
|
||||
def markup_context(markup)
|
||||
"in \"{{#{markup}}}\""
|
||||
case @options[:error_mode] || Template.error_mode
|
||||
when :strict then strict_parse(markup)
|
||||
when :lax then lax_parse(markup)
|
||||
when :warn
|
||||
begin
|
||||
strict_parse(markup)
|
||||
rescue SyntaxError => e
|
||||
@warnings ||= []
|
||||
@warnings << e
|
||||
lax_parse(markup)
|
||||
end
|
||||
end
|
||||
end
|
||||
|
||||
def lax_parse(markup)
|
||||
@filters = []
|
||||
return unless markup =~ /(#{QuotedFragment})(.*)/om
|
||||
|
||||
name_markup = $1
|
||||
filter_markup = $2
|
||||
@name = Expression.parse(name_markup)
|
||||
if filter_markup =~ /#{FilterSeparator}\s*(.*)/om
|
||||
filters = $1.scan(FilterParser)
|
||||
filters.each do |f|
|
||||
if f =~ /\w+/
|
||||
filtername = Regexp.last_match(0)
|
||||
filterargs = f.scan(/(?:#{FilterArgumentSeparator}|#{ArgumentSeparator})\s*((?:\w+\s*\:\s*)?#{QuotedFragment})/o).flatten
|
||||
@filters << parse_filter_expressions(filtername, filterargs)
|
||||
if markup =~ /\s*(#{QuotedFragment})(.*)/om
|
||||
@name = Regexp.last_match(1)
|
||||
if Regexp.last_match(2) =~ /#{FilterSeparator}\s*(.*)/om
|
||||
filters = Regexp.last_match(1).scan(FilterParser)
|
||||
filters.each do |f|
|
||||
if f =~ /\s*(\w+)/
|
||||
filtername = Regexp.last_match(1)
|
||||
filterargs = f.scan(/(?:#{FilterArgumentSeparator}|#{ArgumentSeparator})\s*((?:\w+\s*\:\s*)?#{QuotedFragment})/o).flatten
|
||||
@filters << [filtername, filterargs]
|
||||
end
|
||||
end
|
||||
end
|
||||
end
|
||||
end
|
||||
|
||||
def strict_parse(markup)
|
||||
# Very simple valid cases
|
||||
if markup =~ EasyParse
|
||||
@name = $1
|
||||
@filters = []
|
||||
return
|
||||
end
|
||||
|
||||
@filters = []
|
||||
p = Parser.new(markup)
|
||||
|
||||
@name = Expression.parse(p.expression)
|
||||
# Could be just filters with no input
|
||||
@name = p.look(:pipe) ? ''.freeze : p.expression
|
||||
while p.consume?(:pipe)
|
||||
filtername = p.consume(:id)
|
||||
filterargs = p.consume?(:colon) ? parse_filterargs(p) : []
|
||||
@filters << parse_filter_expressions(filtername, filterargs)
|
||||
@filters << [filtername, filterargs]
|
||||
end
|
||||
p.consume(:end_of_string)
|
||||
rescue SyntaxError => e
|
||||
e.message << " in \"{{#{markup}}}\""
|
||||
raise e
|
||||
end
|
||||
|
||||
def parse_filterargs(p)
|
||||
# first argument
|
||||
filterargs = [p.argument]
|
||||
# followed by comma separated others
|
||||
filterargs << p.argument while p.consume?(:comma)
|
||||
while p.consume?(:comma)
|
||||
filterargs << p.argument
|
||||
end
|
||||
filterargs
|
||||
end
|
||||
|
||||
def render(context)
|
||||
@filters.inject(context.evaluate(@name)) do |output, (filter_name, filter_args, filter_kwargs)|
|
||||
filter_args = evaluate_filter_expressions(context, filter_args, filter_kwargs)
|
||||
output = context.invoke(filter_name, output, *filter_args)
|
||||
end.tap{ |obj| taint_check(obj) }
|
||||
end
|
||||
|
||||
private
|
||||
|
||||
def parse_filter_expressions(filter_name, unparsed_args)
|
||||
filter_args = []
|
||||
keyword_args = {}
|
||||
unparsed_args.each do |a|
|
||||
if matches = a.match(/\A#{TagAttributes}\z/o)
|
||||
keyword_args[matches[1]] = Expression.parse(matches[2])
|
||||
else
|
||||
filter_args << Expression.parse(a)
|
||||
return ''.freeze if @name.nil?
|
||||
@filters.inject(context[@name]) do |output, filter|
|
||||
filterargs = []
|
||||
keyword_args = {}
|
||||
filter[1].to_a.each do |a|
|
||||
if matches = a.match(/\A#{TagAttributes}\z/o)
|
||||
keyword_args[matches[1]] = context[matches[2]]
|
||||
else
|
||||
filterargs << context[a]
|
||||
end
|
||||
end
|
||||
end
|
||||
result = [filter_name, filter_args]
|
||||
result << keyword_args unless keyword_args.empty?
|
||||
result
|
||||
end
|
||||
|
||||
def evaluate_filter_expressions(context, filter_args, filter_kwargs)
|
||||
parsed_args = filter_args.map{ |expr| context.evaluate(expr) }
|
||||
if filter_kwargs
|
||||
parsed_kwargs = {}
|
||||
filter_kwargs.each do |key, expr|
|
||||
parsed_kwargs[key] = context.evaluate(expr)
|
||||
end
|
||||
parsed_args << parsed_kwargs
|
||||
end
|
||||
parsed_args
|
||||
end
|
||||
|
||||
def taint_check(obj)
|
||||
if obj.tainted?
|
||||
@markup =~ QuotedFragment
|
||||
name = Regexp.last_match(0)
|
||||
case Template.taint_mode
|
||||
when :warn
|
||||
@warnings ||= []
|
||||
@warnings << "variable '#{name}' is tainted and was not escaped"
|
||||
when :error
|
||||
raise TaintedError, "Error - variable '#{name}' is tainted and was not escaped"
|
||||
filterargs << keyword_args unless keyword_args.empty?
|
||||
begin
|
||||
output = context.invoke(filter[0], output, *filterargs)
|
||||
rescue FilterNotFound
|
||||
raise FilterNotFound, "Error - filter '#{filter[0]}' in '#{@markup.strip}' could not be found."
|
||||
end
|
||||
end
|
||||
end
|
||||
|
||||
@@ -1,80 +0,0 @@
|
||||
module Liquid
|
||||
class VariableLookup
|
||||
SQUARE_BRACKETED = /\A\[(.*)\]\z/m
|
||||
COMMAND_METHODS = ['size'.freeze, 'first'.freeze, 'last'.freeze]
|
||||
|
||||
attr_reader :name, :lookups
|
||||
|
||||
def self.parse(markup)
|
||||
new(markup)
|
||||
end
|
||||
|
||||
def initialize(markup)
|
||||
lookups = markup.scan(VariableParser)
|
||||
|
||||
name = lookups.shift
|
||||
if name =~ SQUARE_BRACKETED
|
||||
name = Expression.parse($1)
|
||||
end
|
||||
@name = name
|
||||
|
||||
@lookups = lookups
|
||||
@command_flags = 0
|
||||
|
||||
@lookups.each_index do |i|
|
||||
lookup = lookups[i]
|
||||
if lookup =~ SQUARE_BRACKETED
|
||||
lookups[i] = Expression.parse($1)
|
||||
elsif COMMAND_METHODS.include?(lookup)
|
||||
@command_flags |= 1 << i
|
||||
end
|
||||
end
|
||||
end
|
||||
|
||||
def evaluate(context)
|
||||
name = context.evaluate(@name)
|
||||
object = context.find_variable(name)
|
||||
|
||||
@lookups.each_index do |i|
|
||||
key = context.evaluate(@lookups[i])
|
||||
|
||||
# If object is a hash- or array-like object we look for the
|
||||
# presence of the key and if its available we return it
|
||||
if object.respond_to?(:[]) &&
|
||||
((object.respond_to?(:has_key?) && object.has_key?(key)) ||
|
||||
(object.respond_to?(:fetch) && key.is_a?(Integer)))
|
||||
|
||||
# if its a proc we will replace the entry with the proc
|
||||
res = context.lookup_and_evaluate(object, key)
|
||||
object = res.to_liquid
|
||||
|
||||
# Some special cases. If the part wasn't in square brackets and
|
||||
# no key with the same name was found we interpret following calls
|
||||
# as commands and call them on the current object
|
||||
elsif @command_flags & (1 << i) != 0 && object.respond_to?(key)
|
||||
object = object.send(key).to_liquid
|
||||
|
||||
# No key was present with the desired value and it wasn't one of the directly supported
|
||||
# keywords either. The only thing we got left is to return nil
|
||||
else
|
||||
return nil
|
||||
end
|
||||
|
||||
# If we are dealing with a drop here we have to
|
||||
object.context = context if object.respond_to?(:context=)
|
||||
end
|
||||
|
||||
object
|
||||
end
|
||||
|
||||
def ==(other)
|
||||
self.class == other.class && state == other.state
|
||||
end
|
||||
|
||||
protected
|
||||
|
||||
def state
|
||||
[@name, @lookups, @command_flags]
|
||||
end
|
||||
end
|
||||
end
|
||||
@@ -1,4 +1,4 @@
|
||||
# encoding: utf-8
|
||||
module Liquid
|
||||
VERSION = "4.0.0.alpha"
|
||||
VERSION = "3.0.0.rc1"
|
||||
end
|
||||
|
||||
@@ -1,6 +1,6 @@
|
||||
# encoding: utf-8
|
||||
lib = File.expand_path('../lib/', __FILE__)
|
||||
$LOAD_PATH.unshift lib unless $LOAD_PATH.include?(lib)
|
||||
$:.unshift lib unless $:.include?(lib)
|
||||
|
||||
require "liquid/version"
|
||||
|
||||
@@ -9,11 +9,11 @@ Gem::Specification.new do |s|
|
||||
s.version = Liquid::VERSION
|
||||
s.platform = Gem::Platform::RUBY
|
||||
s.summary = "A secure, non-evaling end user template engine with aesthetic markup."
|
||||
s.authors = ["Tobias Lütke"]
|
||||
s.authors = ["Tobias Luetke"]
|
||||
s.email = ["tobi@leetsoft.com"]
|
||||
s.homepage = "http://www.liquidmarkup.org"
|
||||
s.license = "MIT"
|
||||
# s.description = "A secure, non-evaling end user template engine with aesthetic markup."
|
||||
#s.description = "A secure, non-evaling end user template engine with aesthetic markup."
|
||||
|
||||
s.required_rubygems_version = ">= 1.3.7"
|
||||
|
||||
@@ -25,5 +25,4 @@ Gem::Specification.new do |s|
|
||||
s.require_path = "lib"
|
||||
|
||||
s.add_development_dependency 'rake'
|
||||
s.add_development_dependency 'minitest'
|
||||
end
|
||||
|
||||
@@ -1,17 +1,11 @@
|
||||
require 'benchmark/ips'
|
||||
require_relative 'theme_runner'
|
||||
require 'benchmark'
|
||||
require File.dirname(__FILE__) + '/theme_runner'
|
||||
|
||||
Liquid::Template.error_mode = ARGV.first.to_sym if ARGV.first
|
||||
profiler = ThemeRunner.new
|
||||
|
||||
Benchmark.ips do |x|
|
||||
x.time = 60
|
||||
x.warmup = 5
|
||||
|
||||
puts
|
||||
puts "Running benchmark for #{x.time} seconds (with #{x.warmup} seconds warmup)."
|
||||
puts
|
||||
|
||||
x.report("parse:") { profiler.compile }
|
||||
x.report("parse & run:") { profiler.run }
|
||||
Benchmark.bmbm do |x|
|
||||
x.report("parse:") { 100.times { profiler.compile } }
|
||||
x.report("parse & run:") { 100.times { profiler.run } }
|
||||
end
|
||||
|
||||
|
||||
@@ -1,24 +1,17 @@
|
||||
require 'stackprof' rescue fail("install stackprof extension/gem")
|
||||
require_relative 'theme_runner'
|
||||
require File.dirname(__FILE__) + '/theme_runner'
|
||||
|
||||
Liquid::Template.error_mode = ARGV.first.to_sym if ARGV.first
|
||||
profiler = ThemeRunner.new
|
||||
profiler.run
|
||||
|
||||
[:cpu, :object].each do |profile_type|
|
||||
puts "Profiling in #{profile_type} mode..."
|
||||
puts "Profiling in #{profile_type.to_s} mode..."
|
||||
results = StackProf.run(mode: profile_type) do
|
||||
200.times do
|
||||
100.times do
|
||||
profiler.run
|
||||
end
|
||||
end
|
||||
|
||||
if profile_type == :cpu && graph_filename = ENV['GRAPH_FILENAME']
|
||||
File.open(graph_filename, 'w') do |f|
|
||||
StackProf::Report.new(results).print_graphviz(nil, f)
|
||||
end
|
||||
end
|
||||
|
||||
StackProf::Report.new(results).print_text(false, 20)
|
||||
File.write(ENV['FILENAME'] + "." + profile_type.to_s, Marshal.dump(results)) if ENV['FILENAME']
|
||||
end
|
||||
|
||||
@@ -28,6 +28,6 @@ class CommentForm < Liquid::Block
|
||||
end
|
||||
|
||||
def wrap_in_form(article, input)
|
||||
%(<form id="article-#{article.id}-comment-form" class="comment-form" method="post" action="">\n#{input}\n</form>)
|
||||
%Q{<form id="article-#{article.id}-comment-form" class="comment-form" method="post" action="">\n#{input}\n</form>}
|
||||
end
|
||||
end
|
||||
|
||||
@@ -5,7 +5,7 @@ module Database
|
||||
# to liquid as assigns. All this is based on Shopify
|
||||
def self.tables
|
||||
@tables ||= begin
|
||||
db = YAML.load_file("#{__dir__}/vision.database.yml")
|
||||
db = YAML.load_file(File.dirname(__FILE__) + '/vision.database.yml')
|
||||
|
||||
# From vision source
|
||||
db['products'].each do |product|
|
||||
@@ -39,7 +39,7 @@ module Database
|
||||
end
|
||||
end
|
||||
|
||||
if __FILE__ == $PROGRAM_NAME
|
||||
if __FILE__ == $0
|
||||
p Database.tables['collections']['frontpage'].keys
|
||||
# p Database.tables['blog']['articles']
|
||||
#p Database.tables['blog']['articles']
|
||||
end
|
||||
|
||||
@@ -1,7 +1,9 @@
|
||||
require 'json'
|
||||
|
||||
module JsonFilter
|
||||
|
||||
def json(object)
|
||||
JSON.dump(object.reject { |k, v| k == "collections" })
|
||||
JSON.dump(object.reject {|k,v| k == "collections" })
|
||||
end
|
||||
|
||||
end
|
||||
|
||||
@@ -1,13 +1,13 @@
|
||||
$:.unshift __dir__ + '/../../lib'
|
||||
require_relative '../../lib/liquid'
|
||||
$:.unshift File.dirname(__FILE__) + '/../../lib'
|
||||
require File.dirname(__FILE__) + '/../../lib/liquid'
|
||||
|
||||
require_relative 'comment_form'
|
||||
require_relative 'paginate'
|
||||
require_relative 'json_filter'
|
||||
require_relative 'money_filter'
|
||||
require_relative 'shop_filter'
|
||||
require_relative 'tag_filter'
|
||||
require_relative 'weight_filter'
|
||||
require File.dirname(__FILE__) + '/comment_form'
|
||||
require File.dirname(__FILE__) + '/paginate'
|
||||
require File.dirname(__FILE__) + '/json_filter'
|
||||
require File.dirname(__FILE__) + '/money_filter'
|
||||
require File.dirname(__FILE__) + '/shop_filter'
|
||||
require File.dirname(__FILE__) + '/tag_filter'
|
||||
require File.dirname(__FILE__) + '/weight_filter'
|
||||
|
||||
Liquid::Template.register_tag 'paginate', Paginate
|
||||
Liquid::Template.register_tag 'form', CommentForm
|
||||
|
||||
@@ -1,12 +1,13 @@
|
||||
module MoneyFilter
|
||||
|
||||
def money_with_currency(money)
|
||||
return '' if money.nil?
|
||||
sprintf("$ %.2f USD", money / 100.0)
|
||||
sprintf("$ %.2f USD", money/100.0)
|
||||
end
|
||||
|
||||
def money(money)
|
||||
return '' if money.nil?
|
||||
sprintf("$ %.2f", money / 100.0)
|
||||
sprintf("$ %.2f", money/100.0)
|
||||
end
|
||||
|
||||
private
|
||||
|
||||
@@ -4,6 +4,8 @@ class Paginate < Liquid::Block
|
||||
def initialize(tag_name, markup, options)
|
||||
super
|
||||
|
||||
@nodelist = []
|
||||
|
||||
if markup =~ Syntax
|
||||
@collection_name = $1
|
||||
@page_size = if $2
|
||||
@@ -42,22 +44,23 @@ class Paginate < Liquid::Block
|
||||
page_count = (collection_size.to_f / @page_size.to_f).to_f.ceil + 1
|
||||
|
||||
pagination['items'] = collection_size
|
||||
pagination['pages'] = page_count - 1
|
||||
pagination['previous'] = link('« Previous', current_page - 1) unless 1 >= current_page
|
||||
pagination['next'] = link('Next »', current_page + 1) unless page_count <= current_page + 1
|
||||
pagination['pages'] = page_count -1
|
||||
pagination['previous'] = link('« Previous', current_page-1 ) unless 1 >= current_page
|
||||
pagination['next'] = link('Next »', current_page+1 ) unless page_count <= current_page+1
|
||||
pagination['parts'] = []
|
||||
|
||||
hellip_break = false
|
||||
|
||||
if page_count > 2
|
||||
1.upto(page_count - 1) do |page|
|
||||
1.upto(page_count-1) do |page|
|
||||
|
||||
if current_page == page
|
||||
pagination['parts'] << no_link(page)
|
||||
elsif page == 1
|
||||
pagination['parts'] << link(page, page)
|
||||
elsif page == page_count - 1
|
||||
elsif page == page_count -1
|
||||
pagination['parts'] << link(page, page)
|
||||
elsif page <= current_page - @attributes['window_size'] || page >= current_page + @attributes['window_size']
|
||||
elsif page <= current_page - @attributes['window_size'] or page >= current_page + @attributes['window_size']
|
||||
next if hellip_break
|
||||
pagination['parts'] << no_link('…')
|
||||
hellip_break = true
|
||||
@@ -70,18 +73,18 @@ class Paginate < Liquid::Block
|
||||
end
|
||||
end
|
||||
|
||||
super
|
||||
render_all(@nodelist, context)
|
||||
end
|
||||
end
|
||||
|
||||
private
|
||||
|
||||
def no_link(title)
|
||||
{ 'title' => title, 'is_link' => false }
|
||||
{ 'title' => title, 'is_link' => false}
|
||||
end
|
||||
|
||||
def link(title, page)
|
||||
{ 'title' => title, 'url' => current_url + "?page=#{page}", 'is_link' => true }
|
||||
{ 'title' => title, 'url' => current_url + "?page=#{page}", 'is_link' => true}
|
||||
end
|
||||
|
||||
def current_url
|
||||
|
||||
@@ -1,4 +1,5 @@
|
||||
module ShopFilter
|
||||
|
||||
def asset_url(input)
|
||||
"/files/1/[shop_id]/[shop_id]/assets/#{input}"
|
||||
end
|
||||
@@ -15,16 +16,16 @@ module ShopFilter
|
||||
%(<script src="#{url}" type="text/javascript"></script>)
|
||||
end
|
||||
|
||||
def stylesheet_tag(url, media = "all")
|
||||
def stylesheet_tag(url, media="all")
|
||||
%(<link href="#{url}" rel="stylesheet" type="text/css" media="#{media}" />)
|
||||
end
|
||||
|
||||
def link_to(link, url, title = "")
|
||||
%(<a href="#{url}" title="#{title}">#{link}</a>)
|
||||
def link_to(link, url, title="")
|
||||
%|<a href="#{url}" title="#{title}">#{link}</a>|
|
||||
end
|
||||
|
||||
def img_tag(url, alt = "")
|
||||
%(<img src="#{url}" alt="#{alt}" />)
|
||||
def img_tag(url, alt="")
|
||||
%|<img src="#{url}" alt="#{alt}" />|
|
||||
end
|
||||
|
||||
def link_to_vendor(vendor)
|
||||
@@ -52,6 +53,7 @@ module ShopFilter
|
||||
end
|
||||
|
||||
def product_img_url(url, style = 'small')
|
||||
|
||||
unless url =~ /\Aproducts\/([\w\-\_]+)\.(\w{2,4})/
|
||||
raise ArgumentError, 'filter "size" can only be called on product images'
|
||||
end
|
||||
@@ -67,6 +69,7 @@ module ShopFilter
|
||||
end
|
||||
|
||||
def default_pagination(paginate)
|
||||
|
||||
html = []
|
||||
html << %(<span class="prev">#{link_to(paginate['previous']['title'], paginate['previous']['url'])}</span>) if paginate['previous']
|
||||
|
||||
@@ -103,4 +106,5 @@ module ShopFilter
|
||||
result.gsub!(/\A-+/, '') if result[0] == '-'
|
||||
result
|
||||
end
|
||||
|
||||
end
|
||||
|
||||
@@ -1,9 +1,10 @@
|
||||
module TagFilter
|
||||
|
||||
def link_to_tag(label, tag)
|
||||
"<a title=\"Show tag #{tag}\" href=\"/collections/#{@context['handle']}/#{tag}\">#{label}</a>"
|
||||
end
|
||||
|
||||
def highlight_active_tag(tag, css_class = 'active')
|
||||
def highlight_active_tag(tag, css_class='active')
|
||||
if @context['current_tags'].include?(tag)
|
||||
"<span class=\"#{css_class}\">#{tag}</span>"
|
||||
else
|
||||
@@ -20,4 +21,5 @@ module TagFilter
|
||||
tags = (@context['current_tags'] - [tag]).uniq
|
||||
"<a title=\"Show tag #{tag}\" href=\"/collections/#{@context['handle']}/#{tags.join("+")}\">#{label}</a>"
|
||||
end
|
||||
|
||||
end
|
||||
|
||||
@@ -1,4 +1,5 @@
|
||||
module WeightFilter
|
||||
|
||||
def weight(grams)
|
||||
sprintf("%.2f", grams / 1000)
|
||||
end
|
||||
@@ -6,4 +7,5 @@ module WeightFilter
|
||||
def weight_with_unit(grams)
|
||||
"#{weight(grams)} kg"
|
||||
end
|
||||
|
||||
end
|
||||
|
||||
@@ -6,17 +6,18 @@
|
||||
# Shopify which is likely the biggest user of liquid in the world which something to the tune of several
|
||||
# million Template#render calls a day.
|
||||
|
||||
require_relative 'shopify/liquid'
|
||||
require_relative 'shopify/database'
|
||||
require File.dirname(__FILE__) + '/shopify/liquid'
|
||||
require File.dirname(__FILE__) + '/shopify/database.rb'
|
||||
|
||||
class ThemeRunner
|
||||
class FileSystem
|
||||
|
||||
def initialize(path)
|
||||
@path = path
|
||||
end
|
||||
|
||||
# Called by Liquid to retrieve a template file
|
||||
def read_template_file(template_path)
|
||||
def read_template_file(template_path, context)
|
||||
File.read(@path + '/' + template_path + '.liquid')
|
||||
end
|
||||
end
|
||||
@@ -24,7 +25,7 @@ class ThemeRunner
|
||||
# Load all templates into memory, do this now so that
|
||||
# we don't profile IO.
|
||||
def initialize
|
||||
@tests = Dir[__dir__ + '/tests/**/*.liquid'].collect do |test|
|
||||
@tests = Dir[File.dirname(__FILE__) + '/tests/**/*.liquid'].collect do |test|
|
||||
next if File.basename(test) == 'theme.liquid'
|
||||
|
||||
theme_path = File.dirname(test) + '/theme.liquid'
|
||||
@@ -37,6 +38,7 @@ class ThemeRunner
|
||||
# Dup assigns because will make some changes to them
|
||||
|
||||
@tests.each do |liquid, layout, template_name|
|
||||
|
||||
tmpl = Liquid::Template.new
|
||||
tmpl.parse(liquid)
|
||||
tmpl = Liquid::Template.new
|
||||
@@ -44,17 +46,20 @@ class ThemeRunner
|
||||
end
|
||||
end
|
||||
|
||||
def run
|
||||
def run
|
||||
# Dup assigns because will make some changes to them
|
||||
assigns = Database.tables.dup
|
||||
|
||||
@tests.each do |liquid, layout, template_name|
|
||||
|
||||
# Compute page_tempalte outside of profiler run, uninteresting to profiler
|
||||
page_template = File.basename(template_name, File.extname(template_name))
|
||||
compile_and_render(liquid, layout, assigns, page_template, template_name)
|
||||
|
||||
end
|
||||
end
|
||||
|
||||
|
||||
def compile_and_render(template, layout, assigns, page_template, template_file)
|
||||
tmpl = Liquid::Template.new
|
||||
tmpl.assigns['page_title'] = 'Page title'
|
||||
|
||||
@@ -1,48 +1,27 @@
|
||||
require 'test_helper'
|
||||
|
||||
class AssignTest < Minitest::Test
|
||||
class AssignTest < Test::Unit::TestCase
|
||||
include Liquid
|
||||
|
||||
def test_assign_with_hyphen_in_variable_name
|
||||
template_source = <<-END_TEMPLATE
|
||||
{% assign this-thing = 'Print this-thing' %}
|
||||
{{ this-thing }}
|
||||
END_TEMPLATE
|
||||
template = Template.parse(template_source)
|
||||
rendered = template.render!
|
||||
assert_equal "Print this-thing", rendered.strip
|
||||
end
|
||||
|
||||
def test_assigned_variable
|
||||
assert_template_result('.foo.',
|
||||
'{% assign foo = values %}.{{ foo[0] }}.',
|
||||
'values' => %w(foo bar baz))
|
||||
'{% assign foo = values %}.{{ foo[0] }}.',
|
||||
'values' => %w{foo bar baz})
|
||||
|
||||
assert_template_result('.bar.',
|
||||
'{% assign foo = values %}.{{ foo[1] }}.',
|
||||
'values' => %w(foo bar baz))
|
||||
'{% assign foo = values %}.{{ foo[1] }}.',
|
||||
'values' => %w{foo bar baz})
|
||||
end
|
||||
|
||||
def test_assign_with_filter
|
||||
assert_template_result('.bar.',
|
||||
'{% assign foo = values | split: "," %}.{{ foo[1] }}.',
|
||||
'values' => "foo,bar,baz")
|
||||
'{% assign foo = values | split: "," %}.{{ foo[1] }}.',
|
||||
'values' => "foo,bar,baz")
|
||||
end
|
||||
|
||||
def test_assign_syntax_error
|
||||
assert_match_syntax_error(/assign/,
|
||||
'{% assign foo not values %}.',
|
||||
'values' => "foo,bar,baz")
|
||||
end
|
||||
|
||||
def test_assign_uses_error_mode
|
||||
with_error_mode(:strict) do
|
||||
assert_raises(SyntaxError) do
|
||||
Template.parse("{% assign foo = ('X' | downcase) %}")
|
||||
end
|
||||
end
|
||||
with_error_mode(:lax) do
|
||||
assert Template.parse("{% assign foo = ('X' | downcase) %}")
|
||||
end
|
||||
'{% assign foo not values %}.',
|
||||
'values' => "foo,bar,baz")
|
||||
end
|
||||
end # AssignTest
|
||||
|
||||
@@ -9,12 +9,12 @@ class FoobarTag < Liquid::Tag
|
||||
end
|
||||
|
||||
class BlankTestFileSystem
|
||||
def read_template_file(template_path)
|
||||
def read_template_file(template_path, context)
|
||||
template_path
|
||||
end
|
||||
end
|
||||
|
||||
class BlankTest < Minitest::Test
|
||||
class BlankTest < Test::Unit::TestCase
|
||||
include Liquid
|
||||
N = 10
|
||||
|
||||
@@ -31,7 +31,7 @@ class BlankTest < Minitest::Test
|
||||
end
|
||||
|
||||
def test_new_tags_are_not_blank_by_default
|
||||
assert_template_result(" " * N, wrap_in_for("{% foobar %}"))
|
||||
assert_template_result(" "*N, wrap_in_for("{% foobar %}"))
|
||||
end
|
||||
|
||||
def test_loops_are_blank
|
||||
@@ -47,7 +47,7 @@ class BlankTest < Minitest::Test
|
||||
end
|
||||
|
||||
def test_mark_as_blank_only_during_parsing
|
||||
assert_template_result(" " * (N + 1), wrap(" {% if false %} this never happens, but still, this block is not blank {% endif %}"))
|
||||
assert_template_result(" "*(N+1), wrap(" {% if false %} this never happens, but still, this block is not blank {% endif %}"))
|
||||
end
|
||||
|
||||
def test_comments_are_blank
|
||||
@@ -60,9 +60,9 @@ class BlankTest < Minitest::Test
|
||||
|
||||
def test_nested_blocks_are_blank_but_only_if_all_children_are
|
||||
assert_template_result("", wrap(wrap(" ")))
|
||||
assert_template_result("\n but this is not " * (N + 1),
|
||||
wrap('{% if true %} {% comment %} this is blank {% endcomment %} {% endif %}
|
||||
{% if true %} but this is not {% endif %}'))
|
||||
assert_template_result("\n but this is not "*(N+1),
|
||||
wrap(%q{{% if true %} {% comment %} this is blank {% endcomment %} {% endif %}
|
||||
{% if true %} but this is not {% endif %}}))
|
||||
end
|
||||
|
||||
def test_assigns_are_blank
|
||||
@@ -76,31 +76,31 @@ class BlankTest < Minitest::Test
|
||||
|
||||
def test_whitespace_is_not_blank_if_other_stuff_is_present
|
||||
body = " x "
|
||||
assert_template_result(body * (N + 1), wrap(body))
|
||||
assert_template_result(body*(N+1), wrap(body))
|
||||
end
|
||||
|
||||
def test_increment_is_not_blank
|
||||
assert_template_result(" 0" * 2 * (N + 1), wrap("{% assign foo = 0 %} {% increment foo %} {% decrement foo %}"))
|
||||
assert_template_result(" 0"*2*(N+1), wrap("{% assign foo = 0 %} {% increment foo %} {% decrement foo %}"))
|
||||
end
|
||||
|
||||
def test_cycle_is_not_blank
|
||||
assert_template_result(" " * ((N + 1) / 2) + " ", wrap("{% cycle ' ', ' ' %}"))
|
||||
assert_template_result(" "*((N+1)/2)+" ", wrap("{% cycle ' ', ' ' %}"))
|
||||
end
|
||||
|
||||
def test_raw_is_not_blank
|
||||
assert_template_result(" " * (N + 1), wrap(" {% raw %} {% endraw %}"))
|
||||
assert_template_result(" "*(N+1), wrap(" {% raw %} {% endraw %}"))
|
||||
end
|
||||
|
||||
def test_include_is_blank
|
||||
Liquid::Template.file_system = BlankTestFileSystem.new
|
||||
assert_template_result "foobar" * (N + 1), wrap("{% include 'foobar' %}")
|
||||
assert_template_result " foobar " * (N + 1), wrap("{% include ' foobar ' %}")
|
||||
assert_template_result " " * (N + 1), wrap(" {% include ' ' %} ")
|
||||
assert_template_result "foobar"*(N+1), wrap("{% include 'foobar' %}")
|
||||
assert_template_result " foobar "*(N+1), wrap("{% include ' foobar ' %}")
|
||||
assert_template_result " "*(N+1), wrap(" {% include ' ' %} ")
|
||||
end
|
||||
|
||||
def test_case_is_blank
|
||||
assert_template_result("", wrap(" {% assign foo = 'bar' %} {% case foo %} {% when 'bar' %} {% when 'whatever' %} {% else %} {% endcase %} "))
|
||||
assert_template_result("", wrap(" {% assign foo = 'else' %} {% case foo %} {% when 'bar' %} {% when 'whatever' %} {% else %} {% endcase %} "))
|
||||
assert_template_result(" x " * (N + 1), wrap(" {% assign foo = 'else' %} {% case foo %} {% when 'bar' %} {% when 'whatever' %} {% else %} x {% endcase %} "))
|
||||
assert_template_result(" x "*(N+1), wrap(" {% assign foo = 'else' %} {% case foo %} {% when 'bar' %} {% when 'whatever' %} {% else %} x {% endcase %} "))
|
||||
end
|
||||
end
|
||||
|
||||
@@ -1,22 +1,12 @@
|
||||
require 'test_helper'
|
||||
|
||||
class CaptureTest < Minitest::Test
|
||||
class CaptureTest < Test::Unit::TestCase
|
||||
include Liquid
|
||||
|
||||
def test_captures_block_content_in_variable
|
||||
assert_template_result("test string", "{% capture 'var' %}test string{% endcapture %}{{var}}", {})
|
||||
end
|
||||
|
||||
def test_capture_with_hyphen_in_variable_name
|
||||
template_source = <<-END_TEMPLATE
|
||||
{% capture this-thing %}Print this-thing{% endcapture %}
|
||||
{{ this-thing }}
|
||||
END_TEMPLATE
|
||||
template = Template.parse(template_source)
|
||||
rendered = template.render!
|
||||
assert_equal "Print this-thing", rendered.strip
|
||||
end
|
||||
|
||||
def test_capture_to_variable_from_outer_scope_if_existing
|
||||
template_source = <<-END_TEMPLATE
|
||||
{% assign var = '' %}
|
||||
|
||||
@@ -1,6 +1,6 @@
|
||||
require 'test_helper'
|
||||
|
||||
class ContextTest < Minitest::Test
|
||||
class ContextTest < Test::Unit::TestCase
|
||||
include Liquid
|
||||
|
||||
def test_override_global_filter
|
||||
@@ -16,17 +16,18 @@ class ContextTest < Minitest::Test
|
||||
end
|
||||
end
|
||||
|
||||
with_global_filter(global) do
|
||||
assert_equal 'Global test', Template.parse("{{'test' | notice }}").render!
|
||||
assert_equal 'Local test', Template.parse("{{'test' | notice }}").render!({}, :filters => [local])
|
||||
end
|
||||
Template.register_filter(global)
|
||||
assert_equal 'Global test', Template.parse("{{'test' | notice }}").render!
|
||||
assert_equal 'Local test', Template.parse("{{'test' | notice }}").render!({}, :filters => [local])
|
||||
end
|
||||
|
||||
def test_has_key_will_not_add_an_error_for_missing_keys
|
||||
with_error_mode :strict do
|
||||
context = Context.new
|
||||
context.has_key?('unknown')
|
||||
assert_empty context.errors
|
||||
end
|
||||
Template.error_mode = :strict
|
||||
|
||||
context = Context.new
|
||||
|
||||
context.has_key?('unknown')
|
||||
|
||||
assert_empty context.errors
|
||||
end
|
||||
end
|
||||
|
||||
@@ -1,19 +0,0 @@
|
||||
require 'test_helper'
|
||||
|
||||
class DocumentTest < Minitest::Test
|
||||
include Liquid
|
||||
|
||||
def test_unexpected_outer_tag
|
||||
exc = assert_raises(SyntaxError) do
|
||||
Template.parse("{% else %}")
|
||||
end
|
||||
assert_equal exc.message, "Liquid syntax error: Unexpected outer 'else' tag"
|
||||
end
|
||||
|
||||
def test_unknown_tag
|
||||
exc = assert_raises(SyntaxError) do
|
||||
Template.parse("{% foo %}")
|
||||
end
|
||||
assert_equal exc.message, "Liquid syntax error: Unknown tag 'foo'"
|
||||
end
|
||||
end
|
||||
@@ -14,7 +14,7 @@ class ContextDrop < Liquid::Drop
|
||||
end
|
||||
|
||||
def before_method(method)
|
||||
@context[method]
|
||||
return @context[method]
|
||||
end
|
||||
end
|
||||
|
||||
@@ -32,7 +32,7 @@ class ProductDrop < Liquid::Drop
|
||||
|
||||
class CatchallDrop < Liquid::Drop
|
||||
def before_method(method)
|
||||
'method: ' << method.to_s
|
||||
return 'method: ' << method.to_s
|
||||
end
|
||||
end
|
||||
|
||||
@@ -48,15 +48,10 @@ class ProductDrop < Liquid::Drop
|
||||
ContextDrop.new
|
||||
end
|
||||
|
||||
def user_input
|
||||
"foo".taint
|
||||
end
|
||||
|
||||
protected
|
||||
|
||||
def callmenot
|
||||
"protected"
|
||||
end
|
||||
def callmenot
|
||||
"protected"
|
||||
end
|
||||
end
|
||||
|
||||
class EnumerableDrop < Liquid::Drop
|
||||
@@ -105,34 +100,12 @@ class RealEnumerableDrop < Liquid::Drop
|
||||
end
|
||||
end
|
||||
|
||||
class DropsTest < Minitest::Test
|
||||
class DropsTest < Test::Unit::TestCase
|
||||
include Liquid
|
||||
|
||||
def test_product_drop
|
||||
tpl = Liquid::Template.parse(' ')
|
||||
assert_equal ' ', tpl.render!('product' => ProductDrop.new)
|
||||
end
|
||||
|
||||
def test_rendering_raises_on_tainted_attr
|
||||
with_taint_mode(:error) do
|
||||
tpl = Liquid::Template.parse('{{ product.user_input }}')
|
||||
assert_raises TaintedError do
|
||||
tpl.render!('product' => ProductDrop.new)
|
||||
end
|
||||
end
|
||||
end
|
||||
|
||||
def test_rendering_warns_on_tainted_attr
|
||||
with_taint_mode(:warn) do
|
||||
tpl = Liquid::Template.parse('{{ product.user_input }}')
|
||||
tpl.render!('product' => ProductDrop.new)
|
||||
assert_match /tainted/, tpl.warnings.first
|
||||
end
|
||||
end
|
||||
|
||||
def test_rendering_doesnt_raise_on_escaped_tainted_attr
|
||||
with_taint_mode(:error) do
|
||||
tpl = Liquid::Template.parse('{{ product.user_input | escape }}')
|
||||
assert_nothing_raised do
|
||||
tpl = Liquid::Template.parse( ' ' )
|
||||
tpl.render!('product' => ProductDrop.new)
|
||||
end
|
||||
end
|
||||
@@ -152,37 +125,37 @@ class DropsTest < Minitest::Test
|
||||
end
|
||||
|
||||
def test_text_drop
|
||||
output = Liquid::Template.parse(' {{ product.texts.text }} ').render!('product' => ProductDrop.new)
|
||||
output = Liquid::Template.parse( ' {{ product.texts.text }} ' ).render!('product' => ProductDrop.new)
|
||||
assert_equal ' text1 ', output
|
||||
end
|
||||
|
||||
def test_unknown_method
|
||||
output = Liquid::Template.parse(' {{ product.catchall.unknown }} ').render!('product' => ProductDrop.new)
|
||||
output = Liquid::Template.parse( ' {{ product.catchall.unknown }} ' ).render!('product' => ProductDrop.new)
|
||||
assert_equal ' method: unknown ', output
|
||||
end
|
||||
|
||||
def test_integer_argument_drop
|
||||
output = Liquid::Template.parse(' {{ product.catchall[8] }} ').render!('product' => ProductDrop.new)
|
||||
output = Liquid::Template.parse( ' {{ product.catchall[8] }} ' ).render!('product' => ProductDrop.new)
|
||||
assert_equal ' method: 8 ', output
|
||||
end
|
||||
|
||||
def test_text_array_drop
|
||||
output = Liquid::Template.parse('{% for text in product.texts.array %} {{text}} {% endfor %}').render!('product' => ProductDrop.new)
|
||||
output = Liquid::Template.parse( '{% for text in product.texts.array %} {{text}} {% endfor %}' ).render!('product' => ProductDrop.new)
|
||||
assert_equal ' text1 text2 ', output
|
||||
end
|
||||
|
||||
def test_context_drop
|
||||
output = Liquid::Template.parse(' {{ context.bar }} ').render!('context' => ContextDrop.new, 'bar' => "carrot")
|
||||
output = Liquid::Template.parse( ' {{ context.bar }} ' ).render!('context' => ContextDrop.new, 'bar' => "carrot")
|
||||
assert_equal ' carrot ', output
|
||||
end
|
||||
|
||||
def test_nested_context_drop
|
||||
output = Liquid::Template.parse(' {{ product.context.foo }} ').render!('product' => ProductDrop.new, 'foo' => "monkey")
|
||||
output = Liquid::Template.parse( ' {{ product.context.foo }} ' ).render!('product' => ProductDrop.new, 'foo' => "monkey")
|
||||
assert_equal ' monkey ', output
|
||||
end
|
||||
|
||||
def test_protected
|
||||
output = Liquid::Template.parse(' {{ product.callmenot }} ').render!('product' => ProductDrop.new)
|
||||
output = Liquid::Template.parse( ' {{ product.callmenot }} ' ).render!('product' => ProductDrop.new)
|
||||
assert_equal ' ', output
|
||||
end
|
||||
|
||||
@@ -194,40 +167,40 @@ class DropsTest < Minitest::Test
|
||||
end
|
||||
|
||||
def test_scope
|
||||
assert_equal '1', Liquid::Template.parse('{{ context.scopes }}').render!('context' => ContextDrop.new)
|
||||
assert_equal '2', Liquid::Template.parse('{%for i in dummy%}{{ context.scopes }}{%endfor%}').render!('context' => ContextDrop.new, 'dummy' => [1])
|
||||
assert_equal '3', Liquid::Template.parse('{%for i in dummy%}{%for i in dummy%}{{ context.scopes }}{%endfor%}{%endfor%}').render!('context' => ContextDrop.new, 'dummy' => [1])
|
||||
assert_equal '1', Liquid::Template.parse( '{{ context.scopes }}' ).render!('context' => ContextDrop.new)
|
||||
assert_equal '2', Liquid::Template.parse( '{%for i in dummy%}{{ context.scopes }}{%endfor%}' ).render!('context' => ContextDrop.new, 'dummy' => [1])
|
||||
assert_equal '3', Liquid::Template.parse( '{%for i in dummy%}{%for i in dummy%}{{ context.scopes }}{%endfor%}{%endfor%}' ).render!('context' => ContextDrop.new, 'dummy' => [1])
|
||||
end
|
||||
|
||||
def test_scope_though_proc
|
||||
assert_equal '1', Liquid::Template.parse('{{ s }}').render!('context' => ContextDrop.new, 's' => proc{ |c| c['context.scopes'] })
|
||||
assert_equal '2', Liquid::Template.parse('{%for i in dummy%}{{ s }}{%endfor%}').render!('context' => ContextDrop.new, 's' => proc{ |c| c['context.scopes'] }, 'dummy' => [1])
|
||||
assert_equal '3', Liquid::Template.parse('{%for i in dummy%}{%for i in dummy%}{{ s }}{%endfor%}{%endfor%}').render!('context' => ContextDrop.new, 's' => proc{ |c| c['context.scopes'] }, 'dummy' => [1])
|
||||
assert_equal '1', Liquid::Template.parse( '{{ s }}' ).render!('context' => ContextDrop.new, 's' => Proc.new{|c| c['context.scopes'] })
|
||||
assert_equal '2', Liquid::Template.parse( '{%for i in dummy%}{{ s }}{%endfor%}' ).render!('context' => ContextDrop.new, 's' => Proc.new{|c| c['context.scopes'] }, 'dummy' => [1])
|
||||
assert_equal '3', Liquid::Template.parse( '{%for i in dummy%}{%for i in dummy%}{{ s }}{%endfor%}{%endfor%}' ).render!('context' => ContextDrop.new, 's' => Proc.new{|c| c['context.scopes'] }, 'dummy' => [1])
|
||||
end
|
||||
|
||||
def test_scope_with_assigns
|
||||
assert_equal 'variable', Liquid::Template.parse('{% assign a = "variable"%}{{a}}').render!('context' => ContextDrop.new)
|
||||
assert_equal 'variable', Liquid::Template.parse('{% assign a = "variable"%}{%for i in dummy%}{{a}}{%endfor%}').render!('context' => ContextDrop.new, 'dummy' => [1])
|
||||
assert_equal 'test', Liquid::Template.parse('{% assign header_gif = "test"%}{{header_gif}}').render!('context' => ContextDrop.new)
|
||||
assert_equal 'test', Liquid::Template.parse("{% assign header_gif = 'test'%}{{header_gif}}").render!('context' => ContextDrop.new)
|
||||
assert_equal 'variable', Liquid::Template.parse( '{% assign a = "variable"%}{{a}}' ).render!('context' => ContextDrop.new)
|
||||
assert_equal 'variable', Liquid::Template.parse( '{% assign a = "variable"%}{%for i in dummy%}{{a}}{%endfor%}' ).render!('context' => ContextDrop.new, 'dummy' => [1])
|
||||
assert_equal 'test', Liquid::Template.parse( '{% assign header_gif = "test"%}{{header_gif}}' ).render!('context' => ContextDrop.new)
|
||||
assert_equal 'test', Liquid::Template.parse( "{% assign header_gif = 'test'%}{{header_gif}}" ).render!('context' => ContextDrop.new)
|
||||
end
|
||||
|
||||
def test_scope_from_tags
|
||||
assert_equal '1', Liquid::Template.parse('{% for i in context.scopes_as_array %}{{i}}{% endfor %}').render!('context' => ContextDrop.new, 'dummy' => [1])
|
||||
assert_equal '12', Liquid::Template.parse('{%for a in dummy%}{% for i in context.scopes_as_array %}{{i}}{% endfor %}{% endfor %}').render!('context' => ContextDrop.new, 'dummy' => [1])
|
||||
assert_equal '123', Liquid::Template.parse('{%for a in dummy%}{%for a in dummy%}{% for i in context.scopes_as_array %}{{i}}{% endfor %}{% endfor %}{% endfor %}').render!('context' => ContextDrop.new, 'dummy' => [1])
|
||||
assert_equal '1', Liquid::Template.parse( '{% for i in context.scopes_as_array %}{{i}}{% endfor %}' ).render!('context' => ContextDrop.new, 'dummy' => [1])
|
||||
assert_equal '12', Liquid::Template.parse( '{%for a in dummy%}{% for i in context.scopes_as_array %}{{i}}{% endfor %}{% endfor %}' ).render!('context' => ContextDrop.new, 'dummy' => [1])
|
||||
assert_equal '123', Liquid::Template.parse( '{%for a in dummy%}{%for a in dummy%}{% for i in context.scopes_as_array %}{{i}}{% endfor %}{% endfor %}{% endfor %}' ).render!('context' => ContextDrop.new, 'dummy' => [1])
|
||||
end
|
||||
|
||||
def test_access_context_from_drop
|
||||
assert_equal '123', Liquid::Template.parse('{%for a in dummy%}{{ context.loop_pos }}{% endfor %}').render!('context' => ContextDrop.new, 'dummy' => [1, 2, 3])
|
||||
assert_equal '123', Liquid::Template.parse( '{%for a in dummy%}{{ context.loop_pos }}{% endfor %}' ).render!('context' => ContextDrop.new, 'dummy' => [1,2,3])
|
||||
end
|
||||
|
||||
def test_enumerable_drop
|
||||
assert_equal '123', Liquid::Template.parse('{% for c in collection %}{{c}}{% endfor %}').render!('collection' => EnumerableDrop.new)
|
||||
assert_equal '123', Liquid::Template.parse( '{% for c in collection %}{{c}}{% endfor %}').render!('collection' => EnumerableDrop.new)
|
||||
end
|
||||
|
||||
def test_enumerable_drop_size
|
||||
assert_equal '3', Liquid::Template.parse('{{collection.size}}').render!('collection' => EnumerableDrop.new)
|
||||
assert_equal '3', Liquid::Template.parse( '{{collection.size}}').render!('collection' => EnumerableDrop.new)
|
||||
end
|
||||
|
||||
def test_enumerable_drop_will_invoke_before_method_for_clashing_method_names
|
||||
|
||||
@@ -1,195 +1,110 @@
|
||||
require 'test_helper'
|
||||
|
||||
class ErrorHandlingTest < Minitest::Test
|
||||
include Liquid
|
||||
|
||||
def test_templates_parsed_with_line_numbers_renders_them_in_errors
|
||||
template = <<-LIQUID
|
||||
Hello,
|
||||
|
||||
{{ errors.standard_error }} will raise a standard error.
|
||||
|
||||
Bla bla test.
|
||||
|
||||
{{ errors.syntax_error }} will raise a syntax error.
|
||||
|
||||
This is an argument error: {{ errors.argument_error }}
|
||||
|
||||
Bla.
|
||||
LIQUID
|
||||
|
||||
expected = <<-TEXT
|
||||
Hello,
|
||||
|
||||
Liquid error (line 3): standard error will raise a standard error.
|
||||
|
||||
Bla bla test.
|
||||
|
||||
Liquid syntax error (line 7): syntax error will raise a syntax error.
|
||||
|
||||
This is an argument error: Liquid error (line 9): argument error
|
||||
|
||||
Bla.
|
||||
TEXT
|
||||
|
||||
output = Liquid::Template.parse(template, line_numbers: true).render('errors' => ErrorDrop.new)
|
||||
assert_equal expected, output
|
||||
class ErrorDrop < Liquid::Drop
|
||||
def standard_error
|
||||
raise Liquid::StandardError, 'standard error'
|
||||
end
|
||||
|
||||
def test_standard_error
|
||||
template = Liquid::Template.parse(' {{ errors.standard_error }} ')
|
||||
assert_equal ' Liquid error: standard error ', template.render('errors' => ErrorDrop.new)
|
||||
def argument_error
|
||||
raise Liquid::ArgumentError, 'argument error'
|
||||
end
|
||||
|
||||
assert_equal 1, template.errors.size
|
||||
assert_equal StandardError, template.errors.first.class
|
||||
def syntax_error
|
||||
raise Liquid::SyntaxError, 'syntax error'
|
||||
end
|
||||
|
||||
def exception
|
||||
raise Exception, 'exception'
|
||||
end
|
||||
|
||||
end
|
||||
|
||||
class ErrorHandlingTest < Test::Unit::TestCase
|
||||
include Liquid
|
||||
|
||||
def test_standard_error
|
||||
assert_nothing_raised do
|
||||
template = Liquid::Template.parse( ' {{ errors.standard_error }} ' )
|
||||
assert_equal ' Liquid error: standard error ', template.render('errors' => ErrorDrop.new)
|
||||
|
||||
assert_equal 1, template.errors.size
|
||||
assert_equal StandardError, template.errors.first.class
|
||||
end
|
||||
end
|
||||
|
||||
def test_syntax
|
||||
template = Liquid::Template.parse(' {{ errors.syntax_error }} ')
|
||||
assert_equal ' Liquid syntax error: syntax error ', template.render('errors' => ErrorDrop.new)
|
||||
|
||||
assert_equal 1, template.errors.size
|
||||
assert_equal SyntaxError, template.errors.first.class
|
||||
assert_nothing_raised do
|
||||
|
||||
template = Liquid::Template.parse( ' {{ errors.syntax_error }} ' )
|
||||
assert_equal ' Liquid syntax error: syntax error ', template.render('errors' => ErrorDrop.new)
|
||||
|
||||
assert_equal 1, template.errors.size
|
||||
assert_equal SyntaxError, template.errors.first.class
|
||||
|
||||
end
|
||||
end
|
||||
|
||||
def test_argument
|
||||
template = Liquid::Template.parse(' {{ errors.argument_error }} ')
|
||||
assert_equal ' Liquid error: argument error ', template.render('errors' => ErrorDrop.new)
|
||||
assert_nothing_raised do
|
||||
|
||||
assert_equal 1, template.errors.size
|
||||
assert_equal ArgumentError, template.errors.first.class
|
||||
template = Liquid::Template.parse( ' {{ errors.argument_error }} ' )
|
||||
assert_equal ' Liquid error: argument error ', template.render('errors' => ErrorDrop.new)
|
||||
|
||||
assert_equal 1, template.errors.size
|
||||
assert_equal ArgumentError, template.errors.first.class
|
||||
end
|
||||
end
|
||||
|
||||
def test_missing_endtag_parse_time_error
|
||||
assert_raises(Liquid::SyntaxError) do
|
||||
assert_raise(Liquid::SyntaxError) do
|
||||
Liquid::Template.parse(' {% for a in b %} ... ')
|
||||
end
|
||||
end
|
||||
|
||||
def test_unrecognized_operator
|
||||
with_error_mode(:strict) do
|
||||
assert_raises(SyntaxError) do
|
||||
assert_raise(SyntaxError) do
|
||||
Liquid::Template.parse(' {% if 1 =! 2 %}ok{% endif %} ')
|
||||
end
|
||||
end
|
||||
end
|
||||
|
||||
|
||||
def test_lax_unrecognized_operator
|
||||
template = Liquid::Template.parse(' {% if 1 =! 2 %}ok{% endif %} ', :error_mode => :lax)
|
||||
assert_equal ' Liquid error: Unknown operator =! ', template.render
|
||||
assert_equal 1, template.errors.size
|
||||
assert_equal Liquid::ArgumentError, template.errors.first.class
|
||||
end
|
||||
|
||||
def test_with_line_numbers_adds_numbers_to_parser_errors
|
||||
err = assert_raises(SyntaxError) do
|
||||
template = Liquid::Template.parse(%q(
|
||||
foobar
|
||||
|
||||
{% "cat" | foobar %}
|
||||
|
||||
bla
|
||||
),
|
||||
:line_numbers => true
|
||||
)
|
||||
assert_nothing_raised do
|
||||
template = Liquid::Template.parse(' {% if 1 =! 2 %}ok{% endif %} ', :error_mode => :lax)
|
||||
assert_equal ' Liquid error: Unknown operator =! ', template.render
|
||||
assert_equal 1, template.errors.size
|
||||
assert_equal Liquid::ArgumentError, template.errors.first.class
|
||||
end
|
||||
|
||||
assert_match /Liquid syntax error \(line 4\)/, err.message
|
||||
end
|
||||
|
||||
def test_parsing_warn_with_line_numbers_adds_numbers_to_lexer_errors
|
||||
template = Liquid::Template.parse('
|
||||
foobar
|
||||
|
||||
{% if 1 =! 2 %}ok{% endif %}
|
||||
|
||||
bla
|
||||
',
|
||||
:error_mode => :warn,
|
||||
:line_numbers => true
|
||||
)
|
||||
|
||||
assert_equal ['Liquid syntax error (line 4): Unexpected character = in "1 =! 2"'],
|
||||
template.warnings.map(&:message)
|
||||
end
|
||||
|
||||
def test_parsing_strict_with_line_numbers_adds_numbers_to_lexer_errors
|
||||
err = assert_raises(SyntaxError) do
|
||||
Liquid::Template.parse('
|
||||
foobar
|
||||
|
||||
{% if 1 =! 2 %}ok{% endif %}
|
||||
|
||||
bla
|
||||
',
|
||||
:error_mode => :strict,
|
||||
:line_numbers => true
|
||||
)
|
||||
end
|
||||
|
||||
assert_equal 'Liquid syntax error (line 4): Unexpected character = in "1 =! 2"', err.message
|
||||
end
|
||||
|
||||
def test_syntax_errors_in_nested_blocks_have_correct_line_number
|
||||
err = assert_raises(SyntaxError) do
|
||||
Liquid::Template.parse('
|
||||
foobar
|
||||
|
||||
{% if 1 != 2 %}
|
||||
{% foo %}
|
||||
{% endif %}
|
||||
|
||||
bla
|
||||
',
|
||||
:line_numbers => true
|
||||
)
|
||||
end
|
||||
|
||||
assert_equal "Liquid syntax error (line 5): Unknown tag 'foo'", err.message
|
||||
end
|
||||
|
||||
def test_strict_error_messages
|
||||
err = assert_raises(SyntaxError) do
|
||||
err = assert_raise(SyntaxError) do
|
||||
Liquid::Template.parse(' {% if 1 =! 2 %}ok{% endif %} ', :error_mode => :strict)
|
||||
end
|
||||
assert_equal 'Liquid syntax error: Unexpected character = in "1 =! 2"', err.message
|
||||
assert_equal 'Unexpected character = in "1 =! 2"', err.message
|
||||
|
||||
err = assert_raises(SyntaxError) do
|
||||
err = assert_raise(SyntaxError) do
|
||||
Liquid::Template.parse('{{%%%}}', :error_mode => :strict)
|
||||
end
|
||||
assert_equal 'Liquid syntax error: Unexpected character % in "{{%%%}}"', err.message
|
||||
assert_equal 'Unexpected character % in "{{%%%}}"', err.message
|
||||
end
|
||||
|
||||
def test_warnings
|
||||
template = Liquid::Template.parse('{% if ~~~ %}{{%%%}}{% else %}{{ hello. }}{% endif %}', :error_mode => :warn)
|
||||
assert_equal 3, template.warnings.size
|
||||
assert_equal 'Unexpected character ~ in "~~~"', template.warnings[0].to_s(false)
|
||||
assert_equal 'Unexpected character % in "{{%%%}}"', template.warnings[1].to_s(false)
|
||||
assert_equal 'Expected id but found end_of_string in "{{ hello. }}"', template.warnings[2].to_s(false)
|
||||
assert_equal 'Unexpected character ~ in "~~~"', template.warnings[0].message
|
||||
assert_equal 'Unexpected character % in "{{%%%}}"', template.warnings[1].message
|
||||
assert_equal 'Expected id but found end_of_string in "{{ hello. }}"', template.warnings[2].message
|
||||
assert_equal '', template.render
|
||||
end
|
||||
|
||||
def test_warning_line_numbers
|
||||
template = Liquid::Template.parse("{% if ~~~ %}\n{{%%%}}{% else %}\n{{ hello. }}{% endif %}", :error_mode => :warn, :line_numbers => true)
|
||||
assert_equal 'Liquid syntax error (line 1): Unexpected character ~ in "~~~"', template.warnings[0].message
|
||||
assert_equal 'Liquid syntax error (line 2): Unexpected character % in "{{%%%}}"', template.warnings[1].message
|
||||
assert_equal 'Liquid syntax error (line 3): Expected id but found end_of_string in "{{ hello. }}"', template.warnings[2].message
|
||||
assert_equal 3, template.warnings.size
|
||||
assert_equal [1, 2, 3], template.warnings.map(&:line_number)
|
||||
end
|
||||
|
||||
# Liquid should not catch Exceptions that are not subclasses of StandardError, like Interrupt and NoMemoryError
|
||||
def test_exceptions_propagate
|
||||
assert_raises Exception do
|
||||
template = Liquid::Template.parse('{{ errors.exception }}')
|
||||
assert_raise Exception do
|
||||
template = Liquid::Template.parse( ' {{ errors.exception }} ' )
|
||||
template.render('errors' => ErrorDrop.new)
|
||||
end
|
||||
end
|
||||
|
||||
def test_disabling_error_rendering
|
||||
template = Liquid::Template.parse('This is an argument error: {{ errors.argument_error }}')
|
||||
template.render_errors = false
|
||||
assert_equal 'This is an argument error: ', template.render('errors' => ErrorDrop.new)
|
||||
assert_equal [ArgumentError], template.errors.map(&:class)
|
||||
end
|
||||
end
|
||||
end # ErrorHandlingTest
|
||||
|
||||
@@ -17,26 +17,14 @@ module CanadianMoneyFilter
|
||||
end
|
||||
|
||||
module SubstituteFilter
|
||||
def substitute(input, params = {})
|
||||
def substitute(input, params={})
|
||||
input.gsub(/%\{(\w+)\}/) { |match| params[$1] }
|
||||
end
|
||||
end
|
||||
|
||||
module ErrorFilter
|
||||
def standard_error(input)
|
||||
raise ::StandardError, 'standard error'
|
||||
end
|
||||
end
|
||||
|
||||
class FiltersTest < Minitest::Test
|
||||
class FiltersTest < Test::Unit::TestCase
|
||||
include Liquid
|
||||
|
||||
module OverrideObjectMethodFilter
|
||||
def tap(input)
|
||||
"tap overridden"
|
||||
end
|
||||
end
|
||||
|
||||
def setup
|
||||
@context = Context.new
|
||||
end
|
||||
@@ -70,44 +58,21 @@ class FiltersTest < Minitest::Test
|
||||
end
|
||||
|
||||
def test_join
|
||||
@context['var'] = [1, 2, 3, 4]
|
||||
@context['var'] = [1,2,3,4]
|
||||
|
||||
assert_equal "1 2 3 4", Variable.new("var | join").render(@context)
|
||||
end
|
||||
|
||||
def test_sort
|
||||
@context['value'] = 3
|
||||
@context['numbers'] = [2, 1, 4, 3]
|
||||
@context['numbers'] = [2,1,4,3]
|
||||
@context['words'] = ['expected', 'as', 'alphabetic']
|
||||
@context['arrays'] = ['flower', 'are']
|
||||
@context['case_sensitive'] = ['sensitive', 'Expected', 'case']
|
||||
|
||||
assert_equal [1, 2, 3, 4], Variable.new("numbers | sort").render(@context)
|
||||
assert_equal [1,2,3,4], Variable.new("numbers | sort").render(@context)
|
||||
assert_equal ['alphabetic', 'as', 'expected'], Variable.new("words | sort").render(@context)
|
||||
assert_equal [3], Variable.new("value | sort").render(@context)
|
||||
assert_equal ['are', 'flower'], Variable.new("arrays | sort").render(@context)
|
||||
assert_equal ['Expected', 'case', 'sensitive'], Variable.new("case_sensitive | sort").render(@context)
|
||||
end
|
||||
|
||||
def test_sort_natural
|
||||
@context['words'] = ['case', 'Assert', 'Insensitive']
|
||||
@context['hashes'] = [{ 'a' => 'A' }, { 'a' => 'b' }, { 'a' => 'C' }]
|
||||
@context['objects'] = [TestObject.new('A'), TestObject.new('b'), TestObject.new('C')]
|
||||
|
||||
# Test strings
|
||||
assert_equal ['Assert', 'case', 'Insensitive'], Variable.new("words | sort_natural").render(@context)
|
||||
|
||||
# Test hashes
|
||||
sorted = Variable.new("hashes | sort_natural: 'a'").render(@context)
|
||||
assert_equal sorted[0]['a'], 'A'
|
||||
assert_equal sorted[1]['a'], 'b'
|
||||
assert_equal sorted[2]['a'], 'C'
|
||||
|
||||
# Test objects
|
||||
sorted = Variable.new("objects | sort_natural: 'a'").render(@context)
|
||||
assert_equal sorted[0].a, 'A'
|
||||
assert_equal sorted[1].a, 'b'
|
||||
assert_equal sorted[2].a, 'C'
|
||||
end
|
||||
|
||||
def test_strip_html
|
||||
@@ -137,45 +102,24 @@ class FiltersTest < Minitest::Test
|
||||
def test_filter_with_keyword_arguments
|
||||
@context['surname'] = 'john'
|
||||
@context.add_filters(SubstituteFilter)
|
||||
output = Variable.new(%( 'hello %{first_name}, %{last_name}' | substitute: first_name: surname, last_name: 'doe' )).render(@context)
|
||||
output = Variable.new(%! 'hello %{first_name}, %{last_name}' | substitute: first_name: surname, last_name: 'doe' !).render(@context)
|
||||
assert_equal 'hello john, doe', output
|
||||
end
|
||||
|
||||
def test_override_object_method_in_filter
|
||||
assert_equal "tap overridden", Template.parse("{{var | tap}}").render!({ 'var' => 1000 }, :filters => [OverrideObjectMethodFilter])
|
||||
|
||||
# tap still treated as a non-existent filter
|
||||
assert_equal "1000", Template.parse("{{var | tap}}").render!({ 'var' => 1000 })
|
||||
end
|
||||
end
|
||||
|
||||
class FiltersInTemplate < Minitest::Test
|
||||
class FiltersInTemplate < Test::Unit::TestCase
|
||||
include Liquid
|
||||
|
||||
def test_local_global
|
||||
with_global_filter(MoneyFilter) do
|
||||
assert_equal " 1000$ ", Template.parse("{{1000 | money}}").render!(nil, nil)
|
||||
assert_equal " 1000$ CAD ", Template.parse("{{1000 | money}}").render!(nil, :filters => CanadianMoneyFilter)
|
||||
assert_equal " 1000$ CAD ", Template.parse("{{1000 | money}}").render!(nil, :filters => [CanadianMoneyFilter])
|
||||
end
|
||||
Template.register_filter(MoneyFilter)
|
||||
|
||||
assert_equal " 1000$ ", Template.parse("{{1000 | money}}").render!(nil, nil)
|
||||
assert_equal " 1000$ CAD ", Template.parse("{{1000 | money}}").render!(nil, :filters => CanadianMoneyFilter)
|
||||
assert_equal " 1000$ CAD ", Template.parse("{{1000 | money}}").render!(nil, :filters => [CanadianMoneyFilter])
|
||||
end
|
||||
|
||||
def test_local_filter_with_deprecated_syntax
|
||||
assert_equal " 1000$ CAD ", Template.parse("{{1000 | money}}").render!(nil, CanadianMoneyFilter)
|
||||
assert_equal " 1000$ CAD ", Template.parse("{{1000 | money}}").render!(nil, [CanadianMoneyFilter])
|
||||
end
|
||||
|
||||
def test_filter_error
|
||||
context = Context.new
|
||||
context.add_filters(ErrorFilter)
|
||||
assert_equal "Liquid error: standard error", Template.parse("{{'var' | standard_error}}").render(context)
|
||||
assert_equal [Liquid::FilterError], context.errors.map(&:class)
|
||||
end
|
||||
end
|
||||
|
||||
class TestObject
|
||||
attr_accessor :a
|
||||
def initialize(a)
|
||||
@a = a
|
||||
end
|
||||
end
|
||||
end # FiltersTest
|
||||
|
||||
@@ -12,12 +12,14 @@ module CanadianMoneyFilter
|
||||
end
|
||||
end
|
||||
|
||||
class HashOrderingTest < Minitest::Test
|
||||
class HashOrderingTest < Test::Unit::TestCase
|
||||
include Liquid
|
||||
|
||||
def test_global_register_order
|
||||
with_global_filter(MoneyFilter, CanadianMoneyFilter) do
|
||||
assert_equal " 1000$ CAD ", Template.parse("{{1000 | money}}").render(nil, nil)
|
||||
end
|
||||
end
|
||||
def test_global_register_order
|
||||
Template.register_filter(MoneyFilter)
|
||||
Template.register_filter(CanadianMoneyFilter)
|
||||
|
||||
assert_equal " 1000$ CAD ", Template.parse("{{1000 | money}}").render(nil, nil)
|
||||
end
|
||||
|
||||
end
|
||||
|
||||
@@ -14,7 +14,7 @@ module FunnyFilter
|
||||
end
|
||||
|
||||
def add_tag(input, tag = "p", id = "foo")
|
||||
%(<#{tag} id="#{id}">#{input}</#{tag}>)
|
||||
%|<#{tag} id="#{id}">#{input}</#{tag}>|
|
||||
end
|
||||
|
||||
def paragraph(input)
|
||||
@@ -22,44 +22,45 @@ module FunnyFilter
|
||||
end
|
||||
|
||||
def link_to(name, url)
|
||||
%(<a href="#{url}">#{name}</a>)
|
||||
%|<a href="#{url}">#{name}</a>|
|
||||
end
|
||||
|
||||
end
|
||||
|
||||
class OutputTest < Minitest::Test
|
||||
class OutputTest < Test::Unit::TestCase
|
||||
include Liquid
|
||||
|
||||
def setup
|
||||
@assigns = {
|
||||
'best_cars' => 'bmw',
|
||||
'car' => { 'bmw' => 'good', 'gm' => 'bad' }
|
||||
}
|
||||
'car' => {'bmw' => 'good', 'gm' => 'bad'}
|
||||
}
|
||||
end
|
||||
|
||||
def test_variable
|
||||
text = %( {{best_cars}} )
|
||||
text = %| {{best_cars}} |
|
||||
|
||||
expected = %( bmw )
|
||||
expected = %| bmw |
|
||||
assert_equal expected, Template.parse(text).render!(@assigns)
|
||||
end
|
||||
|
||||
def test_variable_traversing
|
||||
text = %( {{car.bmw}} {{car.gm}} {{car.bmw}} )
|
||||
text = %| {{car.bmw}} {{car.gm}} {{car.bmw}} |
|
||||
|
||||
expected = %( good bad good )
|
||||
expected = %| good bad good |
|
||||
assert_equal expected, Template.parse(text).render!(@assigns)
|
||||
end
|
||||
|
||||
def test_variable_piping
|
||||
text = %( {{ car.gm | make_funny }} )
|
||||
expected = %( LOL )
|
||||
expected = %| LOL |
|
||||
|
||||
assert_equal expected, Template.parse(text).render!(@assigns, :filters => [FunnyFilter])
|
||||
end
|
||||
|
||||
def test_variable_piping_with_input
|
||||
text = %( {{ car.gm | cite_funny }} )
|
||||
expected = %( LOL: bad )
|
||||
expected = %| LOL: bad |
|
||||
|
||||
assert_equal expected, Template.parse(text).render!(@assigns, :filters => [FunnyFilter])
|
||||
end
|
||||
@@ -72,7 +73,7 @@ class OutputTest < Minitest::Test
|
||||
end
|
||||
|
||||
def test_variable_piping_with_no_args
|
||||
text = %( {{ car.gm | add_smiley }} )
|
||||
text = %! {{ car.gm | add_smiley }} !
|
||||
expected = %| bad :-) |
|
||||
|
||||
assert_equal expected, Template.parse(text).render!(@assigns, :filters => [FunnyFilter])
|
||||
@@ -86,29 +87,29 @@ class OutputTest < Minitest::Test
|
||||
end
|
||||
|
||||
def test_variable_piping_with_multiple_args
|
||||
text = %( {{ car.gm | add_tag : 'span', 'bar'}} )
|
||||
expected = %( <span id="bar">bad</span> )
|
||||
text = %! {{ car.gm | add_tag : 'span', 'bar'}} !
|
||||
expected = %| <span id="bar">bad</span> |
|
||||
|
||||
assert_equal expected, Template.parse(text).render!(@assigns, :filters => [FunnyFilter])
|
||||
end
|
||||
|
||||
def test_variable_piping_with_variable_args
|
||||
text = %( {{ car.gm | add_tag : 'span', car.bmw}} )
|
||||
expected = %( <span id="good">bad</span> )
|
||||
text = %! {{ car.gm | add_tag : 'span', car.bmw}} !
|
||||
expected = %| <span id="good">bad</span> |
|
||||
|
||||
assert_equal expected, Template.parse(text).render!(@assigns, :filters => [FunnyFilter])
|
||||
end
|
||||
|
||||
def test_multiple_pipings
|
||||
text = %( {{ best_cars | cite_funny | paragraph }} )
|
||||
expected = %( <p>LOL: bmw</p> )
|
||||
expected = %| <p>LOL: bmw</p> |
|
||||
|
||||
assert_equal expected, Template.parse(text).render!(@assigns, :filters => [FunnyFilter])
|
||||
end
|
||||
|
||||
def test_link_to
|
||||
text = %( {{ 'Typo' | link_to: 'http://typo.leetsoft.com' }} )
|
||||
expected = %( <a href="http://typo.leetsoft.com">Typo</a> )
|
||||
expected = %| <a href="http://typo.leetsoft.com">Typo</a> |
|
||||
|
||||
assert_equal expected, Template.parse(text).render!(@assigns, :filters => [FunnyFilter])
|
||||
end
|
||||
|
||||
@@ -1,6 +1,6 @@
|
||||
require 'test_helper'
|
||||
|
||||
class ParsingQuirksTest < Minitest::Test
|
||||
class ParsingQuirksTest < Test::Unit::TestCase
|
||||
include Liquid
|
||||
|
||||
def test_parsing_css
|
||||
@@ -9,39 +9,38 @@ class ParsingQuirksTest < Minitest::Test
|
||||
end
|
||||
|
||||
def test_raise_on_single_close_bracet
|
||||
assert_raises(SyntaxError) do
|
||||
assert_raise(SyntaxError) do
|
||||
Template.parse("text {{method} oh nos!")
|
||||
end
|
||||
end
|
||||
|
||||
def test_raise_on_label_and_no_close_bracets
|
||||
assert_raises(SyntaxError) do
|
||||
assert_raise(SyntaxError) do
|
||||
Template.parse("TEST {{ ")
|
||||
end
|
||||
end
|
||||
|
||||
def test_raise_on_label_and_no_close_bracets_percent
|
||||
assert_raises(SyntaxError) do
|
||||
assert_raise(SyntaxError) do
|
||||
Template.parse("TEST {% ")
|
||||
end
|
||||
end
|
||||
|
||||
def test_error_on_empty_filter
|
||||
assert Template.parse("{{test}}")
|
||||
|
||||
with_error_mode(:lax) do
|
||||
assert Template.parse("{{|test}}")
|
||||
assert_nothing_raised do
|
||||
Template.parse("{{test}}")
|
||||
Template.parse("{{|test}}")
|
||||
end
|
||||
|
||||
with_error_mode(:strict) do
|
||||
assert_raises(SyntaxError) { Template.parse("{{|test}}") }
|
||||
assert_raises(SyntaxError) { Template.parse("{{test |a|b|}}") }
|
||||
assert_raise(SyntaxError) do
|
||||
Template.parse("{{test |a|b|}}")
|
||||
end
|
||||
end
|
||||
end
|
||||
|
||||
def test_meaningless_parens_error
|
||||
with_error_mode(:strict) do
|
||||
assert_raises(SyntaxError) do
|
||||
assert_raise(SyntaxError) do
|
||||
markup = "a == 'foo' or (b == 'bar' and c == 'baz') or false"
|
||||
Template.parse("{% if #{markup} %} YES {% endif %}")
|
||||
end
|
||||
@@ -50,11 +49,11 @@ class ParsingQuirksTest < Minitest::Test
|
||||
|
||||
def test_unexpected_characters_syntax_error
|
||||
with_error_mode(:strict) do
|
||||
assert_raises(SyntaxError) do
|
||||
assert_raise(SyntaxError) do
|
||||
markup = "true && false"
|
||||
Template.parse("{% if #{markup} %} YES {% endif %}")
|
||||
end
|
||||
assert_raises(SyntaxError) do
|
||||
assert_raise(SyntaxError) do
|
||||
markup = "false || true"
|
||||
Template.parse("{% if #{markup} %} YES {% endif %}")
|
||||
end
|
||||
@@ -62,58 +61,34 @@ class ParsingQuirksTest < Minitest::Test
|
||||
end
|
||||
|
||||
def test_no_error_on_lax_empty_filter
|
||||
assert Template.parse("{{test |a|b|}}", :error_mode => :lax)
|
||||
assert Template.parse("{{test}}", :error_mode => :lax)
|
||||
assert Template.parse("{{|test|}}", :error_mode => :lax)
|
||||
assert_nothing_raised do
|
||||
Template.parse("{{test |a|b|}}", :error_mode => :lax)
|
||||
Template.parse("{{test}}", :error_mode => :lax)
|
||||
Template.parse("{{|test|}}", :error_mode => :lax)
|
||||
end
|
||||
end
|
||||
|
||||
def test_meaningless_parens_lax
|
||||
with_error_mode(:lax) do
|
||||
assigns = { 'b' => 'bar', 'c' => 'baz' }
|
||||
assigns = {'b' => 'bar', 'c' => 'baz'}
|
||||
markup = "a == 'foo' or (b == 'bar' and c == 'baz') or false"
|
||||
assert_template_result(' YES ', "{% if #{markup} %} YES {% endif %}", assigns)
|
||||
assert_template_result(' YES ',"{% if #{markup} %} YES {% endif %}", assigns)
|
||||
end
|
||||
end
|
||||
|
||||
def test_unexpected_characters_silently_eat_logic_lax
|
||||
with_error_mode(:lax) do
|
||||
markup = "true && false"
|
||||
assert_template_result(' YES ', "{% if #{markup} %} YES {% endif %}")
|
||||
assert_template_result(' YES ',"{% if #{markup} %} YES {% endif %}")
|
||||
markup = "false || true"
|
||||
assert_template_result('', "{% if #{markup} %} YES {% endif %}")
|
||||
assert_template_result('',"{% if #{markup} %} YES {% endif %}")
|
||||
end
|
||||
end
|
||||
|
||||
def test_raise_on_invalid_tag_delimiter
|
||||
assert_raises(Liquid::SyntaxError) do
|
||||
assert_raise(Liquid::SyntaxError) do
|
||||
Template.new.parse('{% end %}')
|
||||
end
|
||||
end
|
||||
|
||||
def test_unanchored_filter_arguments
|
||||
with_error_mode(:lax) do
|
||||
assert_template_result('hi', "{{ 'hi there' | split$$$:' ' | first }}")
|
||||
|
||||
assert_template_result('x', "{{ 'X' | downcase) }}")
|
||||
|
||||
# After the messed up quotes a filter without parameters (reverse) should work
|
||||
# but one with parameters (remove) shouldn't be detected.
|
||||
assert_template_result('here', "{{ 'hi there' | split:\"t\"\" | reverse | first}}")
|
||||
assert_template_result('hi ', "{{ 'hi there' | split:\"t\"\" | remove:\"i\" | first}}")
|
||||
end
|
||||
end
|
||||
|
||||
def test_invalid_variables_work
|
||||
with_error_mode(:lax) do
|
||||
assert_template_result('bar', "{% assign 123foo = 'bar' %}{{ 123foo }}")
|
||||
assert_template_result('123', "{% assign 123 = 'bar' %}{{ 123 }}")
|
||||
end
|
||||
end
|
||||
|
||||
def test_extra_dots_in_ranges
|
||||
with_error_mode(:lax) do
|
||||
assert_template_result('12345', "{% for i in (1...5) %}{{ i }}{% endfor %}")
|
||||
end
|
||||
end
|
||||
|
||||
end # ParsingQuirksTest
|
||||
|
||||
@@ -1,154 +0,0 @@
|
||||
require 'test_helper'
|
||||
|
||||
class RenderProfilingTest < Minitest::Test
|
||||
include Liquid
|
||||
|
||||
class ProfilingFileSystem
|
||||
def read_template_file(template_path)
|
||||
"Rendering template {% assign template_name = '#{template_path}'%}\n{{ template_name }}"
|
||||
end
|
||||
end
|
||||
|
||||
def setup
|
||||
Liquid::Template.file_system = ProfilingFileSystem.new
|
||||
end
|
||||
|
||||
def test_template_allows_flagging_profiling
|
||||
t = Template.parse("{{ 'a string' | upcase }}")
|
||||
t.render!
|
||||
|
||||
assert_nil t.profiler
|
||||
end
|
||||
|
||||
def test_parse_makes_available_simple_profiling
|
||||
t = Template.parse("{{ 'a string' | upcase }}", :profile => true)
|
||||
t.render!
|
||||
|
||||
assert_equal 1, t.profiler.length
|
||||
|
||||
node = t.profiler[0]
|
||||
assert_equal " 'a string' | upcase ", node.code
|
||||
end
|
||||
|
||||
def test_render_ignores_raw_strings_when_profiling
|
||||
t = Template.parse("This is raw string\nstuff\nNewline", :profile => true)
|
||||
t.render!
|
||||
|
||||
assert_equal 0, t.profiler.length
|
||||
end
|
||||
|
||||
def test_profiling_includes_line_numbers_of_liquid_nodes
|
||||
t = Template.parse("{{ 'a string' | upcase }}\n{% increment test %}", :profile => true)
|
||||
t.render!
|
||||
assert_equal 2, t.profiler.length
|
||||
|
||||
# {{ 'a string' | upcase }}
|
||||
assert_equal 1, t.profiler[0].line_number
|
||||
# {{ increment test }}
|
||||
assert_equal 2, t.profiler[1].line_number
|
||||
end
|
||||
|
||||
def test_profiling_includes_line_numbers_of_included_partials
|
||||
t = Template.parse("{% include 'a_template' %}", :profile => true)
|
||||
t.render!
|
||||
|
||||
included_children = t.profiler[0].children
|
||||
|
||||
# {% assign template_name = 'a_template' %}
|
||||
assert_equal 1, included_children[0].line_number
|
||||
# {{ template_name }}
|
||||
assert_equal 2, included_children[1].line_number
|
||||
end
|
||||
|
||||
def test_profiling_times_the_rendering_of_tokens
|
||||
t = Template.parse("{% include 'a_template' %}", :profile => true)
|
||||
t.render!
|
||||
|
||||
node = t.profiler[0]
|
||||
refute_nil node.render_time
|
||||
end
|
||||
|
||||
def test_profiling_times_the_entire_render
|
||||
t = Template.parse("{% include 'a_template' %}", :profile => true)
|
||||
t.render!
|
||||
|
||||
assert t.profiler.total_render_time >= 0, "Total render time was not calculated"
|
||||
end
|
||||
|
||||
def test_profiling_uses_include_to_mark_children
|
||||
t = Template.parse("{{ 'a string' | upcase }}\n{% include 'a_template' %}", :profile => true)
|
||||
t.render!
|
||||
|
||||
include_node = t.profiler[1]
|
||||
assert_equal 2, include_node.children.length
|
||||
end
|
||||
|
||||
def test_profiling_marks_children_with_the_name_of_included_partial
|
||||
t = Template.parse("{{ 'a string' | upcase }}\n{% include 'a_template' %}", :profile => true)
|
||||
t.render!
|
||||
|
||||
include_node = t.profiler[1]
|
||||
include_node.children.each do |child|
|
||||
assert_equal "a_template", child.partial
|
||||
end
|
||||
end
|
||||
|
||||
def test_profiling_supports_multiple_templates
|
||||
t = Template.parse("{{ 'a string' | upcase }}\n{% include 'a_template' %}\n{% include 'b_template' %}", :profile => true)
|
||||
t.render!
|
||||
|
||||
a_template = t.profiler[1]
|
||||
a_template.children.each do |child|
|
||||
assert_equal "a_template", child.partial
|
||||
end
|
||||
|
||||
b_template = t.profiler[2]
|
||||
b_template.children.each do |child|
|
||||
assert_equal "b_template", child.partial
|
||||
end
|
||||
end
|
||||
|
||||
def test_profiling_supports_rendering_the_same_partial_multiple_times
|
||||
t = Template.parse("{{ 'a string' | upcase }}\n{% include 'a_template' %}\n{% include 'a_template' %}", :profile => true)
|
||||
t.render!
|
||||
|
||||
a_template1 = t.profiler[1]
|
||||
a_template1.children.each do |child|
|
||||
assert_equal "a_template", child.partial
|
||||
end
|
||||
|
||||
a_template2 = t.profiler[2]
|
||||
a_template2.children.each do |child|
|
||||
assert_equal "a_template", child.partial
|
||||
end
|
||||
end
|
||||
|
||||
def test_can_iterate_over_each_profiling_entry
|
||||
t = Template.parse("{{ 'a string' | upcase }}\n{% increment test %}", :profile => true)
|
||||
t.render!
|
||||
|
||||
timing_count = 0
|
||||
t.profiler.each do |timing|
|
||||
timing_count += 1
|
||||
end
|
||||
|
||||
assert_equal 2, timing_count
|
||||
end
|
||||
|
||||
def test_profiling_marks_children_of_if_blocks
|
||||
t = Template.parse("{% if true %} {% increment test %} {{ test }} {% endif %}", :profile => true)
|
||||
t.render!
|
||||
|
||||
assert_equal 1, t.profiler.length
|
||||
assert_equal 2, t.profiler[0].children.length
|
||||
end
|
||||
|
||||
def test_profiling_marks_children_of_for_blocks
|
||||
t = Template.parse("{% for item in collection %} {{ item }} {% endfor %}", :profile => true)
|
||||
t.render!({ "collection" => ["one", "two"] })
|
||||
|
||||
assert_equal 1, t.profiler.length
|
||||
# Will profile each invocation of the for block
|
||||
assert_equal 2, t.profiler[0].children.length
|
||||
end
|
||||
end
|
||||
@@ -6,33 +6,35 @@ module SecurityFilter
|
||||
end
|
||||
end
|
||||
|
||||
class SecurityTest < Minitest::Test
|
||||
class SecurityTest < Test::Unit::TestCase
|
||||
include Liquid
|
||||
|
||||
def test_no_instance_eval
|
||||
text = %( {{ '1+1' | instance_eval }} )
|
||||
expected = %( 1+1 )
|
||||
expected = %| 1+1 |
|
||||
|
||||
assert_equal expected, Template.parse(text).render!(@assigns)
|
||||
end
|
||||
|
||||
def test_no_existing_instance_eval
|
||||
text = %( {{ '1+1' | __instance_eval__ }} )
|
||||
expected = %( 1+1 )
|
||||
expected = %| 1+1 |
|
||||
|
||||
assert_equal expected, Template.parse(text).render!(@assigns)
|
||||
end
|
||||
|
||||
|
||||
def test_no_instance_eval_after_mixing_in_new_filter
|
||||
text = %( {{ '1+1' | instance_eval }} )
|
||||
expected = %( 1+1 )
|
||||
expected = %| 1+1 |
|
||||
|
||||
assert_equal expected, Template.parse(text).render!(@assigns)
|
||||
end
|
||||
|
||||
|
||||
def test_no_instance_eval_later_in_chain
|
||||
text = %( {{ '1+1' | add_one | instance_eval }} )
|
||||
expected = %( 1+1 + 1 )
|
||||
expected = %| 1+1 + 1 |
|
||||
|
||||
assert_equal expected, Template.parse(text).render!(@assigns, :filters => SecurityFilter)
|
||||
end
|
||||
|
||||
@@ -41,7 +41,7 @@ class TestEnumerable < Liquid::Drop
|
||||
end
|
||||
end
|
||||
|
||||
class StandardFiltersTest < Minitest::Test
|
||||
class StandardFiltersTest < Test::Unit::TestCase
|
||||
include Liquid
|
||||
|
||||
def setup
|
||||
@@ -49,7 +49,7 @@ class StandardFiltersTest < Minitest::Test
|
||||
end
|
||||
|
||||
def test_size
|
||||
assert_equal 3, @filters.size([1, 2, 3])
|
||||
assert_equal 3, @filters.size([1,2,3])
|
||||
assert_equal 0, @filters.size([])
|
||||
assert_equal 0, @filters.size(nil)
|
||||
end
|
||||
@@ -64,34 +64,6 @@ class StandardFiltersTest < Minitest::Test
|
||||
assert_equal '', @filters.upcase(nil)
|
||||
end
|
||||
|
||||
def test_slice
|
||||
assert_equal 'oob', @filters.slice('foobar', 1, 3)
|
||||
assert_equal 'oobar', @filters.slice('foobar', 1, 1000)
|
||||
assert_equal '', @filters.slice('foobar', 1, 0)
|
||||
assert_equal 'o', @filters.slice('foobar', 1, 1)
|
||||
assert_equal 'bar', @filters.slice('foobar', 3, 3)
|
||||
assert_equal 'ar', @filters.slice('foobar', -2, 2)
|
||||
assert_equal 'ar', @filters.slice('foobar', -2, 1000)
|
||||
assert_equal 'r', @filters.slice('foobar', -1)
|
||||
assert_equal '', @filters.slice(nil, 0)
|
||||
assert_equal '', @filters.slice('foobar', 100, 10)
|
||||
assert_equal '', @filters.slice('foobar', -100, 10)
|
||||
end
|
||||
|
||||
def test_slice_on_arrays
|
||||
input = 'foobar'.split(//)
|
||||
assert_equal %w(o o b), @filters.slice(input, 1, 3)
|
||||
assert_equal %w(o o b a r), @filters.slice(input, 1, 1000)
|
||||
assert_equal %w(), @filters.slice(input, 1, 0)
|
||||
assert_equal %w(o), @filters.slice(input, 1, 1)
|
||||
assert_equal %w(b a r), @filters.slice(input, 3, 3)
|
||||
assert_equal %w(a r), @filters.slice(input, -2, 2)
|
||||
assert_equal %w(a r), @filters.slice(input, -2, 1000)
|
||||
assert_equal %w(r), @filters.slice(input, -1)
|
||||
assert_equal %w(), @filters.slice(input, 100, 10)
|
||||
assert_equal %w(), @filters.slice(input, -100, 10)
|
||||
end
|
||||
|
||||
def test_truncate
|
||||
assert_equal '1234...', @filters.truncate('1234567890', 7)
|
||||
assert_equal '1234567890', @filters.truncate('1234567890', 20)
|
||||
@@ -101,12 +73,11 @@ class StandardFiltersTest < Minitest::Test
|
||||
end
|
||||
|
||||
def test_split
|
||||
assert_equal ['12', '34'], @filters.split('12~34', '~')
|
||||
assert_equal ['A? ', ' ,Z'], @filters.split('A? ~ ~ ~ ,Z', '~ ~ ~')
|
||||
assert_equal ['12','34'], @filters.split('12~34', '~')
|
||||
assert_equal ['A? ',' ,Z'], @filters.split('A? ~ ~ ~ ,Z', '~ ~ ~')
|
||||
assert_equal ['A?Z'], @filters.split('A?Z', '~')
|
||||
# Regexp works although Liquid does not support.
|
||||
assert_equal ['A', 'Z'], @filters.split('AxZ', /x/)
|
||||
assert_equal [], @filters.split(nil, ' ')
|
||||
assert_equal ['A','Z'], @filters.split('AxZ', /x/)
|
||||
end
|
||||
|
||||
def test_escape
|
||||
@@ -118,11 +89,6 @@ class StandardFiltersTest < Minitest::Test
|
||||
assert_equal '<strong>Hulk</strong>', @filters.escape_once('<strong>Hulk</strong>')
|
||||
end
|
||||
|
||||
def test_url_encode
|
||||
assert_equal 'foo%2B1%40example.com', @filters.url_encode('foo+1@example.com')
|
||||
assert_equal nil, @filters.url_encode(nil)
|
||||
end
|
||||
|
||||
def test_truncatewords
|
||||
assert_equal 'one two three', @filters.truncatewords('one two three', 4)
|
||||
assert_equal 'one two...', @filters.truncatewords('one two three', 2)
|
||||
@@ -142,45 +108,38 @@ class StandardFiltersTest < Minitest::Test
|
||||
end
|
||||
|
||||
def test_join
|
||||
assert_equal '1 2 3 4', @filters.join([1, 2, 3, 4])
|
||||
assert_equal '1 - 2 - 3 - 4', @filters.join([1, 2, 3, 4], ' - ')
|
||||
assert_equal '1 2 3 4', @filters.join([1,2,3,4])
|
||||
assert_equal '1 - 2 - 3 - 4', @filters.join([1,2,3,4], ' - ')
|
||||
end
|
||||
|
||||
def test_sort
|
||||
assert_equal [1, 2, 3, 4], @filters.sort([4, 3, 2, 1])
|
||||
assert_equal [{ "a" => 1 }, { "a" => 2 }, { "a" => 3 }, { "a" => 4 }], @filters.sort([{ "a" => 4 }, { "a" => 3 }, { "a" => 1 }, { "a" => 2 }], "a")
|
||||
assert_equal [1,2,3,4], @filters.sort([4,3,2,1])
|
||||
assert_equal [{"a" => 1}, {"a" => 2}, {"a" => 3}, {"a" => 4}], @filters.sort([{"a" => 4}, {"a" => 3}, {"a" => 1}, {"a" => 2}], "a")
|
||||
end
|
||||
|
||||
def test_legacy_sort_hash
|
||||
assert_equal [{ a: 1, b: 2 }], @filters.sort({ a: 1, b: 2 })
|
||||
assert_equal [{a:1, b:2}], @filters.sort({a:1, b:2})
|
||||
end
|
||||
|
||||
def test_numerical_vs_lexicographical_sort
|
||||
assert_equal [2, 10], @filters.sort([10, 2])
|
||||
assert_equal [{ "a" => 2 }, { "a" => 10 }], @filters.sort([{ "a" => 10 }, { "a" => 2 }], "a")
|
||||
assert_equal [{"a" => 2}, {"a" => 10}], @filters.sort([{"a" => 10}, {"a" => 2}], "a")
|
||||
assert_equal ["10", "2"], @filters.sort(["10", "2"])
|
||||
assert_equal [{ "a" => "10" }, { "a" => "2" }], @filters.sort([{ "a" => "10" }, { "a" => "2" }], "a")
|
||||
end
|
||||
|
||||
def test_uniq
|
||||
assert_equal [1, 3, 2, 4], @filters.uniq([1, 1, 3, 2, 3, 1, 4, 3, 2, 1])
|
||||
assert_equal [{ "a" => 1 }, { "a" => 3 }, { "a" => 2 }], @filters.uniq([{ "a" => 1 }, { "a" => 3 }, { "a" => 1 }, { "a" => 2 }], "a")
|
||||
testdrop = TestDrop.new
|
||||
assert_equal [testdrop], @filters.uniq([testdrop, TestDrop.new], 'test')
|
||||
assert_equal [{"a" => "10"}, {"a" => "2"}], @filters.sort([{"a" => "10"}, {"a" => "2"}], "a")
|
||||
end
|
||||
|
||||
def test_reverse
|
||||
assert_equal [4, 3, 2, 1], @filters.reverse([1, 2, 3, 4])
|
||||
assert_equal [4,3,2,1], @filters.reverse([1,2,3,4])
|
||||
end
|
||||
|
||||
def test_legacy_reverse_hash
|
||||
assert_equal [{ a: 1, b: 2 }], @filters.reverse(a: 1, b: 2)
|
||||
assert_equal [{a:1, b:2}], @filters.reverse(a:1, b:2)
|
||||
end
|
||||
|
||||
def test_map
|
||||
assert_equal [1, 2, 3, 4], @filters.map([{ "a" => 1 }, { "a" => 2 }, { "a" => 3 }, { "a" => 4 }], 'a')
|
||||
assert_equal [1,2,3,4], @filters.map([{"a" => 1}, {"a" => 2}, {"a" => 3}, {"a" => 4}], 'a')
|
||||
assert_template_result 'abc', "{{ ary | map:'foo' | map:'bar' }}",
|
||||
'ary' => [{ 'foo' => { 'bar' => 'a' } }, { 'foo' => { 'bar' => 'b' } }, { 'foo' => { 'bar' => 'c' } }]
|
||||
'ary' => [{'foo' => {'bar' => 'a'}}, {'foo' => {'bar' => 'b'}}, {'foo' => {'bar' => 'c'}}]
|
||||
end
|
||||
|
||||
def test_map_doesnt_call_arbitrary_stuff
|
||||
@@ -212,7 +171,7 @@ class StandardFiltersTest < Minitest::Test
|
||||
|
||||
def test_map_over_proc
|
||||
drop = TestDrop.new
|
||||
p = proc{ drop }
|
||||
p = Proc.new{ drop }
|
||||
templ = '{{ procs | map: "test" }}'
|
||||
assert_template_result "testfoo", templ, "procs" => [p]
|
||||
end
|
||||
@@ -225,11 +184,6 @@ class StandardFiltersTest < Minitest::Test
|
||||
assert_template_result "213", '{{ foo | sort: "bar" | map: "foo" }}', "foo" => TestEnumerable.new
|
||||
end
|
||||
|
||||
def test_first_and_last_call_to_liquid
|
||||
assert_template_result 'foobar', '{{ foo | first }}', 'foo' => [ThingWithToLiquid.new]
|
||||
assert_template_result 'foobar', '{{ foo | last }}', 'foo' => [ThingWithToLiquid.new]
|
||||
end
|
||||
|
||||
def test_date
|
||||
assert_equal 'May', @filters.date(Time.parse("2006-05-05 10:00:00"), "%B")
|
||||
assert_equal 'June', @filters.date(Time.parse("2006-06-05 10:00:00"), "%B")
|
||||
@@ -249,19 +203,16 @@ class StandardFiltersTest < Minitest::Test
|
||||
assert_equal "07/16/2004", @filters.date("Fri Jul 16 01:00:00 2004", "%m/%d/%Y")
|
||||
assert_equal "#{Date.today.year}", @filters.date('now', '%Y')
|
||||
assert_equal "#{Date.today.year}", @filters.date('today', '%Y')
|
||||
assert_equal "#{Date.today.year}", @filters.date('Today', '%Y')
|
||||
|
||||
assert_equal nil, @filters.date(nil, "%B")
|
||||
|
||||
assert_equal '', @filters.date('', "%B")
|
||||
|
||||
assert_equal "07/05/2006", @filters.date(1152098955, "%m/%d/%Y")
|
||||
assert_equal "07/05/2006", @filters.date("1152098955", "%m/%d/%Y")
|
||||
end
|
||||
|
||||
def test_first_last
|
||||
assert_equal 1, @filters.first([1, 2, 3])
|
||||
assert_equal 3, @filters.last([1, 2, 3])
|
||||
assert_equal 1, @filters.first([1,2,3])
|
||||
assert_equal 3, @filters.last([1,2,3])
|
||||
assert_equal nil, @filters.first([])
|
||||
assert_equal nil, @filters.last([])
|
||||
end
|
||||
@@ -356,26 +307,15 @@ class StandardFiltersTest < Minitest::Test
|
||||
end
|
||||
|
||||
def test_append
|
||||
assigns = { 'a' => 'bc', 'b' => 'd' }
|
||||
assert_template_result('bcd', "{{ a | append: 'd'}}", assigns)
|
||||
assert_template_result('bcd', "{{ a | append: b}}", assigns)
|
||||
end
|
||||
|
||||
def test_concat
|
||||
assert_equal [1, 2, 3, 4], @filters.concat([1, 2], [3, 4])
|
||||
assert_equal [1, 2, 'a'], @filters.concat([1, 2], ['a'])
|
||||
assert_equal [1, 2, 10], @filters.concat([1, 2], [10])
|
||||
|
||||
assert_raises(TypeError) do
|
||||
# no implicit conversion of Fixnum into Array
|
||||
@filters.concat([1, 2], 10)
|
||||
end
|
||||
assigns = {'a' => 'bc', 'b' => 'd' }
|
||||
assert_template_result('bcd',"{{ a | append: 'd'}}",assigns)
|
||||
assert_template_result('bcd',"{{ a | append: b}}",assigns)
|
||||
end
|
||||
|
||||
def test_prepend
|
||||
assigns = { 'a' => 'bc', 'b' => 'a' }
|
||||
assert_template_result('abc', "{{ a | prepend: 'a'}}", assigns)
|
||||
assert_template_result('abc', "{{ a | prepend: b}}", assigns)
|
||||
assigns = {'a' => 'bc', 'b' => 'a' }
|
||||
assert_template_result('abc',"{{ a | prepend: 'a'}}",assigns)
|
||||
assert_template_result('abc',"{{ a | prepend: b}}",assigns)
|
||||
end
|
||||
|
||||
def test_default
|
||||
@@ -388,6 +328,6 @@ class StandardFiltersTest < Minitest::Test
|
||||
end
|
||||
|
||||
def test_cannot_access_private_methods
|
||||
assert_template_result('a', "{{ 'a' | to_number }}")
|
||||
assert_template_result('a',"{{ 'a' | to_number }}")
|
||||
end
|
||||
end # StandardFiltersTest
|
||||
|
||||
@@ -1,12 +1,12 @@
|
||||
require 'test_helper'
|
||||
|
||||
class BreakTagTest < Minitest::Test
|
||||
class BreakTagTest < Test::Unit::TestCase
|
||||
include Liquid
|
||||
|
||||
# tests that no weird errors are raised if break is called outside of a
|
||||
# block
|
||||
def test_break_with_no_block
|
||||
assigns = { 'i' => 1 }
|
||||
assigns = {'i' => 1}
|
||||
markup = '{% break %}'
|
||||
expected = ''
|
||||
|
||||
|
||||
@@ -1,6 +1,6 @@
|
||||
require 'test_helper'
|
||||
|
||||
class ContinueTagTest < Minitest::Test
|
||||
class ContinueTagTest < Test::Unit::TestCase
|
||||
include Liquid
|
||||
|
||||
# tests that no weird errors are raised if continue is called outside of a
|
||||
|
||||
@@ -6,14 +6,14 @@ class ThingWithValue < Liquid::Drop
|
||||
end
|
||||
end
|
||||
|
||||
class ForTagTest < Minitest::Test
|
||||
class ForTagTest < Test::Unit::TestCase
|
||||
include Liquid
|
||||
|
||||
def test_for
|
||||
assert_template_result(' yo yo yo yo ', '{%for item in array%} yo {%endfor%}', 'array' => [1, 2, 3, 4])
|
||||
assert_template_result('yoyo', '{%for item in array%}yo{%endfor%}', 'array' => [1, 2])
|
||||
assert_template_result(' yo ', '{%for item in array%} yo {%endfor%}', 'array' => [1])
|
||||
assert_template_result('', '{%for item in array%}{%endfor%}', 'array' => [1, 2])
|
||||
assert_template_result(' yo yo yo yo ','{%for item in array%} yo {%endfor%}','array' => [1,2,3,4])
|
||||
assert_template_result('yoyo','{%for item in array%}yo{%endfor%}','array' => [1,2])
|
||||
assert_template_result(' yo ','{%for item in array%} yo {%endfor%}','array' => [1])
|
||||
assert_template_result('','{%for item in array%}{%endfor%}','array' => [1,2])
|
||||
expected = <<HERE
|
||||
|
||||
yo
|
||||
@@ -28,46 +28,46 @@ HERE
|
||||
yo
|
||||
{%endfor%}
|
||||
HERE
|
||||
assert_template_result(expected, template, 'array' => [1, 2, 3])
|
||||
assert_template_result(expected,template,'array' => [1,2,3])
|
||||
end
|
||||
|
||||
def test_for_reversed
|
||||
assigns = { 'array' => [ 1, 2, 3] }
|
||||
assert_template_result('321', '{%for item in array reversed %}{{item}}{%endfor%}', assigns)
|
||||
assigns = {'array' => [ 1, 2, 3] }
|
||||
assert_template_result('321','{%for item in array reversed %}{{item}}{%endfor%}',assigns)
|
||||
end
|
||||
|
||||
def test_for_with_range
|
||||
assert_template_result(' 1 2 3 ', '{%for item in (1..3) %} {{item}} {%endfor%}')
|
||||
assert_template_result(' 1 2 3 ','{%for item in (1..3) %} {{item}} {%endfor%}')
|
||||
end
|
||||
|
||||
def test_for_with_variable_range
|
||||
assert_template_result(' 1 2 3 ', '{%for item in (1..foobar) %} {{item}} {%endfor%}', "foobar" => 3)
|
||||
assert_template_result(' 1 2 3 ','{%for item in (1..foobar) %} {{item}} {%endfor%}', "foobar" => 3)
|
||||
end
|
||||
|
||||
def test_for_with_hash_value_range
|
||||
foobar = { "value" => 3 }
|
||||
assert_template_result(' 1 2 3 ', '{%for item in (1..foobar.value) %} {{item}} {%endfor%}', "foobar" => foobar)
|
||||
assert_template_result(' 1 2 3 ','{%for item in (1..foobar.value) %} {{item}} {%endfor%}', "foobar" => foobar)
|
||||
end
|
||||
|
||||
def test_for_with_drop_value_range
|
||||
foobar = ThingWithValue.new
|
||||
assert_template_result(' 1 2 3 ', '{%for item in (1..foobar.value) %} {{item}} {%endfor%}', "foobar" => foobar)
|
||||
assert_template_result(' 1 2 3 ','{%for item in (1..foobar.value) %} {{item}} {%endfor%}', "foobar" => foobar)
|
||||
end
|
||||
|
||||
def test_for_with_variable
|
||||
assert_template_result(' 1 2 3 ', '{%for item in array%} {{item}} {%endfor%}', 'array' => [1, 2, 3])
|
||||
assert_template_result('123', '{%for item in array%}{{item}}{%endfor%}', 'array' => [1, 2, 3])
|
||||
assert_template_result('123', '{% for item in array %}{{item}}{% endfor %}', 'array' => [1, 2, 3])
|
||||
assert_template_result('abcd', '{%for item in array%}{{item}}{%endfor%}', 'array' => ['a', 'b', 'c', 'd'])
|
||||
assert_template_result('a b c', '{%for item in array%}{{item}}{%endfor%}', 'array' => ['a', ' ', 'b', ' ', 'c'])
|
||||
assert_template_result('abc', '{%for item in array%}{{item}}{%endfor%}', 'array' => ['a', '', 'b', '', 'c'])
|
||||
assert_template_result(' 1 2 3 ','{%for item in array%} {{item}} {%endfor%}','array' => [1,2,3])
|
||||
assert_template_result('123','{%for item in array%}{{item}}{%endfor%}','array' => [1,2,3])
|
||||
assert_template_result('123','{% for item in array %}{{item}}{% endfor %}','array' => [1,2,3])
|
||||
assert_template_result('abcd','{%for item in array%}{{item}}{%endfor%}','array' => ['a','b','c','d'])
|
||||
assert_template_result('a b c','{%for item in array%}{{item}}{%endfor%}','array' => ['a',' ','b',' ','c'])
|
||||
assert_template_result('abc','{%for item in array%}{{item}}{%endfor%}','array' => ['a','','b','','c'])
|
||||
end
|
||||
|
||||
def test_for_helpers
|
||||
assigns = { 'array' => [1, 2, 3] }
|
||||
assigns = {'array' => [1,2,3] }
|
||||
assert_template_result(' 1/3 2/3 3/3 ',
|
||||
'{%for item in array%} {{forloop.index}}/{{forloop.length}} {%endfor%}',
|
||||
assigns)
|
||||
'{%for item in array%} {{forloop.index}}/{{forloop.length}} {%endfor%}',
|
||||
assigns)
|
||||
assert_template_result(' 1 2 3 ', '{%for item in array%} {{forloop.index}} {%endfor%}', assigns)
|
||||
assert_template_result(' 0 1 2 ', '{%for item in array%} {{forloop.index0}} {%endfor%}', assigns)
|
||||
assert_template_result(' 2 1 0 ', '{%for item in array%} {{forloop.rindex0}} {%endfor%}', assigns)
|
||||
@@ -77,20 +77,20 @@ HERE
|
||||
end
|
||||
|
||||
def test_for_and_if
|
||||
assigns = { 'array' => [1, 2, 3] }
|
||||
assigns = {'array' => [1,2,3] }
|
||||
assert_template_result('+--',
|
||||
'{%for item in array%}{% if forloop.first %}+{% else %}-{% endif %}{%endfor%}',
|
||||
assigns)
|
||||
'{%for item in array%}{% if forloop.first %}+{% else %}-{% endif %}{%endfor%}',
|
||||
assigns)
|
||||
end
|
||||
|
||||
def test_for_else
|
||||
assert_template_result('+++', '{%for item in array%}+{%else%}-{%endfor%}', 'array' => [1, 2, 3])
|
||||
assert_template_result('-', '{%for item in array%}+{%else%}-{%endfor%}', 'array' => [])
|
||||
assert_template_result('-', '{%for item in array%}+{%else%}-{%endfor%}', 'array' => nil)
|
||||
assert_template_result('+++', '{%for item in array%}+{%else%}-{%endfor%}', 'array'=>[1,2,3])
|
||||
assert_template_result('-', '{%for item in array%}+{%else%}-{%endfor%}', 'array'=>[])
|
||||
assert_template_result('-', '{%for item in array%}+{%else%}-{%endfor%}', 'array'=>nil)
|
||||
end
|
||||
|
||||
def test_limiting
|
||||
assigns = { 'array' => [1, 2, 3, 4, 5, 6, 7, 8, 9, 0] }
|
||||
assigns = {'array' => [1,2,3,4,5,6,7,8,9,0]}
|
||||
assert_template_result('12', '{%for i in array limit:2 %}{{ i }}{%endfor%}', assigns)
|
||||
assert_template_result('1234', '{%for i in array limit:4 %}{{ i }}{%endfor%}', assigns)
|
||||
assert_template_result('3456', '{%for i in array limit:4 offset:2 %}{{ i }}{%endfor%}', assigns)
|
||||
@@ -98,7 +98,7 @@ HERE
|
||||
end
|
||||
|
||||
def test_dynamic_variable_limiting
|
||||
assigns = { 'array' => [1, 2, 3, 4, 5, 6, 7, 8, 9, 0] }
|
||||
assigns = {'array' => [1,2,3,4,5,6,7,8,9,0]}
|
||||
assigns['limit'] = 2
|
||||
assigns['offset'] = 2
|
||||
|
||||
@@ -106,17 +106,17 @@ HERE
|
||||
end
|
||||
|
||||
def test_nested_for
|
||||
assigns = { 'array' => [[1, 2], [3, 4], [5, 6]] }
|
||||
assigns = {'array' => [[1,2],[3,4],[5,6]] }
|
||||
assert_template_result('123456', '{%for item in array%}{%for i in item%}{{ i }}{%endfor%}{%endfor%}', assigns)
|
||||
end
|
||||
|
||||
def test_offset_only
|
||||
assigns = { 'array' => [1, 2, 3, 4, 5, 6, 7, 8, 9, 0] }
|
||||
assigns = {'array' => [1,2,3,4,5,6,7,8,9,0]}
|
||||
assert_template_result('890', '{%for i in array offset:7 %}{{ i }}{%endfor%}', assigns)
|
||||
end
|
||||
|
||||
def test_pause_resume
|
||||
assigns = { 'array' => { 'items' => [1, 2, 3, 4, 5, 6, 7, 8, 9, 0] } }
|
||||
assigns = {'array' => {'items' => [1,2,3,4,5,6,7,8,9,0]}}
|
||||
markup = <<-MKUP
|
||||
{%for i in array.items limit: 3 %}{{i}}{%endfor%}
|
||||
next
|
||||
@@ -131,11 +131,11 @@ HERE
|
||||
next
|
||||
789
|
||||
XPCTD
|
||||
assert_template_result(expected, markup, assigns)
|
||||
assert_template_result(expected,markup,assigns)
|
||||
end
|
||||
|
||||
def test_pause_resume_limit
|
||||
assigns = { 'array' => { 'items' => [1, 2, 3, 4, 5, 6, 7, 8, 9, 0] } }
|
||||
assigns = {'array' => {'items' => [1,2,3,4,5,6,7,8,9,0]}}
|
||||
markup = <<-MKUP
|
||||
{%for i in array.items limit:3 %}{{i}}{%endfor%}
|
||||
next
|
||||
@@ -150,11 +150,11 @@ HERE
|
||||
next
|
||||
7
|
||||
XPCTD
|
||||
assert_template_result(expected, markup, assigns)
|
||||
assert_template_result(expected,markup,assigns)
|
||||
end
|
||||
|
||||
def test_pause_resume_BIG_limit
|
||||
assigns = { 'array' => { 'items' => [1, 2, 3, 4, 5, 6, 7, 8, 9, 0] } }
|
||||
assigns = {'array' => {'items' => [1,2,3,4,5,6,7,8,9,0]}}
|
||||
markup = <<-MKUP
|
||||
{%for i in array.items limit:3 %}{{i}}{%endfor%}
|
||||
next
|
||||
@@ -169,102 +169,103 @@ HERE
|
||||
next
|
||||
7890
|
||||
XPCTD
|
||||
assert_template_result(expected, markup, assigns)
|
||||
assert_template_result(expected,markup,assigns)
|
||||
end
|
||||
|
||||
|
||||
def test_pause_resume_BIG_offset
|
||||
assigns = { 'array' => { 'items' => [1, 2, 3, 4, 5, 6, 7, 8, 9, 0] } }
|
||||
markup = '{%for i in array.items limit:3 %}{{i}}{%endfor%}
|
||||
assigns = {'array' => {'items' => [1,2,3,4,5,6,7,8,9,0]}}
|
||||
markup = %q({%for i in array.items limit:3 %}{{i}}{%endfor%}
|
||||
next
|
||||
{%for i in array.items offset:continue limit:3 %}{{i}}{%endfor%}
|
||||
next
|
||||
{%for i in array.items offset:continue limit:3 offset:1000 %}{{i}}{%endfor%}'
|
||||
expected = '123
|
||||
{%for i in array.items offset:continue limit:3 offset:1000 %}{{i}}{%endfor%})
|
||||
expected = %q(123
|
||||
next
|
||||
456
|
||||
next
|
||||
'
|
||||
assert_template_result(expected, markup, assigns)
|
||||
)
|
||||
assert_template_result(expected,markup,assigns)
|
||||
end
|
||||
|
||||
def test_for_with_break
|
||||
assigns = { 'array' => { 'items' => [1, 2, 3, 4, 5, 6, 7, 8, 9, 10] } }
|
||||
assigns = {'array' => {'items' => [1,2,3,4,5,6,7,8,9,10]}}
|
||||
|
||||
markup = '{% for i in array.items %}{% break %}{% endfor %}'
|
||||
expected = ""
|
||||
assert_template_result(expected, markup, assigns)
|
||||
assert_template_result(expected,markup,assigns)
|
||||
|
||||
markup = '{% for i in array.items %}{{ i }}{% break %}{% endfor %}'
|
||||
expected = "1"
|
||||
assert_template_result(expected, markup, assigns)
|
||||
assert_template_result(expected,markup,assigns)
|
||||
|
||||
markup = '{% for i in array.items %}{% break %}{{ i }}{% endfor %}'
|
||||
expected = ""
|
||||
assert_template_result(expected, markup, assigns)
|
||||
assert_template_result(expected,markup,assigns)
|
||||
|
||||
markup = '{% for i in array.items %}{{ i }}{% if i > 3 %}{% break %}{% endif %}{% endfor %}'
|
||||
expected = "1234"
|
||||
assert_template_result(expected, markup, assigns)
|
||||
assert_template_result(expected,markup,assigns)
|
||||
|
||||
# tests to ensure it only breaks out of the local for loop
|
||||
# and not all of them.
|
||||
assigns = { 'array' => [[1, 2], [3, 4], [5, 6]] }
|
||||
markup = '{% for item in array %}' \
|
||||
'{% for i in item %}' \
|
||||
'{% if i == 1 %}' \
|
||||
'{% break %}' \
|
||||
'{% endif %}' \
|
||||
'{{ i }}' \
|
||||
'{% endfor %}' \
|
||||
assigns = {'array' => [[1,2],[3,4],[5,6]] }
|
||||
markup = '{% for item in array %}' +
|
||||
'{% for i in item %}' +
|
||||
'{% if i == 1 %}' +
|
||||
'{% break %}' +
|
||||
'{% endif %}' +
|
||||
'{{ i }}' +
|
||||
'{% endfor %}' +
|
||||
'{% endfor %}'
|
||||
expected = '3456'
|
||||
assert_template_result(expected, markup, assigns)
|
||||
|
||||
# test break does nothing when unreached
|
||||
assigns = { 'array' => { 'items' => [1, 2, 3, 4, 5] } }
|
||||
assigns = {'array' => {'items' => [1,2,3,4,5]}}
|
||||
markup = '{% for i in array.items %}{% if i == 9999 %}{% break %}{% endif %}{{ i }}{% endfor %}'
|
||||
expected = '12345'
|
||||
assert_template_result(expected, markup, assigns)
|
||||
end
|
||||
|
||||
def test_for_with_continue
|
||||
assigns = { 'array' => { 'items' => [1, 2, 3, 4, 5] } }
|
||||
assigns = {'array' => {'items' => [1,2,3,4,5]}}
|
||||
|
||||
markup = '{% for i in array.items %}{% continue %}{% endfor %}'
|
||||
expected = ""
|
||||
assert_template_result(expected, markup, assigns)
|
||||
assert_template_result(expected,markup,assigns)
|
||||
|
||||
markup = '{% for i in array.items %}{{ i }}{% continue %}{% endfor %}'
|
||||
expected = "12345"
|
||||
assert_template_result(expected, markup, assigns)
|
||||
assert_template_result(expected,markup,assigns)
|
||||
|
||||
markup = '{% for i in array.items %}{% continue %}{{ i }}{% endfor %}'
|
||||
expected = ""
|
||||
assert_template_result(expected, markup, assigns)
|
||||
assert_template_result(expected,markup,assigns)
|
||||
|
||||
markup = '{% for i in array.items %}{% if i > 3 %}{% continue %}{% endif %}{{ i }}{% endfor %}'
|
||||
expected = "123"
|
||||
assert_template_result(expected, markup, assigns)
|
||||
assert_template_result(expected,markup,assigns)
|
||||
|
||||
markup = '{% for i in array.items %}{% if i == 3 %}{% continue %}{% else %}{{ i }}{% endif %}{% endfor %}'
|
||||
expected = "1245"
|
||||
assert_template_result(expected, markup, assigns)
|
||||
assert_template_result(expected,markup,assigns)
|
||||
|
||||
# tests to ensure it only continues the local for loop and not all of them.
|
||||
assigns = { 'array' => [[1, 2], [3, 4], [5, 6]] }
|
||||
markup = '{% for item in array %}' \
|
||||
'{% for i in item %}' \
|
||||
'{% if i == 1 %}' \
|
||||
'{% continue %}' \
|
||||
'{% endif %}' \
|
||||
'{{ i }}' \
|
||||
'{% endfor %}' \
|
||||
assigns = {'array' => [[1,2],[3,4],[5,6]] }
|
||||
markup = '{% for item in array %}' +
|
||||
'{% for i in item %}' +
|
||||
'{% if i == 1 %}' +
|
||||
'{% continue %}' +
|
||||
'{% endif %}' +
|
||||
'{{ i }}' +
|
||||
'{% endfor %}' +
|
||||
'{% endfor %}'
|
||||
expected = '23456'
|
||||
assert_template_result(expected, markup, assigns)
|
||||
|
||||
# test continue does nothing when unreached
|
||||
assigns = { 'array' => { 'items' => [1, 2, 3, 4, 5] } }
|
||||
assigns = {'array' => {'items' => [1,2,3,4,5]}}
|
||||
markup = '{% for i in array.items %}{% if i == 9999 %}{% continue %}{% endif %}{{ i }}{% endfor %}'
|
||||
expected = '12345'
|
||||
assert_template_result(expected, markup, assigns)
|
||||
@@ -276,45 +277,25 @@ HERE
|
||||
# the functionality for backwards compatibility
|
||||
|
||||
assert_template_result('test string',
|
||||
'{%for val in string%}{{val}}{%endfor%}',
|
||||
'string' => "test string")
|
||||
'{%for val in string%}{{val}}{%endfor%}',
|
||||
'string' => "test string")
|
||||
|
||||
assert_template_result('test string',
|
||||
'{%for val in string limit:1%}{{val}}{%endfor%}',
|
||||
'string' => "test string")
|
||||
'{%for val in string limit:1%}{{val}}{%endfor%}',
|
||||
'string' => "test string")
|
||||
|
||||
assert_template_result('val-string-1-1-0-1-0-true-true-test string',
|
||||
'{%for val in string%}' \
|
||||
'{{forloop.name}}-' \
|
||||
'{{forloop.index}}-' \
|
||||
'{{forloop.length}}-' \
|
||||
'{{forloop.index0}}-' \
|
||||
'{{forloop.rindex}}-' \
|
||||
'{{forloop.rindex0}}-' \
|
||||
'{{forloop.first}}-' \
|
||||
'{{forloop.last}}-' \
|
||||
'{{val}}{%endfor%}',
|
||||
'string' => "test string")
|
||||
end
|
||||
|
||||
def test_for_parentloop_references_parent_loop
|
||||
assert_template_result('1.1 1.2 1.3 2.1 2.2 2.3 ',
|
||||
'{% for inner in outer %}{% for k in inner %}' \
|
||||
'{{ forloop.parentloop.index }}.{{ forloop.index }} ' \
|
||||
'{% endfor %}{% endfor %}',
|
||||
'outer' => [[1, 1, 1], [1, 1, 1]])
|
||||
end
|
||||
|
||||
def test_for_parentloop_nil_when_not_present
|
||||
assert_template_result('.1 .2 ',
|
||||
'{% for inner in outer %}' \
|
||||
'{{ forloop.parentloop.index }}.{{ forloop.index }} ' \
|
||||
'{% endfor %}',
|
||||
'outer' => [[1, 1, 1], [1, 1, 1]])
|
||||
end
|
||||
|
||||
def test_inner_for_over_empty_input
|
||||
assert_template_result 'oo', '{% for a in (1..2) %}o{% for b in empty %}{% endfor %}{% endfor %}'
|
||||
'{%for val in string%}' +
|
||||
'{{forloop.name}}-' +
|
||||
'{{forloop.index}}-' +
|
||||
'{{forloop.length}}-' +
|
||||
'{{forloop.index0}}-' +
|
||||
'{{forloop.rindex}}-' +
|
||||
'{{forloop.rindex0}}-' +
|
||||
'{{forloop.first}}-' +
|
||||
'{{forloop.last}}-' +
|
||||
'{{val}}{%endfor%}',
|
||||
'string' => "test string")
|
||||
end
|
||||
|
||||
def test_blank_string_not_iterable
|
||||
@@ -322,7 +303,7 @@ HERE
|
||||
end
|
||||
|
||||
def test_bad_variable_naming_in_for_loop
|
||||
assert_raises(Liquid::SyntaxError) do
|
||||
assert_raise(Liquid::SyntaxError) do
|
||||
Liquid::Template.parse('{% for a/b in x %}{% endfor %}')
|
||||
end
|
||||
end
|
||||
@@ -330,7 +311,7 @@ HERE
|
||||
def test_spacing_with_variable_naming_in_for_loop
|
||||
expected = '12345'
|
||||
template = '{% for item in items %}{{item}}{% endfor %}'
|
||||
assigns = { 'items' => [1, 2, 3, 4, 5] }
|
||||
assigns = {'items' => [1,2,3,4,5]}
|
||||
assert_template_result(expected, template, assigns)
|
||||
end
|
||||
|
||||
@@ -348,13 +329,13 @@ HERE
|
||||
|
||||
def load_slice(from, to)
|
||||
@load_slice_called = true
|
||||
@data[(from..to - 1)]
|
||||
@data[(from..to-1)]
|
||||
end
|
||||
end
|
||||
|
||||
def test_iterate_with_each_when_no_limit_applied
|
||||
loader = LoaderDrop.new([1, 2, 3, 4, 5])
|
||||
assigns = { 'items' => loader }
|
||||
loader = LoaderDrop.new([1,2,3,4,5])
|
||||
assigns = {'items' => loader}
|
||||
expected = '12345'
|
||||
template = '{% for item in items %}{{item}}{% endfor %}'
|
||||
assert_template_result(expected, template, assigns)
|
||||
@@ -363,8 +344,8 @@ HERE
|
||||
end
|
||||
|
||||
def test_iterate_with_load_slice_when_limit_applied
|
||||
loader = LoaderDrop.new([1, 2, 3, 4, 5])
|
||||
assigns = { 'items' => loader }
|
||||
loader = LoaderDrop.new([1,2,3,4,5])
|
||||
assigns = {'items' => loader}
|
||||
expected = '1'
|
||||
template = '{% for item in items limit:1 %}{{item}}{% endfor %}'
|
||||
assert_template_result(expected, template, assigns)
|
||||
@@ -373,8 +354,8 @@ HERE
|
||||
end
|
||||
|
||||
def test_iterate_with_load_slice_when_limit_and_offset_applied
|
||||
loader = LoaderDrop.new([1, 2, 3, 4, 5])
|
||||
assigns = { 'items' => loader }
|
||||
loader = LoaderDrop.new([1,2,3,4,5])
|
||||
assigns = {'items' => loader}
|
||||
expected = '34'
|
||||
template = '{% for item in items offset:2 limit:2 %}{{item}}{% endfor %}'
|
||||
assert_template_result(expected, template, assigns)
|
||||
@@ -383,22 +364,12 @@ HERE
|
||||
end
|
||||
|
||||
def test_iterate_with_load_slice_returns_same_results_as_without
|
||||
loader = LoaderDrop.new([1, 2, 3, 4, 5])
|
||||
loader_assigns = { 'items' => loader }
|
||||
array_assigns = { 'items' => [1, 2, 3, 4, 5] }
|
||||
loader = LoaderDrop.new([1,2,3,4,5])
|
||||
loader_assigns = {'items' => loader}
|
||||
array_assigns = {'items' => [1,2,3,4,5]}
|
||||
expected = '34'
|
||||
template = '{% for item in items offset:2 limit:2 %}{{item}}{% endfor %}'
|
||||
assert_template_result(expected, template, loader_assigns)
|
||||
assert_template_result(expected, template, array_assigns)
|
||||
end
|
||||
|
||||
def test_for_cleans_up_registers
|
||||
context = Context.new(ErrorDrop.new)
|
||||
|
||||
assert_raises(StandardError) do
|
||||
Liquid::Template.parse('{% for i in (1..2) %}{{ standard_error }}{% endfor %}').render!(context)
|
||||
end
|
||||
|
||||
assert context.registers[:for_stack].empty?
|
||||
end
|
||||
end
|
||||
|
||||
@@ -1,103 +1,105 @@
|
||||
require 'test_helper'
|
||||
|
||||
class IfElseTagTest < Minitest::Test
|
||||
class IfElseTagTest < Test::Unit::TestCase
|
||||
include Liquid
|
||||
|
||||
def test_if
|
||||
assert_template_result(' ', ' {% if false %} this text should not go into the output {% endif %} ')
|
||||
assert_template_result(' ',' {% if false %} this text should not go into the output {% endif %} ')
|
||||
assert_template_result(' this text should go into the output ',
|
||||
' {% if true %} this text should go into the output {% endif %} ')
|
||||
assert_template_result(' you rock ?', '{% if false %} you suck {% endif %} {% if true %} you rock {% endif %}?')
|
||||
end
|
||||
|
||||
def test_literal_comparisons
|
||||
assert_template_result(' NO ', '{% assign v = false %}{% if v %} YES {% else %} NO {% endif %}')
|
||||
assert_template_result(' YES ', '{% assign v = nil %}{% if v == nil %} YES {% else %} NO {% endif %}')
|
||||
' {% if true %} this text should go into the output {% endif %} ')
|
||||
assert_template_result(' you rock ?','{% if false %} you suck {% endif %} {% if true %} you rock {% endif %}?')
|
||||
end
|
||||
|
||||
def test_if_else
|
||||
assert_template_result(' YES ', '{% if false %} NO {% else %} YES {% endif %}')
|
||||
assert_template_result(' YES ', '{% if true %} YES {% else %} NO {% endif %}')
|
||||
assert_template_result(' YES ', '{% if "foo" %} YES {% else %} NO {% endif %}')
|
||||
assert_template_result(' YES ','{% if false %} NO {% else %} YES {% endif %}')
|
||||
assert_template_result(' YES ','{% if true %} YES {% else %} NO {% endif %}')
|
||||
assert_template_result(' YES ','{% if "foo" %} YES {% else %} NO {% endif %}')
|
||||
end
|
||||
|
||||
def test_if_boolean
|
||||
assert_template_result(' YES ', '{% if var %} YES {% endif %}', 'var' => true)
|
||||
assert_template_result(' YES ','{% if var %} YES {% endif %}', 'var' => true)
|
||||
end
|
||||
|
||||
def test_if_or
|
||||
assert_template_result(' YES ', '{% if a or b %} YES {% endif %}', 'a' => true, 'b' => true)
|
||||
assert_template_result(' YES ', '{% if a or b %} YES {% endif %}', 'a' => true, 'b' => false)
|
||||
assert_template_result(' YES ', '{% if a or b %} YES {% endif %}', 'a' => false, 'b' => true)
|
||||
assert_template_result(' YES ','{% if a or b %} YES {% endif %}', 'a' => true, 'b' => true)
|
||||
assert_template_result(' YES ','{% if a or b %} YES {% endif %}', 'a' => true, 'b' => false)
|
||||
assert_template_result(' YES ','{% if a or b %} YES {% endif %}', 'a' => false, 'b' => true)
|
||||
assert_template_result('', '{% if a or b %} YES {% endif %}', 'a' => false, 'b' => false)
|
||||
|
||||
assert_template_result(' YES ', '{% if a or b or c %} YES {% endif %}', 'a' => false, 'b' => false, 'c' => true)
|
||||
assert_template_result(' YES ','{% if a or b or c %} YES {% endif %}', 'a' => false, 'b' => false, 'c' => true)
|
||||
assert_template_result('', '{% if a or b or c %} YES {% endif %}', 'a' => false, 'b' => false, 'c' => false)
|
||||
end
|
||||
|
||||
def test_if_or_with_operators
|
||||
assert_template_result(' YES ', '{% if a == true or b == true %} YES {% endif %}', 'a' => true, 'b' => true)
|
||||
assert_template_result(' YES ', '{% if a == true or b == false %} YES {% endif %}', 'a' => true, 'b' => true)
|
||||
assert_template_result('', '{% if a == false or b == false %} YES {% endif %}', 'a' => true, 'b' => true)
|
||||
assert_template_result(' YES ','{% if a == true or b == true %} YES {% endif %}', 'a' => true, 'b' => true)
|
||||
assert_template_result(' YES ','{% if a == true or b == false %} YES {% endif %}', 'a' => true, 'b' => true)
|
||||
assert_template_result('','{% if a == false or b == false %} YES {% endif %}', 'a' => true, 'b' => true)
|
||||
end
|
||||
|
||||
def test_comparison_of_strings_containing_and_or_or
|
||||
awful_markup = "a == 'and' and b == 'or' and c == 'foo and bar' and d == 'bar or baz' and e == 'foo' and foo and bar"
|
||||
assigns = { 'a' => 'and', 'b' => 'or', 'c' => 'foo and bar', 'd' => 'bar or baz', 'e' => 'foo', 'foo' => true, 'bar' => true }
|
||||
assert_template_result(' YES ', "{% if #{awful_markup} %} YES {% endif %}", assigns)
|
||||
assert_nothing_raised do
|
||||
awful_markup = "a == 'and' and b == 'or' and c == 'foo and bar' and d == 'bar or baz' and e == 'foo' and foo and bar"
|
||||
assigns = {'a' => 'and', 'b' => 'or', 'c' => 'foo and bar', 'd' => 'bar or baz', 'e' => 'foo', 'foo' => true, 'bar' => true}
|
||||
assert_template_result(' YES ',"{% if #{awful_markup} %} YES {% endif %}", assigns)
|
||||
end
|
||||
end
|
||||
|
||||
def test_comparison_of_expressions_starting_with_and_or_or
|
||||
assigns = { 'order' => { 'items_count' => 0 }, 'android' => { 'name' => 'Roy' } }
|
||||
assert_template_result("YES",
|
||||
"{% if android.name == 'Roy' %}YES{% endif %}",
|
||||
assigns)
|
||||
assert_template_result("YES",
|
||||
"{% if order.items_count == 0 %}YES{% endif %}",
|
||||
assigns)
|
||||
assigns = {'order' => {'items_count' => 0}, 'android' => {'name' => 'Roy'}}
|
||||
assert_nothing_raised do
|
||||
assert_template_result( "YES",
|
||||
"{% if android.name == 'Roy' %}YES{% endif %}",
|
||||
assigns)
|
||||
end
|
||||
assert_nothing_raised do
|
||||
assert_template_result( "YES",
|
||||
"{% if order.items_count == 0 %}YES{% endif %}",
|
||||
assigns)
|
||||
end
|
||||
end
|
||||
|
||||
def test_if_and
|
||||
assert_template_result(' YES ', '{% if true and true %} YES {% endif %}')
|
||||
assert_template_result('', '{% if false and true %} YES {% endif %}')
|
||||
assert_template_result('', '{% if false and true %} YES {% endif %}')
|
||||
assert_template_result(' YES ','{% if true and true %} YES {% endif %}')
|
||||
assert_template_result('','{% if false and true %} YES {% endif %}')
|
||||
assert_template_result('','{% if false and true %} YES {% endif %}')
|
||||
end
|
||||
|
||||
|
||||
def test_hash_miss_generates_false
|
||||
assert_template_result('', '{% if foo.bar %} NO {% endif %}', 'foo' => {})
|
||||
assert_template_result('','{% if foo.bar %} NO {% endif %}', 'foo' => {})
|
||||
end
|
||||
|
||||
def test_if_from_variable
|
||||
assert_template_result('', '{% if var %} NO {% endif %}', 'var' => false)
|
||||
assert_template_result('', '{% if var %} NO {% endif %}', 'var' => nil)
|
||||
assert_template_result('', '{% if foo.bar %} NO {% endif %}', 'foo' => { 'bar' => false })
|
||||
assert_template_result('', '{% if foo.bar %} NO {% endif %}', 'foo' => {})
|
||||
assert_template_result('', '{% if foo.bar %} NO {% endif %}', 'foo' => nil)
|
||||
assert_template_result('', '{% if foo.bar %} NO {% endif %}', 'foo' => true)
|
||||
assert_template_result('','{% if var %} NO {% endif %}', 'var' => false)
|
||||
assert_template_result('','{% if var %} NO {% endif %}', 'var' => nil)
|
||||
assert_template_result('','{% if foo.bar %} NO {% endif %}', 'foo' => {'bar' => false})
|
||||
assert_template_result('','{% if foo.bar %} NO {% endif %}', 'foo' => {})
|
||||
assert_template_result('','{% if foo.bar %} NO {% endif %}', 'foo' => nil)
|
||||
assert_template_result('','{% if foo.bar %} NO {% endif %}', 'foo' => true)
|
||||
|
||||
assert_template_result(' YES ', '{% if var %} YES {% endif %}', 'var' => "text")
|
||||
assert_template_result(' YES ', '{% if var %} YES {% endif %}', 'var' => true)
|
||||
assert_template_result(' YES ', '{% if var %} YES {% endif %}', 'var' => 1)
|
||||
assert_template_result(' YES ', '{% if var %} YES {% endif %}', 'var' => {})
|
||||
assert_template_result(' YES ', '{% if var %} YES {% endif %}', 'var' => [])
|
||||
assert_template_result(' YES ', '{% if "foo" %} YES {% endif %}')
|
||||
assert_template_result(' YES ', '{% if foo.bar %} YES {% endif %}', 'foo' => { 'bar' => true })
|
||||
assert_template_result(' YES ', '{% if foo.bar %} YES {% endif %}', 'foo' => { 'bar' => "text" })
|
||||
assert_template_result(' YES ', '{% if foo.bar %} YES {% endif %}', 'foo' => { 'bar' => 1 })
|
||||
assert_template_result(' YES ', '{% if foo.bar %} YES {% endif %}', 'foo' => { 'bar' => {} })
|
||||
assert_template_result(' YES ', '{% if foo.bar %} YES {% endif %}', 'foo' => { 'bar' => [] })
|
||||
assert_template_result(' YES ','{% if var %} YES {% endif %}', 'var' => "text")
|
||||
assert_template_result(' YES ','{% if var %} YES {% endif %}', 'var' => true)
|
||||
assert_template_result(' YES ','{% if var %} YES {% endif %}', 'var' => 1)
|
||||
assert_template_result(' YES ','{% if var %} YES {% endif %}', 'var' => {})
|
||||
assert_template_result(' YES ','{% if var %} YES {% endif %}', 'var' => [])
|
||||
assert_template_result(' YES ','{% if "foo" %} YES {% endif %}')
|
||||
assert_template_result(' YES ','{% if foo.bar %} YES {% endif %}', 'foo' => {'bar' => true})
|
||||
assert_template_result(' YES ','{% if foo.bar %} YES {% endif %}', 'foo' => {'bar' => "text"})
|
||||
assert_template_result(' YES ','{% if foo.bar %} YES {% endif %}', 'foo' => {'bar' => 1 })
|
||||
assert_template_result(' YES ','{% if foo.bar %} YES {% endif %}', 'foo' => {'bar' => {} })
|
||||
assert_template_result(' YES ','{% if foo.bar %} YES {% endif %}', 'foo' => {'bar' => [] })
|
||||
|
||||
assert_template_result(' YES ', '{% if var %} NO {% else %} YES {% endif %}', 'var' => false)
|
||||
assert_template_result(' YES ', '{% if var %} NO {% else %} YES {% endif %}', 'var' => nil)
|
||||
assert_template_result(' YES ', '{% if var %} YES {% else %} NO {% endif %}', 'var' => true)
|
||||
assert_template_result(' YES ', '{% if "foo" %} YES {% else %} NO {% endif %}', 'var' => "text")
|
||||
assert_template_result(' YES ','{% if var %} NO {% else %} YES {% endif %}', 'var' => false)
|
||||
assert_template_result(' YES ','{% if var %} NO {% else %} YES {% endif %}', 'var' => nil)
|
||||
assert_template_result(' YES ','{% if var %} YES {% else %} NO {% endif %}', 'var' => true)
|
||||
assert_template_result(' YES ','{% if "foo" %} YES {% else %} NO {% endif %}', 'var' => "text")
|
||||
|
||||
assert_template_result(' YES ', '{% if foo.bar %} NO {% else %} YES {% endif %}', 'foo' => { 'bar' => false })
|
||||
assert_template_result(' YES ', '{% if foo.bar %} YES {% else %} NO {% endif %}', 'foo' => { 'bar' => true })
|
||||
assert_template_result(' YES ', '{% if foo.bar %} YES {% else %} NO {% endif %}', 'foo' => { 'bar' => "text" })
|
||||
assert_template_result(' YES ', '{% if foo.bar %} NO {% else %} YES {% endif %}', 'foo' => { 'notbar' => true })
|
||||
assert_template_result(' YES ', '{% if foo.bar %} NO {% else %} YES {% endif %}', 'foo' => {})
|
||||
assert_template_result(' YES ', '{% if foo.bar %} NO {% else %} YES {% endif %}', 'notfoo' => { 'bar' => true })
|
||||
assert_template_result(' YES ','{% if foo.bar %} NO {% else %} YES {% endif %}', 'foo' => {'bar' => false})
|
||||
assert_template_result(' YES ','{% if foo.bar %} YES {% else %} NO {% endif %}', 'foo' => {'bar' => true})
|
||||
assert_template_result(' YES ','{% if foo.bar %} YES {% else %} NO {% endif %}', 'foo' => {'bar' => "text"})
|
||||
assert_template_result(' YES ','{% if foo.bar %} NO {% else %} YES {% endif %}', 'foo' => {'notbar' => true})
|
||||
assert_template_result(' YES ','{% if foo.bar %} NO {% else %} YES {% endif %}', 'foo' => {})
|
||||
assert_template_result(' YES ','{% if foo.bar %} NO {% else %} YES {% endif %}', 'notfoo' => {'bar' => true})
|
||||
end
|
||||
|
||||
def test_nested_if
|
||||
@@ -109,58 +111,55 @@ class IfElseTagTest < Minitest::Test
|
||||
assert_template_result(' YES ', '{% if true %}{% if true %} YES {% else %} NO {% endif %}{% else %} NO {% endif %}')
|
||||
assert_template_result(' YES ', '{% if true %}{% if false %} NO {% else %} YES {% endif %}{% else %} NO {% endif %}')
|
||||
assert_template_result(' YES ', '{% if false %}{% if true %} NO {% else %} NONO {% endif %}{% else %} YES {% endif %}')
|
||||
|
||||
end
|
||||
|
||||
def test_comparisons_on_null
|
||||
assert_template_result('', '{% if null < 10 %} NO {% endif %}')
|
||||
assert_template_result('', '{% if null <= 10 %} NO {% endif %}')
|
||||
assert_template_result('', '{% if null >= 10 %} NO {% endif %}')
|
||||
assert_template_result('', '{% if null > 10 %} NO {% endif %}')
|
||||
assert_template_result('','{% if null < 10 %} NO {% endif %}')
|
||||
assert_template_result('','{% if null <= 10 %} NO {% endif %}')
|
||||
assert_template_result('','{% if null >= 10 %} NO {% endif %}')
|
||||
assert_template_result('','{% if null > 10 %} NO {% endif %}')
|
||||
|
||||
assert_template_result('', '{% if 10 < null %} NO {% endif %}')
|
||||
assert_template_result('', '{% if 10 <= null %} NO {% endif %}')
|
||||
assert_template_result('', '{% if 10 >= null %} NO {% endif %}')
|
||||
assert_template_result('', '{% if 10 > null %} NO {% endif %}')
|
||||
assert_template_result('','{% if 10 < null %} NO {% endif %}')
|
||||
assert_template_result('','{% if 10 <= null %} NO {% endif %}')
|
||||
assert_template_result('','{% if 10 >= null %} NO {% endif %}')
|
||||
assert_template_result('','{% if 10 > null %} NO {% endif %}')
|
||||
end
|
||||
|
||||
def test_else_if
|
||||
assert_template_result('0', '{% if 0 == 0 %}0{% elsif 1 == 1%}1{% else %}2{% endif %}')
|
||||
assert_template_result('1', '{% if 0 != 0 %}0{% elsif 1 == 1%}1{% else %}2{% endif %}')
|
||||
assert_template_result('2', '{% if 0 != 0 %}0{% elsif 1 != 1%}1{% else %}2{% endif %}')
|
||||
assert_template_result('0','{% if 0 == 0 %}0{% elsif 1 == 1%}1{% else %}2{% endif %}')
|
||||
assert_template_result('1','{% if 0 != 0 %}0{% elsif 1 == 1%}1{% else %}2{% endif %}')
|
||||
assert_template_result('2','{% if 0 != 0 %}0{% elsif 1 != 1%}1{% else %}2{% endif %}')
|
||||
|
||||
assert_template_result('elsif', '{% if false %}if{% elsif true %}elsif{% endif %}')
|
||||
assert_template_result('elsif','{% if false %}if{% elsif true %}elsif{% endif %}')
|
||||
end
|
||||
|
||||
def test_syntax_error_no_variable
|
||||
assert_raises(SyntaxError){ assert_template_result('', '{% if jerry == 1 %}') }
|
||||
assert_raise(SyntaxError){ assert_template_result('', '{% if jerry == 1 %}')}
|
||||
end
|
||||
|
||||
def test_syntax_error_no_expression
|
||||
assert_raises(SyntaxError) { assert_template_result('', '{% if %}') }
|
||||
assert_raise(SyntaxError) { assert_template_result('', '{% if %}') }
|
||||
end
|
||||
|
||||
def test_if_with_custom_condition
|
||||
original_op = Condition.operators['contains']
|
||||
Condition.operators['contains'] = :[]
|
||||
|
||||
assert_template_result('yes', %({% if 'bob' contains 'o' %}yes{% endif %}))
|
||||
assert_template_result('no', %({% if 'bob' contains 'f' %}yes{% else %}no{% endif %}))
|
||||
ensure
|
||||
Condition.operators['contains'] = original_op
|
||||
Condition.operators.delete 'contains'
|
||||
end
|
||||
|
||||
def test_operators_are_ignored_unless_isolated
|
||||
original_op = Condition.operators['contains']
|
||||
Condition.operators['contains'] = :[]
|
||||
|
||||
assert_template_result('yes',
|
||||
%({% if 'gnomeslab-and-or-liquid' contains 'gnomeslab-and-or-liquid' %}yes{% endif %}))
|
||||
ensure
|
||||
Condition.operators['contains'] = original_op
|
||||
%({% if 'gnomeslab-and-or-liquid' contains 'gnomeslab-and-or-liquid' %}yes{% endif %}))
|
||||
end
|
||||
|
||||
def test_operators_are_whitelisted
|
||||
assert_raises(SyntaxError) do
|
||||
assert_raise(SyntaxError) do
|
||||
assert_template_result('', %({% if 1 or throw or or 1 %}yes{% endif %}))
|
||||
end
|
||||
end
|
||||
|
||||
@@ -1,7 +1,7 @@
|
||||
require 'test_helper'
|
||||
|
||||
class TestFileSystem
|
||||
def read_template_file(template_path)
|
||||
def read_template_file(template_path, context)
|
||||
case template_path
|
||||
when "product"
|
||||
"Product: {{ product.title }} "
|
||||
@@ -27,9 +27,6 @@ class TestFileSystem
|
||||
when "pick_a_source"
|
||||
"from TestFileSystem"
|
||||
|
||||
when 'assignments'
|
||||
"{% assign foo = 'bar' %}"
|
||||
|
||||
else
|
||||
template_path
|
||||
end
|
||||
@@ -37,14 +34,14 @@ class TestFileSystem
|
||||
end
|
||||
|
||||
class OtherFileSystem
|
||||
def read_template_file(template_path)
|
||||
def read_template_file(template_path, context)
|
||||
'from OtherFileSystem'
|
||||
end
|
||||
end
|
||||
|
||||
class CountingFileSystem
|
||||
attr_reader :count
|
||||
def read_template_file(template_path)
|
||||
def read_template_file(template_path, context)
|
||||
@count ||= 0
|
||||
@count += 1
|
||||
'from CountingFileSystem'
|
||||
@@ -68,7 +65,7 @@ class CustomInclude < Liquid::Tag
|
||||
end
|
||||
end
|
||||
|
||||
class IncludeTagTest < Minitest::Test
|
||||
class IncludeTagTest < Test::Unit::TestCase
|
||||
include Liquid
|
||||
|
||||
def setup
|
||||
@@ -77,22 +74,23 @@ class IncludeTagTest < Minitest::Test
|
||||
|
||||
def test_include_tag_looks_for_file_system_in_registers_first
|
||||
assert_equal 'from OtherFileSystem',
|
||||
Template.parse("{% include 'pick_a_source' %}").render!({}, :registers => { :file_system => OtherFileSystem.new })
|
||||
Template.parse("{% include 'pick_a_source' %}").render!({}, :registers => {:file_system => OtherFileSystem.new})
|
||||
end
|
||||
|
||||
|
||||
def test_include_tag_with
|
||||
assert_template_result "Product: Draft 151cm ",
|
||||
"{% include 'product' with products[0] %}", "products" => [ { 'title' => 'Draft 151cm' }, { 'title' => 'Element 155cm' } ]
|
||||
"{% include 'product' with products[0] %}", "products" => [ {'title' => 'Draft 151cm'}, {'title' => 'Element 155cm'} ]
|
||||
end
|
||||
|
||||
def test_include_tag_with_default_name
|
||||
assert_template_result "Product: Draft 151cm ",
|
||||
"{% include 'product' %}", "product" => { 'title' => 'Draft 151cm' }
|
||||
"{% include 'product' %}", "product" => {'title' => 'Draft 151cm'}
|
||||
end
|
||||
|
||||
def test_include_tag_for
|
||||
assert_template_result "Product: Draft 151cm Product: Element 155cm ",
|
||||
"{% include 'product' for products %}", "products" => [ { 'title' => 'Draft 151cm' }, { 'title' => 'Element 155cm' } ]
|
||||
"{% include 'product' for products %}", "products" => [ {'title' => 'Draft 151cm'}, {'title' => 'Element 155cm'} ]
|
||||
end
|
||||
|
||||
def test_include_tag_with_local_variables
|
||||
@@ -107,11 +105,7 @@ class IncludeTagTest < Minitest::Test
|
||||
def test_include_tag_with_multiple_local_variables_from_context
|
||||
assert_template_result "Locale: test123 test321",
|
||||
"{% include 'locale_variables' echo1: echo1, echo2: more_echos.echo2 %}",
|
||||
'echo1' => 'test123', 'more_echos' => { "echo2" => 'test321' }
|
||||
end
|
||||
|
||||
def test_included_templates_assigns_variables
|
||||
assert_template_result "bar", "{% include 'assignments' %}{{ foo }}"
|
||||
'echo1' => 'test123', 'more_echos' => { "echo2" => 'test321'}
|
||||
end
|
||||
|
||||
def test_nested_include_tag
|
||||
@@ -122,24 +116,38 @@ class IncludeTagTest < Minitest::Test
|
||||
|
||||
def test_nested_include_with_variable
|
||||
assert_template_result "Product: Draft 151cm details ",
|
||||
"{% include 'nested_product_template' with product %}", "product" => { "title" => 'Draft 151cm' }
|
||||
"{% include 'nested_product_template' with product %}", "product" => {"title" => 'Draft 151cm'}
|
||||
|
||||
assert_template_result "Product: Draft 151cm details Product: Element 155cm details ",
|
||||
"{% include 'nested_product_template' for products %}", "products" => [{ "title" => 'Draft 151cm' }, { "title" => 'Element 155cm' }]
|
||||
"{% include 'nested_product_template' for products %}", "products" => [{"title" => 'Draft 151cm'}, {"title" => 'Element 155cm'}]
|
||||
end
|
||||
|
||||
def test_recursively_included_template_does_not_produce_endless_loop
|
||||
|
||||
infinite_file_system = Class.new do
|
||||
def read_template_file(template_path)
|
||||
def read_template_file(template_path, context)
|
||||
"-{% include 'loop' %}"
|
||||
end
|
||||
end
|
||||
|
||||
Liquid::Template.file_system = infinite_file_system.new
|
||||
|
||||
assert_raises(Liquid::StackLevelError, SystemStackError) do
|
||||
assert_raise(Liquid::StackLevelError) do
|
||||
Template.parse("{% include 'loop' %}").render!
|
||||
end
|
||||
|
||||
end
|
||||
|
||||
def test_backwards_compatability_support_for_overridden_read_template_file
|
||||
infinite_file_system = Class.new do
|
||||
def read_template_file(template_path) # testing only one argument here.
|
||||
"- hi mom"
|
||||
end
|
||||
end
|
||||
|
||||
Liquid::Template.file_system = infinite_file_system.new
|
||||
|
||||
Template.parse("{% include 'hi_mom' %}").render!
|
||||
end
|
||||
|
||||
def test_dynamically_choosen_template
|
||||
@@ -147,24 +155,24 @@ class IncludeTagTest < Minitest::Test
|
||||
assert_template_result "Test321", "{% include template %}", "template" => 'Test321'
|
||||
|
||||
assert_template_result "Product: Draft 151cm ", "{% include template for product %}",
|
||||
"template" => 'product', 'product' => { 'title' => 'Draft 151cm' }
|
||||
"template" => 'product', 'product' => { 'title' => 'Draft 151cm'}
|
||||
end
|
||||
|
||||
def test_include_tag_caches_second_read_of_same_partial
|
||||
file_system = CountingFileSystem.new
|
||||
assert_equal 'from CountingFileSystemfrom CountingFileSystem',
|
||||
Template.parse("{% include 'pick_a_source' %}{% include 'pick_a_source' %}").render!({}, :registers => { :file_system => file_system })
|
||||
Template.parse("{% include 'pick_a_source' %}{% include 'pick_a_source' %}").render!({}, :registers => {:file_system => file_system})
|
||||
assert_equal 1, file_system.count
|
||||
end
|
||||
|
||||
def test_include_tag_doesnt_cache_partials_across_renders
|
||||
file_system = CountingFileSystem.new
|
||||
assert_equal 'from CountingFileSystem',
|
||||
Template.parse("{% include 'pick_a_source' %}").render!({}, :registers => { :file_system => file_system })
|
||||
Template.parse("{% include 'pick_a_source' %}").render!({}, :registers => {:file_system => file_system})
|
||||
assert_equal 1, file_system.count
|
||||
|
||||
assert_equal 'from CountingFileSystem',
|
||||
Template.parse("{% include 'pick_a_source' %}").render!({}, :registers => { :file_system => file_system })
|
||||
Template.parse("{% include 'pick_a_source' %}").render!({}, :registers => {:file_system => file_system})
|
||||
assert_equal 2, file_system.count
|
||||
end
|
||||
|
||||
@@ -201,27 +209,4 @@ class IncludeTagTest < Minitest::Test
|
||||
a.render!
|
||||
assert_empty a.errors
|
||||
end
|
||||
|
||||
def test_passing_options_to_included_templates
|
||||
assert_raises(Liquid::SyntaxError) do
|
||||
Template.parse("{% include template %}", error_mode: :strict).render!("template" => '{{ "X" || downcase }}')
|
||||
end
|
||||
with_error_mode(:lax) do
|
||||
assert_equal 'x', Template.parse("{% include template %}", error_mode: :strict, include_options_blacklist: true).render!("template" => '{{ "X" || downcase }}')
|
||||
end
|
||||
assert_raises(Liquid::SyntaxError) do
|
||||
Template.parse("{% include template %}", error_mode: :strict, include_options_blacklist: [:locale]).render!("template" => '{{ "X" || downcase }}')
|
||||
end
|
||||
with_error_mode(:lax) do
|
||||
assert_equal 'x', Template.parse("{% include template %}", error_mode: :strict, include_options_blacklist: [:error_mode]).render!("template" => '{{ "X" || downcase }}')
|
||||
end
|
||||
end
|
||||
|
||||
def test_including_via_variable_value
|
||||
assert_template_result "from TestFileSystem", "{% assign page = 'pick_a_source' %}{% include page %}"
|
||||
|
||||
assert_template_result "Product: Draft 151cm ", "{% assign page = 'product' %}{% include page %}", "product" => { 'title' => 'Draft 151cm' }
|
||||
|
||||
assert_template_result "Product: Draft 151cm ", "{% assign page = 'product' %}{% include page for foo %}", "foo" => { 'title' => 'Draft 151cm' }
|
||||
end
|
||||
end # IncludeTagTest
|
||||
|
||||
@@ -1,24 +1,24 @@
|
||||
require 'test_helper'
|
||||
|
||||
class IncrementTagTest < Minitest::Test
|
||||
class IncrementTagTest < Test::Unit::TestCase
|
||||
include Liquid
|
||||
|
||||
def test_inc
|
||||
assert_template_result('0', '{%increment port %}', {})
|
||||
assert_template_result('0 1', '{%increment port %} {%increment port%}', {})
|
||||
assert_template_result('0','{%increment port %}', {})
|
||||
assert_template_result('0 1','{%increment port %} {%increment port%}', {})
|
||||
assert_template_result('0 0 1 2 1',
|
||||
'{%increment port %} {%increment starboard%} ' \
|
||||
'{%increment port %} {%increment port%} ' \
|
||||
'{%increment starboard %}', {})
|
||||
'{%increment port %} {%increment starboard%} ' +
|
||||
'{%increment port %} {%increment port%} ' +
|
||||
'{%increment starboard %}', {})
|
||||
end
|
||||
|
||||
def test_dec
|
||||
assert_template_result('9', '{%decrement port %}', { 'port' => 10 })
|
||||
assert_template_result('-1 -2', '{%decrement port %} {%decrement port%}', {})
|
||||
assert_template_result('9','{%decrement port %}', { 'port' => 10})
|
||||
assert_template_result('-1 -2','{%decrement port %} {%decrement port%}', {})
|
||||
assert_template_result('1 5 2 2 5',
|
||||
'{%increment port %} {%increment starboard%} ' \
|
||||
'{%increment port %} {%decrement port%} ' \
|
||||
'{%decrement starboard %}', { 'port' => 1, 'starboard' => 5 })
|
||||
'{%increment port %} {%increment starboard%} ' +
|
||||
'{%increment port %} {%decrement port%} ' +
|
||||
'{%decrement starboard %}', { 'port' => 1, 'starboard' => 5 })
|
||||
end
|
||||
|
||||
end
|
||||
|
||||
@@ -1,11 +1,11 @@
|
||||
require 'test_helper'
|
||||
|
||||
class RawTagTest < Minitest::Test
|
||||
class RawTagTest < Test::Unit::TestCase
|
||||
include Liquid
|
||||
|
||||
def test_tag_in_raw
|
||||
assert_template_result '{% comment %} test {% endcomment %}',
|
||||
'{% raw %}{% comment %} test {% endcomment %}{% endraw %}'
|
||||
'{% raw %}{% comment %} test {% endcomment %}{% endraw %}'
|
||||
end
|
||||
|
||||
def test_output_in_raw
|
||||
|
||||
@@ -1,120 +1,120 @@
|
||||
require 'test_helper'
|
||||
|
||||
class StandardTagTest < Minitest::Test
|
||||
class StandardTagTest < Test::Unit::TestCase
|
||||
include Liquid
|
||||
|
||||
def test_no_transform
|
||||
assert_template_result('this text should come out of the template without change...',
|
||||
'this text should come out of the template without change...')
|
||||
'this text should come out of the template without change...')
|
||||
|
||||
assert_template_result('blah', 'blah')
|
||||
assert_template_result('<blah>', '<blah>')
|
||||
assert_template_result('|,.:', '|,.:')
|
||||
assert_template_result('', '')
|
||||
assert_template_result('blah','blah')
|
||||
assert_template_result('<blah>','<blah>')
|
||||
assert_template_result('|,.:','|,.:')
|
||||
assert_template_result('','')
|
||||
|
||||
text = %(this shouldnt see any transformation either but has multiple lines
|
||||
as you can clearly see here ...)
|
||||
assert_template_result(text, text)
|
||||
text = %|this shouldnt see any transformation either but has multiple lines
|
||||
as you can clearly see here ...|
|
||||
assert_template_result(text,text)
|
||||
end
|
||||
|
||||
def test_has_a_block_which_does_nothing
|
||||
assert_template_result(%(the comment block should be removed .. right?),
|
||||
%(the comment block should be removed {%comment%} be gone.. {%endcomment%} .. right?))
|
||||
assert_template_result(%|the comment block should be removed .. right?|,
|
||||
%|the comment block should be removed {%comment%} be gone.. {%endcomment%} .. right?|)
|
||||
|
||||
assert_template_result('', '{%comment%}{%endcomment%}')
|
||||
assert_template_result('', '{%comment%}{% endcomment %}')
|
||||
assert_template_result('', '{% comment %}{%endcomment%}')
|
||||
assert_template_result('', '{% comment %}{% endcomment %}')
|
||||
assert_template_result('', '{%comment%}comment{%endcomment%}')
|
||||
assert_template_result('', '{% comment %}comment{% endcomment %}')
|
||||
assert_template_result('', '{% comment %} 1 {% comment %} 2 {% endcomment %} 3 {% endcomment %}')
|
||||
assert_template_result('','{%comment%}{%endcomment%}')
|
||||
assert_template_result('','{%comment%}{% endcomment %}')
|
||||
assert_template_result('','{% comment %}{%endcomment%}')
|
||||
assert_template_result('','{% comment %}{% endcomment %}')
|
||||
assert_template_result('','{%comment%}comment{%endcomment%}')
|
||||
assert_template_result('','{% comment %}comment{% endcomment %}')
|
||||
assert_template_result('','{% comment %} 1 {% comment %} 2 {% endcomment %} 3 {% endcomment %}')
|
||||
|
||||
assert_template_result('', '{%comment%}{%blabla%}{%endcomment%}')
|
||||
assert_template_result('', '{% comment %}{% blabla %}{% endcomment %}')
|
||||
assert_template_result('', '{%comment%}{% endif %}{%endcomment%}')
|
||||
assert_template_result('', '{% comment %}{% endwhatever %}{% endcomment %}')
|
||||
assert_template_result('', '{% comment %}{% raw %} {{%%%%}} }} { {% endcomment %} {% comment {% endraw %} {% endcomment %}')
|
||||
assert_template_result('','{%comment%}{%blabla%}{%endcomment%}')
|
||||
assert_template_result('','{% comment %}{% blabla %}{% endcomment %}')
|
||||
assert_template_result('','{%comment%}{% endif %}{%endcomment%}')
|
||||
assert_template_result('','{% comment %}{% endwhatever %}{% endcomment %}')
|
||||
assert_template_result('','{% comment %}{% raw %} {{%%%%}} }} { {% endcomment %} {% comment {% endraw %} {% endcomment %}')
|
||||
|
||||
assert_template_result('foobar', 'foo{%comment%}comment{%endcomment%}bar')
|
||||
assert_template_result('foobar', 'foo{% comment %}comment{% endcomment %}bar')
|
||||
assert_template_result('foobar', 'foo{%comment%} comment {%endcomment%}bar')
|
||||
assert_template_result('foobar', 'foo{% comment %} comment {% endcomment %}bar')
|
||||
assert_template_result('foobar','foo{%comment%}comment{%endcomment%}bar')
|
||||
assert_template_result('foobar','foo{% comment %}comment{% endcomment %}bar')
|
||||
assert_template_result('foobar','foo{%comment%} comment {%endcomment%}bar')
|
||||
assert_template_result('foobar','foo{% comment %} comment {% endcomment %}bar')
|
||||
|
||||
assert_template_result('foo bar', 'foo {%comment%} {%endcomment%} bar')
|
||||
assert_template_result('foo bar', 'foo {%comment%}comment{%endcomment%} bar')
|
||||
assert_template_result('foo bar', 'foo {%comment%} comment {%endcomment%} bar')
|
||||
assert_template_result('foo bar','foo {%comment%} {%endcomment%} bar')
|
||||
assert_template_result('foo bar','foo {%comment%}comment{%endcomment%} bar')
|
||||
assert_template_result('foo bar','foo {%comment%} comment {%endcomment%} bar')
|
||||
|
||||
assert_template_result('foobar', 'foo{%comment%}
|
||||
assert_template_result('foobar','foo{%comment%}
|
||||
{%endcomment%}bar')
|
||||
end
|
||||
|
||||
def test_hyphenated_assign
|
||||
assigns = { 'a-b' => '1' }
|
||||
assigns = {'a-b' => '1' }
|
||||
assert_template_result('a-b:1 a-b:2', 'a-b:{{a-b}} {%assign a-b = 2 %}a-b:{{a-b}}', assigns)
|
||||
end
|
||||
|
||||
def test_assign_with_colon_and_spaces
|
||||
assigns = { 'var' => { 'a:b c' => { 'paged' => '1' } } }
|
||||
assigns = {'var' => {'a:b c' => {'paged' => '1' }}}
|
||||
assert_template_result('var2: 1', '{%assign var2 = var["a:b c"].paged %}var2: {{var2}}', assigns)
|
||||
end
|
||||
|
||||
def test_capture
|
||||
assigns = { 'var' => 'content' }
|
||||
assigns = {'var' => 'content' }
|
||||
assert_template_result('content foo content foo ',
|
||||
'{{ var2 }}{% capture var2 %}{{ var }} foo {% endcapture %}{{ var2 }}{{ var2 }}',
|
||||
assigns)
|
||||
'{{ var2 }}{% capture var2 %}{{ var }} foo {% endcapture %}{{ var2 }}{{ var2 }}',
|
||||
assigns)
|
||||
end
|
||||
|
||||
def test_capture_detects_bad_syntax
|
||||
assert_raises(SyntaxError) do
|
||||
assert_raise(SyntaxError) do
|
||||
assert_template_result('content foo content foo ',
|
||||
'{{ var2 }}{% capture %}{{ var }} foo {% endcapture %}{{ var2 }}{{ var2 }}',
|
||||
{ 'var' => 'content' })
|
||||
'{{ var2 }}{% capture %}{{ var }} foo {% endcapture %}{{ var2 }}{{ var2 }}',
|
||||
{'var' => 'content' })
|
||||
end
|
||||
end
|
||||
|
||||
def test_case
|
||||
assigns = { 'condition' => 2 }
|
||||
assigns = {'condition' => 2 }
|
||||
assert_template_result(' its 2 ',
|
||||
'{% case condition %}{% when 1 %} its 1 {% when 2 %} its 2 {% endcase %}',
|
||||
assigns)
|
||||
'{% case condition %}{% when 1 %} its 1 {% when 2 %} its 2 {% endcase %}',
|
||||
assigns)
|
||||
|
||||
assigns = { 'condition' => 1 }
|
||||
assigns = {'condition' => 1 }
|
||||
assert_template_result(' its 1 ',
|
||||
'{% case condition %}{% when 1 %} its 1 {% when 2 %} its 2 {% endcase %}',
|
||||
assigns)
|
||||
'{% case condition %}{% when 1 %} its 1 {% when 2 %} its 2 {% endcase %}',
|
||||
assigns)
|
||||
|
||||
assigns = { 'condition' => 3 }
|
||||
assigns = {'condition' => 3 }
|
||||
assert_template_result('',
|
||||
'{% case condition %}{% when 1 %} its 1 {% when 2 %} its 2 {% endcase %}',
|
||||
assigns)
|
||||
'{% case condition %}{% when 1 %} its 1 {% when 2 %} its 2 {% endcase %}',
|
||||
assigns)
|
||||
|
||||
assigns = { 'condition' => "string here" }
|
||||
assigns = {'condition' => "string here" }
|
||||
assert_template_result(' hit ',
|
||||
'{% case condition %}{% when "string here" %} hit {% endcase %}',
|
||||
assigns)
|
||||
'{% case condition %}{% when "string here" %} hit {% endcase %}',
|
||||
assigns)
|
||||
|
||||
assigns = { 'condition' => "bad string here" }
|
||||
assigns = {'condition' => "bad string here" }
|
||||
assert_template_result('',
|
||||
'{% case condition %}{% when "string here" %} hit {% endcase %}',\
|
||||
assigns)
|
||||
'{% case condition %}{% when "string here" %} hit {% endcase %}',\
|
||||
assigns)
|
||||
end
|
||||
|
||||
def test_case_with_else
|
||||
assigns = { 'condition' => 5 }
|
||||
assigns = {'condition' => 5 }
|
||||
assert_template_result(' hit ',
|
||||
'{% case condition %}{% when 5 %} hit {% else %} else {% endcase %}',
|
||||
assigns)
|
||||
'{% case condition %}{% when 5 %} hit {% else %} else {% endcase %}',
|
||||
assigns)
|
||||
|
||||
assigns = { 'condition' => 6 }
|
||||
assigns = {'condition' => 6 }
|
||||
assert_template_result(' else ',
|
||||
'{% case condition %}{% when 5 %} hit {% else %} else {% endcase %}',
|
||||
assigns)
|
||||
'{% case condition %}{% when 5 %} hit {% else %} else {% endcase %}',
|
||||
assigns)
|
||||
|
||||
assigns = { 'condition' => 6 }
|
||||
assigns = {'condition' => 6 }
|
||||
assert_template_result(' else ',
|
||||
'{% case condition %} {% when 5 %} hit {% else %} else {% endcase %}',
|
||||
assigns)
|
||||
'{% case condition %} {% when 5 %} hit {% else %} else {% endcase %}',
|
||||
assigns)
|
||||
end
|
||||
|
||||
def test_case_on_size
|
||||
@@ -128,87 +128,87 @@ class StandardTagTest < Minitest::Test
|
||||
|
||||
def test_case_on_size_with_else
|
||||
assert_template_result('else',
|
||||
'{% case a.size %}{% when 1 %}1{% when 2 %}2{% else %}else{% endcase %}',
|
||||
'a' => [])
|
||||
'{% case a.size %}{% when 1 %}1{% when 2 %}2{% else %}else{% endcase %}',
|
||||
'a' => [])
|
||||
|
||||
assert_template_result('1',
|
||||
'{% case a.size %}{% when 1 %}1{% when 2 %}2{% else %}else{% endcase %}',
|
||||
'a' => [1])
|
||||
'{% case a.size %}{% when 1 %}1{% when 2 %}2{% else %}else{% endcase %}',
|
||||
'a' => [1])
|
||||
|
||||
assert_template_result('2',
|
||||
'{% case a.size %}{% when 1 %}1{% when 2 %}2{% else %}else{% endcase %}',
|
||||
'a' => [1, 1])
|
||||
'{% case a.size %}{% when 1 %}1{% when 2 %}2{% else %}else{% endcase %}',
|
||||
'a' => [1, 1])
|
||||
|
||||
assert_template_result('else',
|
||||
'{% case a.size %}{% when 1 %}1{% when 2 %}2{% else %}else{% endcase %}',
|
||||
'a' => [1, 1, 1])
|
||||
'{% case a.size %}{% when 1 %}1{% when 2 %}2{% else %}else{% endcase %}',
|
||||
'a' => [1, 1, 1])
|
||||
|
||||
assert_template_result('else',
|
||||
'{% case a.size %}{% when 1 %}1{% when 2 %}2{% else %}else{% endcase %}',
|
||||
'a' => [1, 1, 1, 1])
|
||||
'{% case a.size %}{% when 1 %}1{% when 2 %}2{% else %}else{% endcase %}',
|
||||
'a' => [1, 1, 1, 1])
|
||||
|
||||
assert_template_result('else',
|
||||
'{% case a.size %}{% when 1 %}1{% when 2 %}2{% else %}else{% endcase %}',
|
||||
'a' => [1, 1, 1, 1, 1])
|
||||
'{% case a.size %}{% when 1 %}1{% when 2 %}2{% else %}else{% endcase %}',
|
||||
'a' => [1, 1, 1, 1, 1])
|
||||
end
|
||||
|
||||
def test_case_on_length_with_else
|
||||
assert_template_result('else',
|
||||
'{% case a.empty? %}{% when true %}true{% when false %}false{% else %}else{% endcase %}',
|
||||
{})
|
||||
'{% case a.empty? %}{% when true %}true{% when false %}false{% else %}else{% endcase %}',
|
||||
{})
|
||||
|
||||
assert_template_result('false',
|
||||
'{% case false %}{% when true %}true{% when false %}false{% else %}else{% endcase %}',
|
||||
{})
|
||||
'{% case false %}{% when true %}true{% when false %}false{% else %}else{% endcase %}',
|
||||
{})
|
||||
|
||||
assert_template_result('true',
|
||||
'{% case true %}{% when true %}true{% when false %}false{% else %}else{% endcase %}',
|
||||
{})
|
||||
'{% case true %}{% when true %}true{% when false %}false{% else %}else{% endcase %}',
|
||||
{})
|
||||
|
||||
assert_template_result('else',
|
||||
'{% case NULL %}{% when true %}true{% when false %}false{% else %}else{% endcase %}',
|
||||
{})
|
||||
'{% case NULL %}{% when true %}true{% when false %}false{% else %}else{% endcase %}',
|
||||
{})
|
||||
end
|
||||
|
||||
def test_assign_from_case
|
||||
# Example from the shopify forums
|
||||
code = "{% case collection.handle %}{% when 'menswear-jackets' %}{% assign ptitle = 'menswear' %}{% when 'menswear-t-shirts' %}{% assign ptitle = 'menswear' %}{% else %}{% assign ptitle = 'womenswear' %}{% endcase %}{{ ptitle }}"
|
||||
code = %q({% case collection.handle %}{% when 'menswear-jackets' %}{% assign ptitle = 'menswear' %}{% when 'menswear-t-shirts' %}{% assign ptitle = 'menswear' %}{% else %}{% assign ptitle = 'womenswear' %}{% endcase %}{{ ptitle }})
|
||||
template = Liquid::Template.parse(code)
|
||||
assert_equal "menswear", template.render!("collection" => { 'handle' => 'menswear-jackets' })
|
||||
assert_equal "menswear", template.render!("collection" => { 'handle' => 'menswear-t-shirts' })
|
||||
assert_equal "womenswear", template.render!("collection" => { 'handle' => 'x' })
|
||||
assert_equal "womenswear", template.render!("collection" => { 'handle' => 'y' })
|
||||
assert_equal "womenswear", template.render!("collection" => { 'handle' => 'z' })
|
||||
assert_equal "menswear", template.render!("collection" => {'handle' => 'menswear-jackets'})
|
||||
assert_equal "menswear", template.render!("collection" => {'handle' => 'menswear-t-shirts'})
|
||||
assert_equal "womenswear", template.render!("collection" => {'handle' => 'x'})
|
||||
assert_equal "womenswear", template.render!("collection" => {'handle' => 'y'})
|
||||
assert_equal "womenswear", template.render!("collection" => {'handle' => 'z'})
|
||||
end
|
||||
|
||||
def test_case_when_or
|
||||
code = '{% case condition %}{% when 1 or 2 or 3 %} its 1 or 2 or 3 {% when 4 %} its 4 {% endcase %}'
|
||||
assert_template_result(' its 1 or 2 or 3 ', code, { 'condition' => 1 })
|
||||
assert_template_result(' its 1 or 2 or 3 ', code, { 'condition' => 2 })
|
||||
assert_template_result(' its 1 or 2 or 3 ', code, { 'condition' => 3 })
|
||||
assert_template_result(' its 4 ', code, { 'condition' => 4 })
|
||||
assert_template_result('', code, { 'condition' => 5 })
|
||||
assert_template_result(' its 1 or 2 or 3 ', code, {'condition' => 1 })
|
||||
assert_template_result(' its 1 or 2 or 3 ', code, {'condition' => 2 })
|
||||
assert_template_result(' its 1 or 2 or 3 ', code, {'condition' => 3 })
|
||||
assert_template_result(' its 4 ', code, {'condition' => 4 })
|
||||
assert_template_result('', code, {'condition' => 5 })
|
||||
|
||||
code = '{% case condition %}{% when 1 or "string" or null %} its 1 or 2 or 3 {% when 4 %} its 4 {% endcase %}'
|
||||
assert_template_result(' its 1 or 2 or 3 ', code, { 'condition' => 1 })
|
||||
assert_template_result(' its 1 or 2 or 3 ', code, { 'condition' => 'string' })
|
||||
assert_template_result(' its 1 or 2 or 3 ', code, { 'condition' => nil })
|
||||
assert_template_result('', code, { 'condition' => 'something else' })
|
||||
assert_template_result(' its 1 or 2 or 3 ', code, {'condition' => 1 })
|
||||
assert_template_result(' its 1 or 2 or 3 ', code, {'condition' => 'string' })
|
||||
assert_template_result(' its 1 or 2 or 3 ', code, {'condition' => nil })
|
||||
assert_template_result('', code, {'condition' => 'something else' })
|
||||
end
|
||||
|
||||
def test_case_when_comma
|
||||
code = '{% case condition %}{% when 1, 2, 3 %} its 1 or 2 or 3 {% when 4 %} its 4 {% endcase %}'
|
||||
assert_template_result(' its 1 or 2 or 3 ', code, { 'condition' => 1 })
|
||||
assert_template_result(' its 1 or 2 or 3 ', code, { 'condition' => 2 })
|
||||
assert_template_result(' its 1 or 2 or 3 ', code, { 'condition' => 3 })
|
||||
assert_template_result(' its 4 ', code, { 'condition' => 4 })
|
||||
assert_template_result('', code, { 'condition' => 5 })
|
||||
assert_template_result(' its 1 or 2 or 3 ', code, {'condition' => 1 })
|
||||
assert_template_result(' its 1 or 2 or 3 ', code, {'condition' => 2 })
|
||||
assert_template_result(' its 1 or 2 or 3 ', code, {'condition' => 3 })
|
||||
assert_template_result(' its 4 ', code, {'condition' => 4 })
|
||||
assert_template_result('', code, {'condition' => 5 })
|
||||
|
||||
code = '{% case condition %}{% when 1, "string", null %} its 1 or 2 or 3 {% when 4 %} its 4 {% endcase %}'
|
||||
assert_template_result(' its 1 or 2 or 3 ', code, { 'condition' => 1 })
|
||||
assert_template_result(' its 1 or 2 or 3 ', code, { 'condition' => 'string' })
|
||||
assert_template_result(' its 1 or 2 or 3 ', code, { 'condition' => nil })
|
||||
assert_template_result('', code, { 'condition' => 'something else' })
|
||||
assert_template_result(' its 1 or 2 or 3 ', code, {'condition' => 1 })
|
||||
assert_template_result(' its 1 or 2 or 3 ', code, {'condition' => 'string' })
|
||||
assert_template_result(' its 1 or 2 or 3 ', code, {'condition' => nil })
|
||||
assert_template_result('', code, {'condition' => 'something else' })
|
||||
end
|
||||
|
||||
def test_assign
|
||||
@@ -229,21 +229,22 @@ class StandardTagTest < Minitest::Test
|
||||
end
|
||||
|
||||
def test_case_detects_bad_syntax
|
||||
assert_raises(SyntaxError) do
|
||||
assert_raise(SyntaxError) do
|
||||
assert_template_result('', '{% case false %}{% when %}true{% endcase %}', {})
|
||||
end
|
||||
|
||||
assert_raises(SyntaxError) do
|
||||
assert_raise(SyntaxError) do
|
||||
assert_template_result('', '{% case false %}{% huh %}true{% endcase %}', {})
|
||||
end
|
||||
|
||||
end
|
||||
|
||||
def test_cycle
|
||||
assert_template_result('one', '{%cycle "one", "two"%}')
|
||||
assert_template_result('one two', '{%cycle "one", "two"%} {%cycle "one", "two"%}')
|
||||
assert_template_result(' two', '{%cycle "", "two"%} {%cycle "", "two"%}')
|
||||
assert_template_result('one','{%cycle "one", "two"%}')
|
||||
assert_template_result('one two','{%cycle "one", "two"%} {%cycle "one", "two"%}')
|
||||
assert_template_result(' two','{%cycle "", "two"%} {%cycle "", "two"%}')
|
||||
|
||||
assert_template_result('one two one', '{%cycle "one", "two"%} {%cycle "one", "two"%} {%cycle "one", "two"%}')
|
||||
assert_template_result('one two one','{%cycle "one", "two"%} {%cycle "one", "two"%} {%cycle "one", "two"%}')
|
||||
|
||||
assert_template_result('text-align: left text-align: right',
|
||||
'{%cycle "text-align: left", "text-align: right" %} {%cycle "text-align: left", "text-align: right"%}')
|
||||
@@ -260,18 +261,18 @@ class StandardTagTest < Minitest::Test
|
||||
end
|
||||
|
||||
def test_multiple_named_cycles_with_names_from_context
|
||||
assigns = { "var1" => 1, "var2" => 2 }
|
||||
assigns = {"var1" => 1, "var2" => 2 }
|
||||
assert_template_result('one one two two one one',
|
||||
'{%cycle var1: "one", "two" %} {%cycle var2: "one", "two" %} {%cycle var1: "one", "two" %} {%cycle var2: "one", "two" %} {%cycle var1: "one", "two" %} {%cycle var2: "one", "two" %}', assigns)
|
||||
end
|
||||
|
||||
def test_size_of_array
|
||||
assigns = { "array" => [1, 2, 3, 4] }
|
||||
assigns = {"array" => [1,2,3,4]}
|
||||
assert_template_result('array has 4 elements', "array has {{ array.size }} elements", assigns)
|
||||
end
|
||||
|
||||
def test_size_of_hash
|
||||
assigns = { "hash" => { :a => 1, :b => 2, :c => 3, :d => 4 } }
|
||||
assigns = {"hash" => {:a => 1, :b => 2, :c=> 3, :d => 4}}
|
||||
assert_template_result('hash has 4 elements', "hash has {{ hash.size }} elements", assigns)
|
||||
end
|
||||
|
||||
@@ -283,11 +284,11 @@ class StandardTagTest < Minitest::Test
|
||||
end
|
||||
|
||||
def test_ifchanged
|
||||
assigns = { 'array' => [ 1, 1, 2, 2, 3, 3] }
|
||||
assert_template_result('123', '{%for item in array%}{%ifchanged%}{{item}}{% endifchanged %}{%endfor%}', assigns)
|
||||
assigns = {'array' => [ 1, 1, 2, 2, 3, 3] }
|
||||
assert_template_result('123','{%for item in array%}{%ifchanged%}{{item}}{% endifchanged %}{%endfor%}',assigns)
|
||||
|
||||
assigns = { 'array' => [ 1, 1, 1, 1] }
|
||||
assert_template_result('1', '{%for item in array%}{%ifchanged%}{{item}}{% endifchanged %}{%endfor%}', assigns)
|
||||
assigns = {'array' => [ 1, 1, 1, 1] }
|
||||
assert_template_result('1','{%for item in array%}{%ifchanged%}{{item}}{% endifchanged %}{%endfor%}',assigns)
|
||||
end
|
||||
|
||||
def test_multiline_tag
|
||||
|
||||
@@ -1,6 +1,6 @@
|
||||
require 'test_helper'
|
||||
|
||||
class StatementsTest < Minitest::Test
|
||||
class StatementsTest < Test::Unit::TestCase
|
||||
include Liquid
|
||||
|
||||
def test_true_eql_true
|
||||
@@ -37,6 +37,7 @@ class StatementsTest < Minitest::Test
|
||||
text = ' {% if null <= 0 %} true {% else %} false {% endif %} '
|
||||
assert_template_result ' false ', text
|
||||
|
||||
|
||||
text = ' {% if 0 <= null %} true {% else %} false {% endif %} '
|
||||
assert_template_result ' false ', text
|
||||
end
|
||||
@@ -71,17 +72,18 @@ class StatementsTest < Minitest::Test
|
||||
assert_template_result ' true ', text, 'var' => 'hello there!'
|
||||
end
|
||||
|
||||
|
||||
def test_var_and_long_string_are_equal_backwards
|
||||
text = " {% if 'hello there!' == var %} true {% else %} false {% endif %} "
|
||||
assert_template_result ' true ', text, 'var' => 'hello there!'
|
||||
end
|
||||
|
||||
# def test_is_nil
|
||||
#def test_is_nil
|
||||
# text = %| {% if var != nil %} true {% else %} false {% end %} |
|
||||
# @template.assigns = { 'var' => 'hello there!'}
|
||||
# expected = %| true |
|
||||
# assert_equal expected, @template.parse(text)
|
||||
# end
|
||||
#end
|
||||
|
||||
def test_is_collection_empty
|
||||
text = ' {% if array == empty %} true {% else %} false {% endif %} '
|
||||
@@ -90,7 +92,7 @@ class StatementsTest < Minitest::Test
|
||||
|
||||
def test_is_not_collection_empty
|
||||
text = ' {% if array == empty %} true {% else %} false {% endif %} '
|
||||
assert_template_result ' false ', text, 'array' => [1, 2, 3]
|
||||
assert_template_result ' false ', text, 'array' => [1,2,3]
|
||||
end
|
||||
|
||||
def test_nil
|
||||
|
||||
@@ -1,6 +1,6 @@
|
||||
require 'test_helper'
|
||||
|
||||
class TableRowTest < Minitest::Test
|
||||
class TableRowTest < Test::Unit::TestCase
|
||||
include Liquid
|
||||
|
||||
class ArrayDrop < Liquid::Drop
|
||||
@@ -16,45 +16,48 @@ class TableRowTest < Minitest::Test
|
||||
end
|
||||
|
||||
def test_table_row
|
||||
|
||||
assert_template_result("<tr class=\"row1\">\n<td class=\"col1\"> 1 </td><td class=\"col2\"> 2 </td><td class=\"col3\"> 3 </td></tr>\n<tr class=\"row2\"><td class=\"col1\"> 4 </td><td class=\"col2\"> 5 </td><td class=\"col3\"> 6 </td></tr>\n",
|
||||
'{% tablerow n in numbers cols:3%} {{n}} {% endtablerow %}',
|
||||
'numbers' => [1, 2, 3, 4, 5, 6])
|
||||
'{% tablerow n in numbers cols:3%} {{n}} {% endtablerow %}',
|
||||
'numbers' => [1,2,3,4,5,6])
|
||||
|
||||
assert_template_result("<tr class=\"row1\">\n</tr>\n",
|
||||
'{% tablerow n in numbers cols:3%} {{n}} {% endtablerow %}',
|
||||
'numbers' => [])
|
||||
'{% tablerow n in numbers cols:3%} {{n}} {% endtablerow %}',
|
||||
'numbers' => [])
|
||||
end
|
||||
|
||||
def test_table_row_with_different_cols
|
||||
assert_template_result("<tr class=\"row1\">\n<td class=\"col1\"> 1 </td><td class=\"col2\"> 2 </td><td class=\"col3\"> 3 </td><td class=\"col4\"> 4 </td><td class=\"col5\"> 5 </td></tr>\n<tr class=\"row2\"><td class=\"col1\"> 6 </td></tr>\n",
|
||||
'{% tablerow n in numbers cols:5%} {{n}} {% endtablerow %}',
|
||||
'numbers' => [1, 2, 3, 4, 5, 6])
|
||||
'{% tablerow n in numbers cols:5%} {{n}} {% endtablerow %}',
|
||||
'numbers' => [1,2,3,4,5,6])
|
||||
|
||||
end
|
||||
|
||||
def test_table_col_counter
|
||||
assert_template_result("<tr class=\"row1\">\n<td class=\"col1\">1</td><td class=\"col2\">2</td></tr>\n<tr class=\"row2\"><td class=\"col1\">1</td><td class=\"col2\">2</td></tr>\n<tr class=\"row3\"><td class=\"col1\">1</td><td class=\"col2\">2</td></tr>\n",
|
||||
'{% tablerow n in numbers cols:2%}{{tablerowloop.col}}{% endtablerow %}',
|
||||
'numbers' => [1, 2, 3, 4, 5, 6])
|
||||
'{% tablerow n in numbers cols:2%}{{tablerowloop.col}}{% endtablerow %}',
|
||||
'numbers' => [1,2,3,4,5,6])
|
||||
end
|
||||
|
||||
def test_quoted_fragment
|
||||
assert_template_result("<tr class=\"row1\">\n<td class=\"col1\"> 1 </td><td class=\"col2\"> 2 </td><td class=\"col3\"> 3 </td></tr>\n<tr class=\"row2\"><td class=\"col1\"> 4 </td><td class=\"col2\"> 5 </td><td class=\"col3\"> 6 </td></tr>\n",
|
||||
"{% tablerow n in collections.frontpage cols:3%} {{n}} {% endtablerow %}",
|
||||
'collections' => { 'frontpage' => [1, 2, 3, 4, 5, 6] })
|
||||
"{% tablerow n in collections.frontpage cols:3%} {{n}} {% endtablerow %}",
|
||||
'collections' => {'frontpage' => [1,2,3,4,5,6]})
|
||||
assert_template_result("<tr class=\"row1\">\n<td class=\"col1\"> 1 </td><td class=\"col2\"> 2 </td><td class=\"col3\"> 3 </td></tr>\n<tr class=\"row2\"><td class=\"col1\"> 4 </td><td class=\"col2\"> 5 </td><td class=\"col3\"> 6 </td></tr>\n",
|
||||
"{% tablerow n in collections['frontpage'] cols:3%} {{n}} {% endtablerow %}",
|
||||
'collections' => { 'frontpage' => [1, 2, 3, 4, 5, 6] })
|
||||
"{% tablerow n in collections['frontpage'] cols:3%} {{n}} {% endtablerow %}",
|
||||
'collections' => {'frontpage' => [1,2,3,4,5,6]})
|
||||
|
||||
end
|
||||
|
||||
def test_enumerable_drop
|
||||
assert_template_result("<tr class=\"row1\">\n<td class=\"col1\"> 1 </td><td class=\"col2\"> 2 </td><td class=\"col3\"> 3 </td></tr>\n<tr class=\"row2\"><td class=\"col1\"> 4 </td><td class=\"col2\"> 5 </td><td class=\"col3\"> 6 </td></tr>\n",
|
||||
'{% tablerow n in numbers cols:3%} {{n}} {% endtablerow %}',
|
||||
'numbers' => ArrayDrop.new([1, 2, 3, 4, 5, 6]))
|
||||
'{% tablerow n in numbers cols:3%} {{n}} {% endtablerow %}',
|
||||
'numbers' => ArrayDrop.new([1,2,3,4,5,6]))
|
||||
end
|
||||
|
||||
def test_offset_and_limit
|
||||
assert_template_result("<tr class=\"row1\">\n<td class=\"col1\"> 1 </td><td class=\"col2\"> 2 </td><td class=\"col3\"> 3 </td></tr>\n<tr class=\"row2\"><td class=\"col1\"> 4 </td><td class=\"col2\"> 5 </td><td class=\"col3\"> 6 </td></tr>\n",
|
||||
'{% tablerow n in numbers cols:3 offset:1 limit:6%} {{n}} {% endtablerow %}',
|
||||
'numbers' => [0, 1, 2, 3, 4, 5, 6, 7])
|
||||
'{% tablerow n in numbers cols:3 offset:1 limit:6%} {{n}} {% endtablerow %}',
|
||||
'numbers' => [0,1,2,3,4,5,6,7])
|
||||
end
|
||||
end
|
||||
|
||||
@@ -1,19 +1,19 @@
|
||||
require 'test_helper'
|
||||
|
||||
class UnlessElseTagTest < Minitest::Test
|
||||
class UnlessElseTagTest < Test::Unit::TestCase
|
||||
include Liquid
|
||||
|
||||
def test_unless
|
||||
assert_template_result(' ', ' {% unless true %} this text should not go into the output {% endunless %} ')
|
||||
assert_template_result(' ',' {% unless true %} this text should not go into the output {% endunless %} ')
|
||||
assert_template_result(' this text should go into the output ',
|
||||
' {% unless false %} this text should go into the output {% endunless %} ')
|
||||
assert_template_result(' you rock ?', '{% unless true %} you suck {% endunless %} {% unless false %} you rock {% endunless %}?')
|
||||
' {% unless false %} this text should go into the output {% endunless %} ')
|
||||
assert_template_result(' you rock ?','{% unless true %} you suck {% endunless %} {% unless false %} you rock {% endunless %}?')
|
||||
end
|
||||
|
||||
def test_unless_else
|
||||
assert_template_result(' YES ', '{% unless true %} NO {% else %} YES {% endunless %}')
|
||||
assert_template_result(' YES ', '{% unless false %} YES {% else %} NO {% endunless %}')
|
||||
assert_template_result(' YES ', '{% unless "foo" %} NO {% else %} YES {% endunless %}')
|
||||
assert_template_result(' YES ','{% unless true %} NO {% else %} YES {% endunless %}')
|
||||
assert_template_result(' YES ','{% unless false %} YES {% else %} NO {% endunless %}')
|
||||
assert_template_result(' YES ','{% unless "foo" %} NO {% else %} YES {% endunless %}')
|
||||
end
|
||||
|
||||
def test_unless_in_loop
|
||||
|
||||
@@ -1,5 +1,4 @@
|
||||
require 'test_helper'
|
||||
require 'timeout'
|
||||
|
||||
class TemplateContextDrop < Liquid::Drop
|
||||
def before_method(method)
|
||||
@@ -15,10 +14,12 @@ class TemplateContextDrop < Liquid::Drop
|
||||
end
|
||||
end
|
||||
|
||||
class SomethingWithLength < Liquid::Drop
|
||||
class SomethingWithLength
|
||||
def length
|
||||
nil
|
||||
end
|
||||
|
||||
liquid_methods :length
|
||||
end
|
||||
|
||||
class ErroneousDrop < Liquid::Drop
|
||||
@@ -27,7 +28,7 @@ class ErroneousDrop < Liquid::Drop
|
||||
end
|
||||
end
|
||||
|
||||
class TemplateTest < Minitest::Test
|
||||
class TemplateTest < Test::Unit::TestCase
|
||||
include Liquid
|
||||
|
||||
def test_instance_assigns_persist_on_same_template_object_between_parses
|
||||
@@ -36,16 +37,6 @@ class TemplateTest < Minitest::Test
|
||||
assert_equal 'from instance assigns', t.parse("{{ foo }}").render!
|
||||
end
|
||||
|
||||
def test_warnings_is_not_exponential_time
|
||||
str = "false"
|
||||
100.times do
|
||||
str = "{% if true %}true{% else %}#{str}{% endif %}"
|
||||
end
|
||||
|
||||
t = Template.parse(str)
|
||||
assert_equal [], Timeout.timeout(1) { t.warnings }
|
||||
end
|
||||
|
||||
def test_instance_assigns_persist_on_same_template_parsing_between_renders
|
||||
t = Template.new.parse("{{ foo }}{% assign foo = 'foo' %}{{ foo }}")
|
||||
assert_equal 'foo', t.render!
|
||||
@@ -73,7 +64,7 @@ class TemplateTest < Minitest::Test
|
||||
|
||||
def test_lambda_is_called_once_from_persistent_assigns_over_multiple_parses_and_renders
|
||||
t = Template.new
|
||||
t.assigns['number'] = -> { @global ||= 0; @global += 1 }
|
||||
t.assigns['number'] = lambda { @global ||= 0; @global += 1 }
|
||||
assert_equal '1', t.parse("{{number}}").render!
|
||||
assert_equal '1', t.parse("{{number}}").render!
|
||||
assert_equal '1', t.render!
|
||||
@@ -82,7 +73,7 @@ class TemplateTest < Minitest::Test
|
||||
|
||||
def test_lambda_is_called_once_from_custom_assigns_over_multiple_parses_and_renders
|
||||
t = Template.new
|
||||
assigns = { 'number' => -> { @global ||= 0; @global += 1 } }
|
||||
assigns = {'number' => lambda { @global ||= 0; @global += 1 }}
|
||||
assert_equal '1', t.parse("{{number}}").render!(assigns)
|
||||
assert_equal '1', t.parse("{{number}}").render!(assigns)
|
||||
assert_equal '1', t.render!(assigns)
|
||||
@@ -91,92 +82,57 @@ class TemplateTest < Minitest::Test
|
||||
|
||||
def test_resource_limits_works_with_custom_length_method
|
||||
t = Template.parse("{% assign foo = bar %}")
|
||||
t.resource_limits.render_length_limit = 42
|
||||
t.resource_limits = { :render_length_limit => 42 }
|
||||
assert_equal "", t.render!("bar" => SomethingWithLength.new)
|
||||
end
|
||||
|
||||
def test_resource_limits_render_length
|
||||
t = Template.parse("0123456789")
|
||||
t.resource_limits.render_length_limit = 5
|
||||
assert_equal "Liquid error: Memory limits exceeded", t.render
|
||||
assert t.resource_limits.reached?
|
||||
|
||||
t.resource_limits.render_length_limit = 10
|
||||
assert_equal "0123456789", t.render!
|
||||
refute_nil t.resource_limits.render_length
|
||||
t.resource_limits = { :render_length_limit => 5 }
|
||||
assert_equal "Liquid error: Memory limits exceeded", t.render()
|
||||
assert t.resource_limits[:reached]
|
||||
t.resource_limits = { :render_length_limit => 10 }
|
||||
assert_equal "0123456789", t.render!()
|
||||
assert_not_nil t.resource_limits[:render_length_current]
|
||||
end
|
||||
|
||||
def test_resource_limits_render_score
|
||||
t = Template.parse("{% for a in (1..10) %} {% for a in (1..10) %} foo {% endfor %} {% endfor %}")
|
||||
t.resource_limits.render_score_limit = 50
|
||||
assert_equal "Liquid error: Memory limits exceeded", t.render
|
||||
assert t.resource_limits.reached?
|
||||
|
||||
t.resource_limits = { :render_score_limit => 50 }
|
||||
assert_equal "Liquid error: Memory limits exceeded", t.render()
|
||||
assert t.resource_limits[:reached]
|
||||
t = Template.parse("{% for a in (1..100) %} foo {% endfor %}")
|
||||
t.resource_limits.render_score_limit = 50
|
||||
assert_equal "Liquid error: Memory limits exceeded", t.render
|
||||
assert t.resource_limits.reached?
|
||||
|
||||
t.resource_limits.render_score_limit = 200
|
||||
assert_equal (" foo " * 100), t.render!
|
||||
refute_nil t.resource_limits.render_score
|
||||
t.resource_limits = { :render_score_limit => 50 }
|
||||
assert_equal "Liquid error: Memory limits exceeded", t.render()
|
||||
assert t.resource_limits[:reached]
|
||||
t.resource_limits = { :render_score_limit => 200 }
|
||||
assert_equal (" foo " * 100), t.render!()
|
||||
assert_not_nil t.resource_limits[:render_score_current]
|
||||
end
|
||||
|
||||
def test_resource_limits_assign_score
|
||||
t = Template.parse("{% assign foo = 42 %}{% assign bar = 23 %}")
|
||||
t.resource_limits.assign_score_limit = 1
|
||||
assert_equal "Liquid error: Memory limits exceeded", t.render
|
||||
assert t.resource_limits.reached?
|
||||
|
||||
t.resource_limits.assign_score_limit = 2
|
||||
assert_equal "", t.render!
|
||||
refute_nil t.resource_limits.assign_score
|
||||
t.resource_limits = { :assign_score_limit => 1 }
|
||||
assert_equal "Liquid error: Memory limits exceeded", t.render()
|
||||
assert t.resource_limits[:reached]
|
||||
t.resource_limits = { :assign_score_limit => 2 }
|
||||
assert_equal "", t.render!()
|
||||
assert_not_nil t.resource_limits[:assign_score_current]
|
||||
end
|
||||
|
||||
def test_resource_limits_aborts_rendering_after_first_error
|
||||
t = Template.parse("{% for a in (1..100) %} foo1 {% endfor %} bar {% for a in (1..100) %} foo2 {% endfor %}")
|
||||
t.resource_limits.render_score_limit = 50
|
||||
assert_equal "Liquid error: Memory limits exceeded", t.render
|
||||
assert t.resource_limits.reached?
|
||||
t.resource_limits = { :render_score_limit => 50 }
|
||||
assert_equal "Liquid error: Memory limits exceeded", t.render()
|
||||
assert t.resource_limits[:reached]
|
||||
end
|
||||
|
||||
def test_resource_limits_hash_in_template_gets_updated_even_if_no_limits_are_set
|
||||
t = Template.parse("{% for a in (1..100) %} {% assign foo = 1 %} {% endfor %}")
|
||||
t.render!
|
||||
assert t.resource_limits.assign_score > 0
|
||||
assert t.resource_limits.render_score > 0
|
||||
assert t.resource_limits.render_length > 0
|
||||
end
|
||||
|
||||
def test_render_length_persists_between_blocks
|
||||
t = Template.parse("{% if true %}aaaa{% endif %}")
|
||||
t.resource_limits.render_length_limit = 7
|
||||
assert_equal "Liquid error: Memory limits exceeded", t.render
|
||||
t.resource_limits.render_length_limit = 8
|
||||
assert_equal "aaaa", t.render
|
||||
|
||||
t = Template.parse("{% if true %}aaaa{% endif %}{% if true %}bbb{% endif %}")
|
||||
t.resource_limits.render_length_limit = 13
|
||||
assert_equal "Liquid error: Memory limits exceeded", t.render
|
||||
t.resource_limits.render_length_limit = 14
|
||||
assert_equal "aaaabbb", t.render
|
||||
|
||||
t = Template.parse("{% if true %}a{% endif %}{% if true %}b{% endif %}{% if true %}a{% endif %}{% if true %}b{% endif %}{% if true %}a{% endif %}{% if true %}b{% endif %}")
|
||||
t.resource_limits.render_length_limit = 5
|
||||
assert_equal "Liquid error: Memory limits exceeded", t.render
|
||||
t.resource_limits.render_length_limit = 11
|
||||
assert_equal "Liquid error: Memory limits exceeded", t.render
|
||||
t.resource_limits.render_length_limit = 12
|
||||
assert_equal "ababab", t.render
|
||||
end
|
||||
|
||||
def test_default_resource_limits_unaffected_by_render_with_context
|
||||
context = Context.new
|
||||
t = Template.parse("{% for a in (1..100) %} {% assign foo = 1 %} {% endfor %}")
|
||||
t.render!(context)
|
||||
assert context.resource_limits.assign_score > 0
|
||||
assert context.resource_limits.render_score > 0
|
||||
assert context.resource_limits.render_length > 0
|
||||
t.render!()
|
||||
assert t.resource_limits[:assign_score_current] > 0
|
||||
assert t.resource_limits[:render_score_current] > 0
|
||||
assert t.resource_limits[:render_length_current] > 0
|
||||
end
|
||||
|
||||
def test_can_use_drop_as_context
|
||||
@@ -189,7 +145,7 @@ class TemplateTest < Minitest::Test
|
||||
end
|
||||
|
||||
def test_render_bang_force_rethrow_errors_on_passed_context
|
||||
context = Context.new({ 'drop' => ErroneousDrop.new })
|
||||
context = Context.new({'drop' => ErroneousDrop.new})
|
||||
t = Template.new.parse('{{ drop.bad_method }}')
|
||||
|
||||
e = assert_raises RuntimeError do
|
||||
@@ -201,16 +157,14 @@ class TemplateTest < Minitest::Test
|
||||
def test_exception_handler_doesnt_reraise_if_it_returns_false
|
||||
exception = nil
|
||||
Template.parse("{{ 1 | divided_by: 0 }}").render({}, exception_handler: ->(e) { exception = e; false })
|
||||
assert exception.is_a?(Liquid::FilterError)
|
||||
assert exception.original_exception.is_a?(ZeroDivisionError)
|
||||
assert exception.is_a?(ZeroDivisionError)
|
||||
end
|
||||
|
||||
def test_exception_handler_does_reraise_if_it_returns_true
|
||||
exception = nil
|
||||
assert_raises(Liquid::FilterError) do
|
||||
assert_raises(ZeroDivisionError) do
|
||||
Template.parse("{{ 1 | divided_by: 0 }}").render({}, exception_handler: ->(e) { exception = e; true })
|
||||
end
|
||||
assert exception.is_a?(Liquid::FilterError)
|
||||
assert exception.original_exception.is_a?(ZeroDivisionError)
|
||||
assert exception.is_a?(ZeroDivisionError)
|
||||
end
|
||||
end
|
||||
|
||||
@@ -1,62 +1,52 @@
|
||||
require 'test_helper'
|
||||
|
||||
class VariableTest < Minitest::Test
|
||||
class VariableTest < Test::Unit::TestCase
|
||||
include Liquid
|
||||
|
||||
def test_simple_variable
|
||||
template = Template.parse(%({{test}}))
|
||||
template = Template.parse(%|{{test}}|)
|
||||
assert_equal 'worked', template.render!('test' => 'worked')
|
||||
assert_equal 'worked wonderfully', template.render!('test' => 'worked wonderfully')
|
||||
end
|
||||
|
||||
def test_variable_render_calls_to_liquid
|
||||
assert_template_result 'foobar', '{{ foo }}', 'foo' => ThingWithToLiquid.new
|
||||
end
|
||||
|
||||
def test_simple_with_whitespaces
|
||||
template = Template.parse(%( {{ test }} ))
|
||||
template = Template.parse(%| {{ test }} |)
|
||||
assert_equal ' worked ', template.render!('test' => 'worked')
|
||||
assert_equal ' worked wonderfully ', template.render!('test' => 'worked wonderfully')
|
||||
end
|
||||
|
||||
def test_ignore_unknown
|
||||
template = Template.parse(%({{ test }}))
|
||||
template = Template.parse(%|{{ test }}|)
|
||||
assert_equal '', template.render!
|
||||
end
|
||||
|
||||
def test_hash_scoping
|
||||
template = Template.parse(%({{ test.test }}))
|
||||
assert_equal 'worked', template.render!('test' => { 'test' => 'worked' })
|
||||
template = Template.parse(%|{{ test.test }}|)
|
||||
assert_equal 'worked', template.render!('test' => {'test' => 'worked'})
|
||||
end
|
||||
|
||||
def test_false_renders_as_false
|
||||
assert_equal 'false', Template.parse("{{ foo }}").render!('foo' => false)
|
||||
assert_equal 'false', Template.parse("{{ false }}").render!
|
||||
end
|
||||
|
||||
def test_nil_renders_as_empty_string
|
||||
assert_equal '', Template.parse("{{ nil }}").render!
|
||||
assert_equal 'cat', Template.parse("{{ nil | append: 'cat' }}").render!
|
||||
end
|
||||
|
||||
def test_preset_assigns
|
||||
template = Template.parse(%({{ test }}))
|
||||
template = Template.parse(%|{{ test }}|)
|
||||
template.assigns['test'] = 'worked'
|
||||
assert_equal 'worked', template.render!
|
||||
end
|
||||
|
||||
def test_reuse_parsed_template
|
||||
template = Template.parse(%({{ greeting }} {{ name }}))
|
||||
template = Template.parse(%|{{ greeting }} {{ name }}|)
|
||||
template.assigns['greeting'] = 'Goodbye'
|
||||
assert_equal 'Hello Tobi', template.render!('greeting' => 'Hello', 'name' => 'Tobi')
|
||||
assert_equal 'Hello ', template.render!('greeting' => 'Hello', 'unknown' => 'Tobi')
|
||||
assert_equal 'Hello Brian', template.render!('greeting' => 'Hello', 'name' => 'Brian')
|
||||
assert_equal 'Goodbye Brian', template.render!('name' => 'Brian')
|
||||
assert_equal({ 'greeting' => 'Goodbye' }, template.assigns)
|
||||
assert_equal({'greeting'=>'Goodbye'}, template.assigns)
|
||||
end
|
||||
|
||||
def test_assigns_not_polluted_from_template
|
||||
template = Template.parse(%({{ test }}{% assign test = 'bar' %}{{ test }}))
|
||||
template = Template.parse(%|{{ test }}{% assign test = 'bar' %}{{ test }}|)
|
||||
template.assigns['test'] = 'baz'
|
||||
assert_equal 'bazbar', template.render!
|
||||
assert_equal 'bazbar', template.render!
|
||||
@@ -65,8 +55,8 @@ class VariableTest < Minitest::Test
|
||||
end
|
||||
|
||||
def test_hash_with_default_proc
|
||||
template = Template.parse(%(Hello {{ test }}))
|
||||
assigns = Hash.new { |h, k| raise "Unknown variable '#{k}'" }
|
||||
template = Template.parse(%|Hello {{ test }}|)
|
||||
assigns = Hash.new { |h,k| raise "Unknown variable '#{k}'" }
|
||||
assigns['test'] = 'Tobi'
|
||||
assert_equal 'Hello Tobi', template.render!(assigns)
|
||||
assigns.delete('test')
|
||||
|
||||
@@ -1,12 +1,11 @@
|
||||
#!/usr/bin/env ruby
|
||||
|
||||
ENV["MT_NO_EXPECTATIONS"] = "1"
|
||||
require 'minitest/autorun'
|
||||
require 'test/unit'
|
||||
require 'test/unit/assertions'
|
||||
require 'spy/integration'
|
||||
|
||||
$:.unshift(File.join(File.expand_path(__dir__), '..', 'lib'))
|
||||
$:.unshift(File.join(File.expand_path(File.dirname(__FILE__)), '..', 'lib'))
|
||||
require 'liquid.rb'
|
||||
require 'liquid/profiler'
|
||||
|
||||
mode = :strict
|
||||
if env_mode = ENV['LIQUID_PARSER_MODE']
|
||||
@@ -15,95 +14,41 @@ if env_mode = ENV['LIQUID_PARSER_MODE']
|
||||
end
|
||||
Liquid::Template.error_mode = mode
|
||||
|
||||
if Minitest.const_defined?('Test')
|
||||
# We're on Minitest 5+. Nothing to do here.
|
||||
else
|
||||
# Minitest 4 doesn't have Minitest::Test yet.
|
||||
Minitest::Test = MiniTest::Unit::TestCase
|
||||
end
|
||||
|
||||
module Minitest
|
||||
class Test
|
||||
def fixture(name)
|
||||
File.join(File.expand_path(__dir__), "fixtures", name)
|
||||
end
|
||||
end
|
||||
|
||||
module Assertions
|
||||
include Liquid
|
||||
|
||||
def assert_template_result(expected, template, assigns = {}, message = nil)
|
||||
assert_equal expected, Template.parse(template).render!(assigns)
|
||||
end
|
||||
|
||||
def assert_template_result_matches(expected, template, assigns = {}, message = nil)
|
||||
return assert_template_result(expected, template, assigns, message) unless expected.is_a? Regexp
|
||||
|
||||
assert_match expected, Template.parse(template).render!(assigns)
|
||||
end
|
||||
|
||||
def assert_match_syntax_error(match, template, registers = {})
|
||||
exception = assert_raises(Liquid::SyntaxError) {
|
||||
Template.parse(template).render(assigns)
|
||||
}
|
||||
assert_match match, exception.message
|
||||
end
|
||||
|
||||
def with_global_filter(*globals)
|
||||
original_global_strainer = Liquid::Strainer.class_variable_get(:@@global_strainer)
|
||||
Liquid::Strainer.class_variable_set(:@@global_strainer, Class.new(Liquid::Strainer) do
|
||||
@filter_methods = Set.new
|
||||
end)
|
||||
Liquid::Strainer.class_variable_get(:@@strainer_class_cache).clear
|
||||
|
||||
globals.each do |global|
|
||||
Liquid::Template.register_filter(global)
|
||||
module Test
|
||||
module Unit
|
||||
class TestCase
|
||||
def fixture(name)
|
||||
File.join(File.expand_path(File.dirname(__FILE__)), "fixtures", name)
|
||||
end
|
||||
yield
|
||||
ensure
|
||||
Liquid::Strainer.class_variable_get(:@@strainer_class_cache).clear
|
||||
Liquid::Strainer.class_variable_set(:@@global_strainer, original_global_strainer)
|
||||
end
|
||||
|
||||
def with_taint_mode(mode)
|
||||
old_mode = Liquid::Template.taint_mode
|
||||
Liquid::Template.taint_mode = mode
|
||||
yield
|
||||
ensure
|
||||
Liquid::Template.taint_mode = old_mode
|
||||
end
|
||||
module Assertions
|
||||
include Liquid
|
||||
|
||||
def with_error_mode(mode)
|
||||
old_mode = Liquid::Template.error_mode
|
||||
Liquid::Template.error_mode = mode
|
||||
yield
|
||||
ensure
|
||||
Liquid::Template.error_mode = old_mode
|
||||
end
|
||||
end
|
||||
end
|
||||
def assert_template_result(expected, template, assigns = {}, message = nil)
|
||||
assert_equal expected, Template.parse(template).render!(assigns)
|
||||
end
|
||||
|
||||
class ThingWithToLiquid
|
||||
def to_liquid
|
||||
'foobar'
|
||||
end
|
||||
end
|
||||
def assert_template_result_matches(expected, template, assigns = {}, message = nil)
|
||||
return assert_template_result(expected, template, assigns, message) unless expected.is_a? Regexp
|
||||
|
||||
class ErrorDrop < Liquid::Drop
|
||||
def standard_error
|
||||
raise Liquid::StandardError, 'standard error'
|
||||
end
|
||||
assert_match expected, Template.parse(template).render!(assigns)
|
||||
end
|
||||
|
||||
def argument_error
|
||||
raise Liquid::ArgumentError, 'argument error'
|
||||
end
|
||||
|
||||
def syntax_error
|
||||
raise Liquid::SyntaxError, 'syntax error'
|
||||
end
|
||||
|
||||
def exception
|
||||
raise Exception, 'exception'
|
||||
end
|
||||
end
|
||||
def assert_match_syntax_error(match, template, registers = {})
|
||||
exception = assert_raise(Liquid::SyntaxError) {
|
||||
Template.parse(template).render(assigns)
|
||||
}
|
||||
assert_match match, exception.message
|
||||
end
|
||||
|
||||
def with_error_mode(mode)
|
||||
old_mode = Liquid::Template.error_mode
|
||||
Liquid::Template.error_mode = mode
|
||||
yield
|
||||
Liquid::Template.error_mode = old_mode
|
||||
end
|
||||
end # Assertions
|
||||
end # Unit
|
||||
end # Test
|
||||
|
||||
@@ -1,6 +1,6 @@
|
||||
require 'test_helper'
|
||||
|
||||
class BlockUnitTest < Minitest::Test
|
||||
class BlockUnitTest < Test::Unit::TestCase
|
||||
include Liquid
|
||||
|
||||
def test_blankspace
|
||||
@@ -34,7 +34,7 @@ class BlockUnitTest < Minitest::Test
|
||||
template = Liquid::Template.parse(" {{funk}} {{so}} {{brother}} ")
|
||||
assert_equal 7, template.root.nodelist.size
|
||||
assert_equal [String, Variable, String, Variable, String, Variable, String],
|
||||
block_types(template.root.nodelist)
|
||||
block_types(template.root.nodelist)
|
||||
end
|
||||
|
||||
def test_with_block
|
||||
@@ -45,12 +45,14 @@ class BlockUnitTest < Minitest::Test
|
||||
|
||||
def test_with_custom_tag
|
||||
Liquid::Template.register_tag("testtag", Block)
|
||||
assert Liquid::Template.parse("{% testtag %} {% endtesttag %}")
|
||||
|
||||
assert_nothing_thrown do
|
||||
template = Liquid::Template.parse( "{% testtag %} {% endtesttag %}")
|
||||
end
|
||||
end
|
||||
|
||||
private
|
||||
|
||||
def block_types(nodelist)
|
||||
nodelist.collect(&:class)
|
||||
end
|
||||
def block_types(nodelist)
|
||||
nodelist.collect { |node| node.class }
|
||||
end
|
||||
end # VariableTest
|
||||
|
||||
@@ -1,150 +1,145 @@
|
||||
require 'test_helper'
|
||||
|
||||
class ConditionUnitTest < Minitest::Test
|
||||
class ConditionUnitTest < Test::Unit::TestCase
|
||||
include Liquid
|
||||
|
||||
def test_basic_condition
|
||||
assert_equal false, Condition.new(1, '==', 2).evaluate
|
||||
assert_equal true, Condition.new(1, '==', 1).evaluate
|
||||
assert_equal false, Condition.new('1', '==', '2').evaluate
|
||||
assert_equal true, Condition.new('1', '==', '1').evaluate
|
||||
end
|
||||
|
||||
def test_default_operators_evalute_true
|
||||
assert_evalutes_true 1, '==', 1
|
||||
assert_evalutes_true 1, '!=', 2
|
||||
assert_evalutes_true 1, '<>', 2
|
||||
assert_evalutes_true 1, '<', 2
|
||||
assert_evalutes_true 2, '>', 1
|
||||
assert_evalutes_true 1, '>=', 1
|
||||
assert_evalutes_true 2, '>=', 1
|
||||
assert_evalutes_true 1, '<=', 2
|
||||
assert_evalutes_true 1, '<=', 1
|
||||
assert_evalutes_true '1', '==', '1'
|
||||
assert_evalutes_true '1', '!=', '2'
|
||||
assert_evalutes_true '1', '<>', '2'
|
||||
assert_evalutes_true '1', '<', '2'
|
||||
assert_evalutes_true '2', '>', '1'
|
||||
assert_evalutes_true '1', '>=', '1'
|
||||
assert_evalutes_true '2', '>=', '1'
|
||||
assert_evalutes_true '1', '<=', '2'
|
||||
assert_evalutes_true '1', '<=', '1'
|
||||
# negative numbers
|
||||
assert_evalutes_true 1, '>', -1
|
||||
assert_evalutes_true -1, '<', 1
|
||||
assert_evalutes_true 1.0, '>', -1.0
|
||||
assert_evalutes_true -1.0, '<', 1.0
|
||||
assert_evalutes_true '1', '>', '-1'
|
||||
assert_evalutes_true '-1', '<', '1'
|
||||
assert_evalutes_true '1.0', '>', '-1.0'
|
||||
assert_evalutes_true '-1.0', '<', '1.0'
|
||||
end
|
||||
|
||||
def test_default_operators_evalute_false
|
||||
assert_evalutes_false 1, '==', 2
|
||||
assert_evalutes_false 1, '!=', 1
|
||||
assert_evalutes_false 1, '<>', 1
|
||||
assert_evalutes_false 1, '<', 0
|
||||
assert_evalutes_false 2, '>', 4
|
||||
assert_evalutes_false 1, '>=', 3
|
||||
assert_evalutes_false 2, '>=', 4
|
||||
assert_evalutes_false 1, '<=', 0
|
||||
assert_evalutes_false 1, '<=', 0
|
||||
assert_evalutes_false '1', '==', '2'
|
||||
assert_evalutes_false '1', '!=', '1'
|
||||
assert_evalutes_false '1', '<>', '1'
|
||||
assert_evalutes_false '1', '<', '0'
|
||||
assert_evalutes_false '2', '>', '4'
|
||||
assert_evalutes_false '1', '>=', '3'
|
||||
assert_evalutes_false '2', '>=', '4'
|
||||
assert_evalutes_false '1', '<=', '0'
|
||||
assert_evalutes_false '1', '<=', '0'
|
||||
end
|
||||
|
||||
def test_contains_works_on_strings
|
||||
assert_evalutes_true 'bob', 'contains', 'o'
|
||||
assert_evalutes_true 'bob', 'contains', 'b'
|
||||
assert_evalutes_true 'bob', 'contains', 'bo'
|
||||
assert_evalutes_true 'bob', 'contains', 'ob'
|
||||
assert_evalutes_true 'bob', 'contains', 'bob'
|
||||
assert_evalutes_true "'bob'", 'contains', "'o'"
|
||||
assert_evalutes_true "'bob'", 'contains', "'b'"
|
||||
assert_evalutes_true "'bob'", 'contains', "'bo'"
|
||||
assert_evalutes_true "'bob'", 'contains', "'ob'"
|
||||
assert_evalutes_true "'bob'", 'contains', "'bob'"
|
||||
|
||||
assert_evalutes_false 'bob', 'contains', 'bob2'
|
||||
assert_evalutes_false 'bob', 'contains', 'a'
|
||||
assert_evalutes_false 'bob', 'contains', '---'
|
||||
assert_evalutes_false "'bob'", 'contains', "'bob2'"
|
||||
assert_evalutes_false "'bob'", 'contains', "'a'"
|
||||
assert_evalutes_false "'bob'", 'contains', "'---'"
|
||||
end
|
||||
|
||||
def test_invalid_comparation_operator
|
||||
assert_evaluates_argument_error 1, '~~', 0
|
||||
assert_evaluates_argument_error "1", '~~', '0'
|
||||
end
|
||||
|
||||
def test_comparation_of_int_and_str
|
||||
assert_evaluates_argument_error '1', '>', 0
|
||||
assert_evaluates_argument_error '1', '<', 0
|
||||
assert_evaluates_argument_error '1', '>=', 0
|
||||
assert_evaluates_argument_error '1', '<=', 0
|
||||
assert_evaluates_argument_error "'1'", '>', '0'
|
||||
assert_evaluates_argument_error "'1'", '<', '0'
|
||||
assert_evaluates_argument_error "'1'", '>=', '0'
|
||||
assert_evaluates_argument_error "'1'", '<=', '0'
|
||||
end
|
||||
|
||||
def test_contains_works_on_arrays
|
||||
@context = Liquid::Context.new
|
||||
@context['array'] = [1, 2, 3, 4, 5]
|
||||
array_expr = VariableLookup.new("array")
|
||||
@context['array'] = [1,2,3,4,5]
|
||||
|
||||
assert_evalutes_false array_expr, 'contains', 0
|
||||
assert_evalutes_true array_expr, 'contains', 1
|
||||
assert_evalutes_true array_expr, 'contains', 2
|
||||
assert_evalutes_true array_expr, 'contains', 3
|
||||
assert_evalutes_true array_expr, 'contains', 4
|
||||
assert_evalutes_true array_expr, 'contains', 5
|
||||
assert_evalutes_false array_expr, 'contains', 6
|
||||
assert_evalutes_false array_expr, 'contains', "1"
|
||||
assert_evalutes_false "array", 'contains', '0'
|
||||
assert_evalutes_true "array", 'contains', '1'
|
||||
assert_evalutes_true "array", 'contains', '2'
|
||||
assert_evalutes_true "array", 'contains', '3'
|
||||
assert_evalutes_true "array", 'contains', '4'
|
||||
assert_evalutes_true "array", 'contains', '5'
|
||||
assert_evalutes_false "array", 'contains', '6'
|
||||
assert_evalutes_false "array", 'contains', '"1"'
|
||||
end
|
||||
|
||||
def test_contains_returns_false_for_nil_operands
|
||||
@context = Liquid::Context.new
|
||||
assert_evalutes_false VariableLookup.new('not_assigned'), 'contains', '0'
|
||||
assert_evalutes_false 0, 'contains', VariableLookup.new('not_assigned')
|
||||
end
|
||||
|
||||
def test_contains_return_false_on_wrong_data_type
|
||||
assert_evalutes_false 1, 'contains', 0
|
||||
assert_evalutes_false "not_assigned", 'contains', '0'
|
||||
assert_evalutes_false "0", 'contains', 'not_assigned'
|
||||
end
|
||||
|
||||
def test_or_condition
|
||||
condition = Condition.new(1, '==', 2)
|
||||
condition = Condition.new('1', '==', '2')
|
||||
|
||||
assert_equal false, condition.evaluate
|
||||
|
||||
condition.or Condition.new(2, '==', 1)
|
||||
condition.or Condition.new('2', '==', '1')
|
||||
|
||||
assert_equal false, condition.evaluate
|
||||
|
||||
condition.or Condition.new(1, '==', 1)
|
||||
condition.or Condition.new('1', '==', '1')
|
||||
|
||||
assert_equal true, condition.evaluate
|
||||
end
|
||||
|
||||
def test_and_condition
|
||||
condition = Condition.new(1, '==', 1)
|
||||
condition = Condition.new('1', '==', '1')
|
||||
|
||||
assert_equal true, condition.evaluate
|
||||
|
||||
condition.and Condition.new(2, '==', 2)
|
||||
condition.and Condition.new('2', '==', '2')
|
||||
|
||||
assert_equal true, condition.evaluate
|
||||
|
||||
condition.and Condition.new(2, '==', 1)
|
||||
condition.and Condition.new('2', '==', '1')
|
||||
|
||||
assert_equal false, condition.evaluate
|
||||
end
|
||||
|
||||
def test_should_allow_custom_proc_operator
|
||||
Condition.operators['starts_with'] = proc { |cond, left, right| left =~ %r{^#{right}} }
|
||||
Condition.operators['starts_with'] = Proc.new { |cond, left, right| left =~ %r{^#{right}} }
|
||||
|
||||
assert_evalutes_true 'bob', 'starts_with', 'b'
|
||||
assert_evalutes_false 'bob', 'starts_with', 'o'
|
||||
ensure
|
||||
Condition.operators.delete 'starts_with'
|
||||
assert_evalutes_true "'bob'", 'starts_with', "'b'"
|
||||
assert_evalutes_false "'bob'", 'starts_with', "'o'"
|
||||
|
||||
ensure
|
||||
Condition.operators.delete 'starts_with'
|
||||
end
|
||||
|
||||
def test_left_or_right_may_contain_operators
|
||||
@context = Liquid::Context.new
|
||||
@context['one'] = @context['another'] = "gnomeslab-and-or-liquid"
|
||||
|
||||
assert_evalutes_true VariableLookup.new("one"), '==', VariableLookup.new("another")
|
||||
assert_evalutes_true "one", '==', "another"
|
||||
end
|
||||
|
||||
private
|
||||
|
||||
def assert_evalutes_true(left, op, right)
|
||||
assert Condition.new(left, op, right).evaluate(@context || Liquid::Context.new),
|
||||
"Evaluated false: #{left} #{op} #{right}"
|
||||
end
|
||||
|
||||
def assert_evalutes_false(left, op, right)
|
||||
assert !Condition.new(left, op, right).evaluate(@context || Liquid::Context.new),
|
||||
"Evaluated true: #{left} #{op} #{right}"
|
||||
end
|
||||
|
||||
def assert_evaluates_argument_error(left, op, right)
|
||||
assert_raises(Liquid::ArgumentError) do
|
||||
Condition.new(left, op, right).evaluate(@context || Liquid::Context.new)
|
||||
def assert_evalutes_true(left, op, right)
|
||||
assert Condition.new(left, op, right).evaluate(@context || Liquid::Context.new),
|
||||
"Evaluated false: #{left} #{op} #{right}"
|
||||
end
|
||||
|
||||
def assert_evalutes_false(left, op, right)
|
||||
assert !Condition.new(left, op, right).evaluate(@context || Liquid::Context.new),
|
||||
"Evaluated true: #{left} #{op} #{right}"
|
||||
end
|
||||
|
||||
def assert_evaluates_argument_error(left, op, right)
|
||||
assert_raises(Liquid::ArgumentError) do
|
||||
Condition.new(left, op, right).evaluate(@context || Liquid::Context.new)
|
||||
end
|
||||
end
|
||||
end
|
||||
|
||||
end # ConditionTest
|
||||
|
||||
@@ -63,7 +63,7 @@ class ArrayLike
|
||||
end
|
||||
end
|
||||
|
||||
class ContextUnitTest < Minitest::Test
|
||||
class ContextUnitTest < Test::Unit::TestCase
|
||||
include Liquid
|
||||
|
||||
def setup
|
||||
@@ -107,14 +107,16 @@ class ContextUnitTest < Minitest::Test
|
||||
end
|
||||
|
||||
def test_scoping
|
||||
@context.push
|
||||
@context.pop
|
||||
|
||||
assert_raises(Liquid::ContextError) do
|
||||
assert_nothing_raised do
|
||||
@context.push
|
||||
@context.pop
|
||||
end
|
||||
|
||||
assert_raises(Liquid::ContextError) do
|
||||
assert_raise(Liquid::ContextError) do
|
||||
@context.pop
|
||||
end
|
||||
|
||||
assert_raise(Liquid::ContextError) do
|
||||
@context.push
|
||||
@context.pop
|
||||
@context.pop
|
||||
@@ -122,25 +124,30 @@ class ContextUnitTest < Minitest::Test
|
||||
end
|
||||
|
||||
def test_length_query
|
||||
@context['numbers'] = [1, 2, 3, 4]
|
||||
|
||||
@context['numbers'] = [1,2,3,4]
|
||||
|
||||
assert_equal 4, @context['numbers.size']
|
||||
|
||||
@context['numbers'] = { 1 => 1, 2 => 2, 3 => 3, 4 => 4 }
|
||||
@context['numbers'] = {1 => 1,2 => 2,3 => 3,4 => 4}
|
||||
|
||||
assert_equal 4, @context['numbers.size']
|
||||
|
||||
@context['numbers'] = { 1 => 1, 2 => 2, 3 => 3, 4 => 4, 'size' => 1000 }
|
||||
@context['numbers'] = {1 => 1,2 => 2,3 => 3,4 => 4, 'size' => 1000}
|
||||
|
||||
assert_equal 1000, @context['numbers.size']
|
||||
|
||||
end
|
||||
|
||||
def test_hyphenated_variable
|
||||
|
||||
@context['oh-my'] = 'godz'
|
||||
assert_equal 'godz', @context['oh-my']
|
||||
|
||||
end
|
||||
|
||||
def test_add_filter
|
||||
|
||||
filter = Module.new do
|
||||
def hi(output)
|
||||
output + ' hi!'
|
||||
@@ -156,9 +163,11 @@ class ContextUnitTest < Minitest::Test
|
||||
|
||||
context.add_filters(filter)
|
||||
assert_equal 'hi? hi!', context.invoke(:hi, 'hi?')
|
||||
|
||||
end
|
||||
|
||||
def test_only_intended_filters_make_it_there
|
||||
|
||||
filter = Module.new do
|
||||
def hi(output)
|
||||
output + ' hi!'
|
||||
@@ -189,7 +198,7 @@ class ContextUnitTest < Minitest::Test
|
||||
end
|
||||
|
||||
def test_hierachical_data
|
||||
@context['hash'] = { "name" => 'tobi' }
|
||||
@context['hash'] = {"name" => 'tobi'}
|
||||
assert_equal 'tobi', @context['hash.name']
|
||||
assert_equal 'tobi', @context['hash["name"]']
|
||||
end
|
||||
@@ -218,7 +227,7 @@ class ContextUnitTest < Minitest::Test
|
||||
end
|
||||
|
||||
def test_array_notation
|
||||
@context['test'] = [1, 2, 3, 4, 5]
|
||||
@context['test'] = [1,2,3,4,5]
|
||||
|
||||
assert_equal 1, @context['test[0]']
|
||||
assert_equal 2, @context['test[1]']
|
||||
@@ -228,21 +237,21 @@ class ContextUnitTest < Minitest::Test
|
||||
end
|
||||
|
||||
def test_recoursive_array_notation
|
||||
@context['test'] = { 'test' => [1, 2, 3, 4, 5] }
|
||||
@context['test'] = {'test' => [1,2,3,4,5]}
|
||||
|
||||
assert_equal 1, @context['test.test[0]']
|
||||
|
||||
@context['test'] = [{ 'test' => 'worked' }]
|
||||
@context['test'] = [{'test' => 'worked'}]
|
||||
|
||||
assert_equal 'worked', @context['test[0].test']
|
||||
end
|
||||
|
||||
def test_hash_to_array_transition
|
||||
@context['colors'] = {
|
||||
'Blue' => ['003366', '336699', '6699CC', '99CCFF'],
|
||||
'Green' => ['003300', '336633', '669966', '99CC99'],
|
||||
'Yellow' => ['CC9900', 'FFCC00', 'FFFF99', 'FFFFCC'],
|
||||
'Red' => ['660000', '993333', 'CC6666', 'FF9999']
|
||||
'Blue' => ['003366','336699', '6699CC', '99CCFF'],
|
||||
'Green' => ['003300','336633', '669966', '99CC99'],
|
||||
'Yellow' => ['CC9900','FFCC00', 'FFFF99', 'FFFFCC'],
|
||||
'Red' => ['660000','993333', 'CC6666', 'FF9999']
|
||||
}
|
||||
|
||||
assert_equal '003366', @context['colors.Blue[0]']
|
||||
@@ -250,12 +259,12 @@ class ContextUnitTest < Minitest::Test
|
||||
end
|
||||
|
||||
def test_try_first
|
||||
@context['test'] = [1, 2, 3, 4, 5]
|
||||
@context['test'] = [1,2,3,4,5]
|
||||
|
||||
assert_equal 1, @context['test.first']
|
||||
assert_equal 5, @context['test.last']
|
||||
|
||||
@context['test'] = { 'test' => [1, 2, 3, 4, 5] }
|
||||
@context['test'] = {'test' => [1,2,3,4,5]}
|
||||
|
||||
assert_equal 1, @context['test.test.first']
|
||||
assert_equal 5, @context['test.test.last']
|
||||
@@ -266,8 +275,8 @@ class ContextUnitTest < Minitest::Test
|
||||
end
|
||||
|
||||
def test_access_hashes_with_hash_notation
|
||||
@context['products'] = { 'count' => 5, 'tags' => ['deepsnow', 'freestyle'] }
|
||||
@context['product'] = { 'variants' => [ { 'title' => 'draft151cm' }, { 'title' => 'element151cm' } ] }
|
||||
@context['products'] = {'count' => 5, 'tags' => ['deepsnow', 'freestyle'] }
|
||||
@context['product'] = {'variants' => [ {'title' => 'draft151cm'}, {'title' => 'element151cm'} ]}
|
||||
|
||||
assert_equal 5, @context['products["count"]']
|
||||
assert_equal 'deepsnow', @context['products["tags"][0]']
|
||||
@@ -287,17 +296,18 @@ class ContextUnitTest < Minitest::Test
|
||||
end
|
||||
|
||||
def test_access_hashes_with_hash_access_variables
|
||||
|
||||
@context['var'] = 'tags'
|
||||
@context['nested'] = { 'var' => 'tags' }
|
||||
@context['products'] = { 'count' => 5, 'tags' => ['deepsnow', 'freestyle'] }
|
||||
@context['nested'] = {'var' => 'tags'}
|
||||
@context['products'] = {'count' => 5, 'tags' => ['deepsnow', 'freestyle'] }
|
||||
|
||||
assert_equal 'deepsnow', @context['products[var].first']
|
||||
assert_equal 'freestyle', @context['products[nested.var].last']
|
||||
end
|
||||
|
||||
def test_hash_notation_only_for_hash_access
|
||||
@context['array'] = [1, 2, 3, 4, 5]
|
||||
@context['hash'] = { 'first' => 'Hello' }
|
||||
@context['array'] = [1,2,3,4,5]
|
||||
@context['hash'] = {'first' => 'Hello'}
|
||||
|
||||
assert_equal 1, @context['array.first']
|
||||
assert_equal nil, @context['array["first"]']
|
||||
@@ -305,64 +315,66 @@ class ContextUnitTest < Minitest::Test
|
||||
end
|
||||
|
||||
def test_first_can_appear_in_middle_of_callchain
|
||||
@context['product'] = { 'variants' => [ { 'title' => 'draft151cm' }, { 'title' => 'element151cm' } ] }
|
||||
|
||||
@context['product'] = {'variants' => [ {'title' => 'draft151cm'}, {'title' => 'element151cm'} ]}
|
||||
|
||||
assert_equal 'draft151cm', @context['product.variants[0].title']
|
||||
assert_equal 'element151cm', @context['product.variants[1].title']
|
||||
assert_equal 'draft151cm', @context['product.variants.first.title']
|
||||
assert_equal 'element151cm', @context['product.variants.last.title']
|
||||
|
||||
end
|
||||
|
||||
def test_cents
|
||||
@context.merge("cents" => HundredCentes.new)
|
||||
@context.merge( "cents" => HundredCentes.new )
|
||||
assert_equal 100, @context['cents']
|
||||
end
|
||||
|
||||
def test_nested_cents
|
||||
@context.merge("cents" => { 'amount' => HundredCentes.new })
|
||||
@context.merge( "cents" => { 'amount' => HundredCentes.new} )
|
||||
assert_equal 100, @context['cents.amount']
|
||||
|
||||
@context.merge("cents" => { 'cents' => { 'amount' => HundredCentes.new } })
|
||||
@context.merge( "cents" => { 'cents' => { 'amount' => HundredCentes.new} } )
|
||||
assert_equal 100, @context['cents.cents.amount']
|
||||
end
|
||||
|
||||
def test_cents_through_drop
|
||||
@context.merge("cents" => CentsDrop.new)
|
||||
@context.merge( "cents" => CentsDrop.new )
|
||||
assert_equal 100, @context['cents.amount']
|
||||
end
|
||||
|
||||
def test_nested_cents_through_drop
|
||||
@context.merge("vars" => { "cents" => CentsDrop.new })
|
||||
@context.merge( "vars" => {"cents" => CentsDrop.new} )
|
||||
assert_equal 100, @context['vars.cents.amount']
|
||||
end
|
||||
|
||||
def test_drop_methods_with_question_marks
|
||||
@context.merge("cents" => CentsDrop.new)
|
||||
@context.merge( "cents" => CentsDrop.new )
|
||||
assert @context['cents.non_zero?']
|
||||
end
|
||||
|
||||
def test_context_from_within_drop
|
||||
@context.merge("test" => '123', "vars" => ContextSensitiveDrop.new)
|
||||
@context.merge( "test" => '123', "vars" => ContextSensitiveDrop.new )
|
||||
assert_equal '123', @context['vars.test']
|
||||
end
|
||||
|
||||
def test_nested_context_from_within_drop
|
||||
@context.merge("test" => '123', "vars" => { "local" => ContextSensitiveDrop.new })
|
||||
@context.merge( "test" => '123', "vars" => {"local" => ContextSensitiveDrop.new } )
|
||||
assert_equal '123', @context['vars.local.test']
|
||||
end
|
||||
|
||||
def test_ranges
|
||||
@context.merge("test" => '5')
|
||||
@context.merge( "test" => '5' )
|
||||
assert_equal (1..5), @context['(1..5)']
|
||||
assert_equal (1..5), @context['(1..test)']
|
||||
assert_equal (5..5), @context['(test..test)']
|
||||
end
|
||||
|
||||
def test_cents_through_drop_nestedly
|
||||
@context.merge("cents" => { "cents" => CentsDrop.new })
|
||||
@context.merge( "cents" => {"cents" => CentsDrop.new} )
|
||||
assert_equal 100, @context['cents.cents.amount']
|
||||
|
||||
@context.merge("cents" => { "cents" => { "cents" => CentsDrop.new } })
|
||||
@context.merge( "cents" => { "cents" => {"cents" => CentsDrop.new}} )
|
||||
assert_equal 100, @context['cents.cents.cents.amount']
|
||||
end
|
||||
|
||||
@@ -383,7 +395,7 @@ class ContextUnitTest < Minitest::Test
|
||||
end
|
||||
|
||||
def test_proc_as_variable
|
||||
@context['dynamic'] = proc { 'Hello' }
|
||||
@context['dynamic'] = Proc.new { 'Hello' }
|
||||
|
||||
assert_equal 'Hello', @context['dynamic']
|
||||
end
|
||||
@@ -401,7 +413,7 @@ class ContextUnitTest < Minitest::Test
|
||||
end
|
||||
|
||||
def test_array_containing_lambda_as_variable
|
||||
@context['dynamic'] = [1, 2, proc { 'Hello' }, 4, 5]
|
||||
@context['dynamic'] = [1,2, proc { 'Hello' } ,4,5]
|
||||
|
||||
assert_equal 'Hello', @context['dynamic[2]']
|
||||
end
|
||||
@@ -427,7 +439,7 @@ class ContextUnitTest < Minitest::Test
|
||||
end
|
||||
|
||||
def test_lambda_in_array_is_called_once
|
||||
@context['callcount'] = [1, 2, proc { @global ||= 0; @global += 1; @global.to_s }, 4, 5]
|
||||
@context['callcount'] = [1,2, proc { @global ||= 0; @global += 1; @global.to_s } ,4,5]
|
||||
|
||||
assert_equal '1', @context['callcount[2]']
|
||||
assert_equal '1', @context['callcount[2]']
|
||||
@@ -459,13 +471,16 @@ class ContextUnitTest < Minitest::Test
|
||||
|
||||
refute mock_any.has_been_called?
|
||||
assert mock_empty.has_been_called?
|
||||
end
|
||||
end
|
||||
|
||||
def test_context_initialization_with_a_proc_in_environment
|
||||
contx = Context.new([:test => ->(c) { c['poutine'] }], { :test => :foo })
|
||||
def test_variable_lookup_caches_markup
|
||||
mock_scan = Spy.on_instance_method(String, :scan).and_return(["string"])
|
||||
|
||||
assert contx
|
||||
assert_nil contx['poutine']
|
||||
@context['string'] = 'string'
|
||||
@context['string']
|
||||
@context['string']
|
||||
|
||||
assert_equal 1, mock_scan.calls.size
|
||||
end
|
||||
|
||||
end # ContextTest
|
||||
|
||||
@@ -1,35 +1,35 @@
|
||||
require 'test_helper'
|
||||
|
||||
class FileSystemUnitTest < Minitest::Test
|
||||
class FileSystemUnitTest < Test::Unit::TestCase
|
||||
include Liquid
|
||||
|
||||
def test_default
|
||||
assert_raises(FileSystemError) do
|
||||
BlankFileSystem.new.read_template_file("dummy")
|
||||
assert_raise(FileSystemError) do
|
||||
BlankFileSystem.new.read_template_file("dummy", {'dummy'=>'smarty'})
|
||||
end
|
||||
end
|
||||
|
||||
def test_local
|
||||
file_system = Liquid::LocalFileSystem.new("/some/path")
|
||||
assert_equal "/some/path/_mypartial.liquid", file_system.full_path("mypartial")
|
||||
assert_equal "/some/path/_mypartial.liquid" , file_system.full_path("mypartial")
|
||||
assert_equal "/some/path/dir/_mypartial.liquid", file_system.full_path("dir/mypartial")
|
||||
|
||||
assert_raises(FileSystemError) do
|
||||
assert_raise(FileSystemError) do
|
||||
file_system.full_path("../dir/mypartial")
|
||||
end
|
||||
|
||||
assert_raises(FileSystemError) do
|
||||
assert_raise(FileSystemError) do
|
||||
file_system.full_path("/dir/../../dir/mypartial")
|
||||
end
|
||||
|
||||
assert_raises(FileSystemError) do
|
||||
assert_raise(FileSystemError) do
|
||||
file_system.full_path("/etc/passwd")
|
||||
end
|
||||
end
|
||||
|
||||
def test_custom_template_filename_patterns
|
||||
file_system = Liquid::LocalFileSystem.new("/some/path", "%s.html")
|
||||
assert_equal "/some/path/mypartial.html", file_system.full_path("mypartial")
|
||||
assert_equal "/some/path/mypartial.html" , file_system.full_path("mypartial")
|
||||
assert_equal "/some/path/dir/mypartial.html", file_system.full_path("dir/mypartial")
|
||||
end
|
||||
end # FileSystemTest
|
||||
|
||||
Some files were not shown because too many files have changed in this diff Show More
Reference in New Issue
Block a user