2 |
{{page.title}}
3 | {% for article in blog.articles %}
4 |
5 | {{ article.created_at | date: '%d %b' }}
6 | {{ article.title }}
7 |
8 | {{ article.content }}
9 | {% if blog.comments_enabled? %}
10 |
{{ article.comments_count }} comments
11 | {% endif %}
12 | {% endfor %}
13 |
2 |
{{page.title}}
3 |
4 | {% paginate blog.articles by 20 %}
5 |
6 | {% for article in blog.articles %}
7 |
8 |
9 |
10 |
13 |
Posted on {{ article.created_at | date: "%B %d, '%y" }} by {{ article.author }}.
14 |
15 |
16 |
17 | {{ article.content | strip_html | truncate: 250 }}
18 |
19 |
20 | {% if blog.comments_enabled? %}
21 |
{{ article.comments_count }} comments
22 | {% endif %}
23 |
24 |
25 | {% endfor %}
26 |
27 |
30 |
31 | {% endpaginate %}
32 |
33 |
2 |
3 | {% if collection.description %}
4 |
{{ collection.description }}
5 | {% endif %}
6 |
7 | {% paginate collection.products by 20 %}
8 |
9 |
10 | {% for product in collection.products %}
11 |
12 |
15 |
16 |
17 |
{{ product.description | strip_html | truncatewords: 35 }}
18 |
{{ product.price_min | money }}{% if product.price_varies %} - {{ product.price_max | money }}{% endif %}
19 |
21 | {% endfor %}
22 |
23 |
24 |
27 |
28 | {% endpaginate %}
29 |
2 | {% assign article = pages.frontpage %}
3 | {% if article.content != "" %}
4 |
{{ article.title }}
5 | {{ article.content }}
6 | {% else %}
7 | In Admin > Blogs & Pages , create a page with the handle frontpage
2 |
3 |
Post from our blog...
4 | {% paginate blog.articles by 20 %}
5 | {% for article in blog.articles %}
6 |
7 |
8 |
9 |
10 |
{{ article.created_at | date: "%b %d" }}
11 | {{ article.content }}
12 |
13 |
14 |
15 | {% endfor %}
16 |
17 |
18 | {{ paginate | default_pagination }}
19 |
20 |
21 | {% endpaginate %}
22 |
23 |
24 |
25 |
Why Shop With Us?
26 |
27 |
28 | 24 Hours
29 | We're always here to help.
30 |
31 |
32 | No Spam
33 | We'll never share your info.
34 |
35 |
36 | Secure Servers
37 | Checkout is 256bit encrypted.
38 |
39 |
40 |
41 |
2 |
Featured products...
3 |
4 | {% for product in collections.frontpage.products %}
5 |
6 |
7 |
9 |
10 | {% if product.compare_at_price %}
11 | {% if product.price_min != product.compare_at_price %}
12 |
Was:{{product.compare_at_price | money}}
13 |
Now: {{product.price_min | money}}
14 | {% endif %}
15 | {% else %}
16 |
{{product.price_min | money}}
17 | {% endif %}
18 |
19 | {% endfor %}
20 |
21 |
22 |
23 | {% assign article = pages.frontpage %}
24 | {% if article.content != "" %}
25 |
{{ article.title }}
26 | {{ article.content }}
27 | {% else %}
28 | In Admin > Blogs & Pages , create a page with the handle frontpage
32 |
6 |
Search Results
7 | {% if search.performed %}
8 |
9 | {% paginate search.results by 10 %}
10 |
11 | {% if search.results == empty %}
12 |
Your search for "{{search.terms | escape}}" did not yield any results
13 | {% else %}
14 |
15 |
16 |
24 | {% endif %}
25 |
26 |
27 | {{ paginate | default_pagination }}
28 |
29 |
30 |
31 |
32 |
Why Shop With Us?
33 |
34 |
35 | 24 Hours
36 | We're always here to help.
37 |
38 |
39 | No Spam
40 | We'll never share your info.
41 |
42 |
43 | Secure Servers
44 | Checkout is 256bit encrypted.
45 |
46 |
47 |
48 |
', ''], %().scan(QuotedFragment))
24 | end
25 |
26 | def test_double_quoted_words
27 | assert_equal(['arg1', 'arg2', '"arg 3"'], 'arg1 arg2 "arg 3"'.scan(QuotedFragment))
28 | end
29 |
30 | def test_single_quoted_words
31 | assert_equal(['arg1', 'arg2', "'arg 3'"], 'arg1 arg2 \'arg 3\''.scan(QuotedFragment))
32 | end
33 |
34 | def test_quoted_words_in_the_middle
35 | assert_equal(['arg1', 'arg2', '"arg 3"', 'arg4'], 'arg1 arg2 "arg 3" arg4 '.scan(QuotedFragment))
36 | end
37 |
38 | def test_variable_parser
39 | assert_equal(['var'], 'var'.scan(VariableParser))
40 | assert_equal(['var', 'method'], 'var.method'.scan(VariableParser))
41 | assert_equal(['var', '[method]'], 'var[method]'.scan(VariableParser))
42 | assert_equal(['var', '[method]', '[0]'], 'var[method][0]'.scan(VariableParser))
43 | assert_equal(['var', '["method"]', '[0]'], 'var["method"][0]'.scan(VariableParser))
44 | assert_equal(['var', '[method]', '[0]', 'method'], 'var[method][0].method'.scan(VariableParser))
45 | end
46 | end # RegexpTest
47 |
--------------------------------------------------------------------------------
/lib/liquid/tag.rb:
--------------------------------------------------------------------------------
1 | # frozen_string_literal: true
2 |
3 | module Liquid
4 | class Tag
5 | attr_reader :nodelist, :tag_name, :line_number, :parse_context
6 | alias_method :options, :parse_context
7 | include ParserSwitching
8 |
9 | class << self
10 | def parse(tag_name, markup, tokenizer, parse_context)
11 | tag = new(tag_name, markup, parse_context)
12 | tag.parse(tokenizer)
13 | tag
14 | end
15 |
16 | def disable_tags(*tags)
17 | disabled_tags.push(*tags)
18 | end
19 |
20 | private :new
21 |
22 | def disabled_tags
23 | @disabled_tags ||= []
24 | end
25 | end
26 |
27 | def initialize(tag_name, markup, parse_context)
28 | @tag_name = tag_name
29 | @markup = markup
30 | @parse_context = parse_context
31 | @line_number = parse_context.line_number
32 | end
33 |
34 | def parse(_tokens)
35 | end
36 |
37 | def raw
38 | "#{@tag_name} #{@markup}"
39 | end
40 |
41 | def name
42 | self.class.name.downcase
43 | end
44 |
45 | def render(_context)
46 | ''
47 | end
48 |
49 | def disabled?(context)
50 | context.registers[:disabled_tags].disabled?(tag_name)
51 | end
52 |
53 | def disabled_error_message
54 | "#{tag_name} #{options[:locale].t('errors.disabled.tag')}"
55 | end
56 |
57 | # For backwards compatibility with custom tags. In a future release, the semantics
58 | # of the `render_to_output_buffer` method will become the default and the `render`
59 | # method will be removed.
60 | def render_to_output_buffer(context, output)
61 | output << render(context)
62 | output
63 | end
64 |
65 | def blank?
66 | false
67 | end
68 |
69 | def disabled_tags
70 | self.class.disabled_tags
71 | end
72 | end
73 | end
74 |
--------------------------------------------------------------------------------
/test/unit/lexer_unit_test.rb:
--------------------------------------------------------------------------------
1 | # frozen_string_literal: true
2 |
3 | require 'test_helper'
4 |
5 | class LexerUnitTest < Minitest::Test
6 | include Liquid
7 |
8 | def test_strings
9 | tokens = Lexer.new(%( 'this is a test""' "wat 'lol'")).tokenize
10 | assert_equal([[:string, %('this is a test""')], [:string, %("wat 'lol'")], [:end_of_string]], tokens)
11 | end
12 |
13 | def test_integer
14 | tokens = Lexer.new('hi 50').tokenize
15 | assert_equal([[:id, 'hi'], [:number, '50'], [:end_of_string]], tokens)
16 | end
17 |
18 | def test_float
19 | tokens = Lexer.new('hi 5.0').tokenize
20 | assert_equal([[:id, 'hi'], [:number, '5.0'], [:end_of_string]], tokens)
21 | end
22 |
23 | def test_comparison
24 | tokens = Lexer.new('== <> contains ').tokenize
25 | assert_equal([[:comparison, '=='], [:comparison, '<>'], [:comparison, 'contains'], [:end_of_string]], tokens)
26 | end
27 |
28 | def test_specials
29 | tokens = Lexer.new('| .:').tokenize
30 | assert_equal([[:pipe, '|'], [:dot, '.'], [:colon, ':'], [:end_of_string]], tokens)
31 | tokens = Lexer.new('[,]').tokenize
32 | assert_equal([[:open_square, '['], [:comma, ','], [:close_square, ']'], [:end_of_string]], tokens)
33 | end
34 |
35 | def test_fancy_identifiers
36 | tokens = Lexer.new('hi five?').tokenize
37 | assert_equal([[:id, 'hi'], [:id, 'five?'], [:end_of_string]], tokens)
38 |
39 | tokens = Lexer.new('2foo').tokenize
40 | assert_equal([[:number, '2'], [:id, 'foo'], [:end_of_string]], tokens)
41 | end
42 |
43 | def test_whitespace
44 | tokens = Lexer.new("five|\n\t ==").tokenize
45 | assert_equal([[:id, 'five'], [:pipe, '|'], [:comparison, '=='], [:end_of_string]], tokens)
46 | end
47 |
48 | def test_unexpected_character
49 | assert_raises(SyntaxError) do
50 | Lexer.new("%").tokenize
51 | end
52 | end
53 | end
54 |
--------------------------------------------------------------------------------
/performance/memory_profile.rb:
--------------------------------------------------------------------------------
1 | # frozen_string_literal: true
2 |
3 | require 'benchmark/ips'
4 | require 'memory_profiler'
5 | require 'terminal-table'
6 | require_relative 'theme_runner'
7 |
8 | class Profiler
9 | LOG_LABEL = "Profiling: ".rjust(14).freeze
10 | REPORTS_DIR = File.expand_path('.memprof', __dir__).freeze
11 |
12 | def self.run
13 | puts
14 | yield new
15 | end
16 |
17 | def initialize
18 | @allocated = []
19 | @retained = []
20 | @headings = []
21 | end
22 |
23 | def profile(phase, &block)
24 | print(LOG_LABEL)
25 | print("#{phase}.. ".ljust(10))
26 | report = MemoryProfiler.report(&block)
27 | puts 'Done.'
28 | @headings << phase.capitalize
29 | @allocated << "#{report.scale_bytes(report.total_allocated_memsize)} (#{report.total_allocated} objects)"
30 | @retained << "#{report.scale_bytes(report.total_retained_memsize)} (#{report.total_retained} objects)"
31 |
32 | return if ENV['CI']
33 |
34 | require 'fileutils'
35 | report_file = File.join(REPORTS_DIR, "#{sanitize(phase)}.txt")
36 | FileUtils.mkdir_p(REPORTS_DIR)
37 | report.pretty_print(to_file: report_file, scale_bytes: true)
38 | end
39 |
40 | def tabulate
41 | table = Terminal::Table.new(headings: @headings.unshift('Phase')) do |t|
42 | t << @allocated.unshift('Total allocated')
43 | t << @retained.unshift('Total retained')
44 | end
45 |
46 | puts
47 | puts table
48 | puts "\nDetailed report(s) saved to #{REPORTS_DIR}/" unless ENV['CI']
49 | end
50 |
51 | def sanitize(string)
52 | string.downcase.gsub(/[\W]/, '-').squeeze('-')
53 | end
54 | end
55 |
56 | Liquid::Template.error_mode = ARGV.first.to_sym if ARGV.first
57 |
58 | runner = ThemeRunner.new
59 | Profiler.run do |x|
60 | x.profile('parse') { runner.compile }
61 | x.profile('render') { runner.render }
62 | x.tabulate
63 | end
64 |
--------------------------------------------------------------------------------
/test/unit/tag_unit_test.rb:
--------------------------------------------------------------------------------
1 | # frozen_string_literal: true
2 |
3 | require 'test_helper'
4 |
5 | class TagUnitTest < Minitest::Test
6 | include Liquid
7 |
8 | def test_tag
9 | tag = Tag.parse('tag', "", Tokenizer.new(""), ParseContext.new)
10 | assert_equal('liquid::tag', tag.name)
11 | assert_equal('', tag.render(Context.new))
12 | end
13 |
14 | def test_return_raw_text_of_tag
15 | tag = Tag.parse("long_tag", "param1, param2, param3", Tokenizer.new(""), ParseContext.new)
16 | assert_equal("long_tag param1, param2, param3", tag.raw)
17 | end
18 |
19 | def test_tag_name_should_return_name_of_the_tag
20 | tag = Tag.parse("some_tag", "", Tokenizer.new(""), ParseContext.new)
21 | assert_equal('some_tag', tag.tag_name)
22 | end
23 |
24 | def test_custom_tags_have_a_default_render_to_output_buffer_method_for_backwards_compatibility
25 | klass1 = Class.new(Tag) do
26 | def render(*)
27 | 'hello'
28 | end
29 | end
30 |
31 | with_custom_tag('blabla', klass1) do
32 | template = Liquid::Template.parse("{% blabla %}")
33 |
34 | assert_equal 'hello', template.render
35 |
36 | buf = +''
37 | output = template.render({}, output: buf)
38 | assert_equal 'hello', output
39 | assert_equal 'hello', buf
40 | assert_equal buf.object_id, output.object_id
41 | end
42 |
43 | klass2 = Class.new(klass1) do
44 | def render(*)
45 | 'foo' + super + 'bar'
46 | end
47 | end
48 |
49 | with_custom_tag('blabla', klass2) do
50 | template = Liquid::Template.parse("{% blabla %}")
51 |
52 | assert_equal 'foohellobar', template.render
53 |
54 | buf = +''
55 | output = template.render({}, output: buf)
56 | assert_equal 'foohellobar', output
57 | assert_equal 'foohellobar', buf
58 | assert_equal buf.object_id, output.object_id
59 | end
60 | end
61 | end
62 |
--------------------------------------------------------------------------------
/performance/tests/dropify/index.liquid:
--------------------------------------------------------------------------------
1 |
2 |
Featured Items
3 | {% for product in collections.frontpage.products limit:1 offset:0 %}
4 |
5 |
6 |
7 |
{{ product.description | strip_html | truncatewords: 18 }}
8 |
{{ product.price_min | money }}
9 |
10 | {% endfor %}
11 | {% for product in collections.frontpage.products offset:1 %}
12 |
13 |
14 |
15 |
{{ product.price_min | money }}
16 |
17 | {% endfor %}
18 |
21 | {% assign article = pages.frontpage %}
22 |
23 | {% if article.content != "" %}
24 |
{{ article.title }}
25 |
26 | {{ article.content }}
27 |
28 | {% else %}
29 |
30 | In Admin > Blogs & Pages , create a page with the handle frontpage
33 | {% endif %}
34 |
35 |
38 | {% for article in blogs.news.articles offset:1 %}
39 |
40 |
{{ article.title }}
41 |
42 | {{ article.content }}
43 |
44 |
45 | {% endfor %}
46 |
\n"
35 | context.stack do
36 | tablerowloop = Liquid::TablerowloopDrop.new(length, cols)
37 | context['tablerowloop'] = tablerowloop
38 |
39 | collection.each do |item|
40 | context[@variable_name] = item
41 |
42 | output << ""
43 | super
44 | output << ' '
45 |
46 | if tablerowloop.col_last && !tablerowloop.last
47 | output << " \n"
48 | end
49 |
50 | tablerowloop.send(:increment!)
51 | end
52 | end
53 |
54 | output << " \n"
55 | output
56 | end
57 |
58 | class ParseTreeVisitor < Liquid::ParseTreeVisitor
59 | def children
60 | super + @node.attributes.values + [@node.collection_name]
61 | end
62 | end
63 | end
64 |
65 | Template.register_tag('tablerow', TableRow)
66 | end
67 |
--------------------------------------------------------------------------------
/performance/tests/tribble/page.liquid:
--------------------------------------------------------------------------------
1 |
2 |
3 |
4 |
5 |
{{page.title}}
6 |
7 | {{page.content}}
8 |
9 |
10 |
11 |
12 |
13 |
Featured Products
14 |
15 |
16 | {% for product in collections.frontpage.products %}
17 |
18 |
48 |
49 | {% endfor %}
50 |
51 |
52 |
9 |
10 | {% if cart.item_count == 0 %}
11 |
Your shopping cart is empty...
12 |
13 | {% else %}
14 |
15 |
51 |
52 | {% endif %}
53 |
54 |
{{ item }}
8 | # {% end %}
9 | #
10 | # Item one
11 | # Item two
12 | # Item three
13 | # Item four
14 | # Item five
15 | #
16 | class Cycle < Tag
17 | SimpleSyntax = /\A#{QuotedFragment}+/o
18 | NamedSyntax = /\A(#{QuotedFragment})\s*\:\s*(.*)/om
19 |
20 | attr_reader :variables
21 |
22 | def initialize(tag_name, markup, options)
23 | super
24 | case markup
25 | when NamedSyntax
26 | @variables = variables_from_string(Regexp.last_match(2))
27 | @name = Expression.parse(Regexp.last_match(1))
28 | when SimpleSyntax
29 | @variables = variables_from_string(markup)
30 | @name = @variables.to_s
31 | else
32 | raise SyntaxError, options[:locale].t("errors.syntax.cycle")
33 | end
34 | end
35 |
36 | def render_to_output_buffer(context, output)
37 | context.registers[:cycle] ||= {}
38 |
39 | key = context.evaluate(@name)
40 | iteration = context.registers[:cycle][key].to_i
41 |
42 | val = context.evaluate(@variables[iteration])
43 |
44 | if val.is_a?(Array)
45 | val = val.join
46 | elsif !val.is_a?(String)
47 | val = val.to_s
48 | end
49 |
50 | output << val
51 |
52 | iteration += 1
53 | iteration = 0 if iteration >= @variables.size
54 |
55 | context.registers[:cycle][key] = iteration
56 | output
57 | end
58 |
59 | private
60 |
61 | def variables_from_string(markup)
62 | markup.split(',').collect do |var|
63 | var =~ /\s*(#{QuotedFragment})\s*/o
64 | Regexp.last_match(1) ? Expression.parse(Regexp.last_match(1)) : nil
65 | end.compact
66 | end
67 |
68 | class ParseTreeVisitor < Liquid::ParseTreeVisitor
69 | def children
70 | Array(@node.variables)
71 | end
72 | end
73 | end
74 |
75 | Template.register_tag('cycle', Cycle)
76 | end
77 |
--------------------------------------------------------------------------------
/performance/tests/tribble/404.liquid:
--------------------------------------------------------------------------------
1 |
2 |
3 |
4 |
5 |
Oh no!
6 |
7 | Seems like you are looking for something that just isn't here.
Try heading back to our main page . Or you can checkout some of our featured products below.
8 |
9 |
10 |
11 |
12 |
13 |
Featured Products
14 |
15 |
16 | {% for product in collections.frontpage.products %}
17 |
18 |
48 |
49 | {% endfor %}
50 |
51 |
52 |
9 |
10 | {% if cart.item_count == 0 %}
11 |
Your shopping cart is looking rather empty...
12 | {% else %}
13 |
63 |
64 | {% endif %}
65 |
66 |
2 |
{{ article.title }}
3 |
posted {{ article.created_at | date: "%Y %h" }} by {{ article.author }}
4 |
5 | {{ article.content }}
6 |
7 |
2 |
{{ collection.title }}
3 | {% if collection.description.size > 0 %}
4 |
{{ collection.description }}
5 | {% endif %}
6 |
7 | {% paginate collection.products by 8 %}
8 |
9 |
10 | {% for product in collection.products %}
11 |
12 |
42 |
43 | {% endfor %}
44 |
45 |
46 |
47 | {{ paginate | default_pagination }}
48 |
49 |
50 |
51 |
52 |
Why Shop With Us?
53 |
54 |
55 | 24 Hours
56 | We're always here to help.
57 |
58 |
59 | No Spam
60 | We'll never share your info.
61 |
62 |
63 | Secure Servers
64 | Checkout is 256bit encrypted.
65 |
66 |
67 |
68 |
2 | {% for image in product.images %}{% if forloop.first %}
3 |
4 |
{% else %}
5 |
6 |
7 |
{% endif %}{% endfor %}
8 |
10 |
{{ product.title }}
11 | {{ product.description }}
12 |
13 | {% if product.available %}
14 |
28 | {% else %}
29 |
This product is temporarily unavailable
30 | {% endif %}
31 |
32 |
33 | Continue Shopping
36 |
{{shop.name}} - {{page_title}}
5 | Skip to navigation.
20 |
21 |
22 |
25 |
26 | {{ content_for_layout }}
27 |
28 |
29 | {% if template != 'cart' %}
30 |
42 | {% endif %}
43 |
44 |
45 | Search
46 |
47 |
52 |
53 |
54 |
55 |
56 |
57 | Navigation
58 | {% for link in linklists.main-menu.links %}
59 | {{ link.title | link_to: link.url }}
60 | {% endfor %}
61 |
62 |
63 | {% if tags %}
64 |
65 | Tags
66 | {% for tag in collection.tags %}
67 | {{ tag | highlight_active_tag | link_to_tag: tag }}
68 | {% endfor %}
69 |
70 | {% endif %}
71 |
72 |
73 |
74 |
75 |
76 |
2 |
3 |
4 | {% for image in product.images %}
5 | {% if forloop.first %}
6 |
7 |
9 | {% else %}
10 |
11 |
13 | {% endif %}
14 | {% endfor %}
15 |
16 |
17 |
{{ product.title }}
18 |
19 |
20 | Vendor: {{ product.vendor | link_to_vendor }}
21 | Type: {{ product.type | link_to_type }}
22 |
23 |
24 |
{{ product.price_min | money }}{% if product.price_varies %} - {{ product.price_max | money }}{% endif %}
25 |
26 |
40 |
41 |
42 | {{ product.description }}
43 |
44 |
2 |
{{ article.title }}
3 |
posted {{ article.created_at | date: "%Y %h" }} by {{ article.author }}
4 |
5 |
6 | {{ article.content }}
7 |
8 |
9 |
2 |
{{ article.title }}
3 |
posted {{ article.created_at | date: "%Y %h" }} by {{ article.author }}
4 |
5 |
6 | {{ article.content }}
7 |
8 |
9 |
2 |
{{ product.title }}
3 |
4 |
5 | {% for image in product.images %}
6 | {% if forloop.first %}
7 |
8 |
10 | {% else %}
11 |
12 |
14 | {% endif %}
15 | {% endfor %}
16 |
17 |
18 |
19 | Vendor: {{ product.vendor | link_to_vendor }}
20 | Type: {{ product.type | link_to_type }}
21 |
22 |
23 |
{{ product.price_min | money }}{% if product.price_varies %} - {{ product.price_max | money }}{% endif %}
24 |
25 |
26 | {% if product.available %}
27 |
28 |
40 | {% else %}
41 |
Sold Out!
42 | {% endif %}
43 |
44 |
45 |
46 | {{ product.description }}
47 |
48 |
49 |
Shopping Cart
2 | {% if cart.item_count == 0 %}
3 | Your shopping basket is empty. Perhaps a featured item below is of interest...
4 |
5 | {% tablerow product in collections.frontpage.products cols: 3 limit: 12 %}
6 |
7 |
8 |
10 |
{{ product.title | truncate: 30 }}
11 |
{{ product.price | money }}{% if product.compare_at_price_max > product.price %} {{ product.compare_at_price_max | money }}{% endif %}
12 |
15 | {% else %}
16 |
22 | {% endif %}
59 |
--------------------------------------------------------------------------------
/performance/tests/tribble/theme.liquid:
--------------------------------------------------------------------------------
1 |
2 |
3 |
4 | {{shop.name}} - {{page_title}}
5 |
21 |
22 |
23 |
24 |
Shopping Cart
25 |
26 | {% if cart.item_count == 0 %}
27 | Your cart is currently empty
28 | {% else %}
29 | {{ cart.item_count }} {{ cart.item_count | pluralize: 'item', 'items' }} - Total: {{cart.total_price | money_with_currency }} - View Cart
30 | {% endif %}
31 |
32 |
33 |
34 |
35 |
36 |
Tribble: A Shopify Theme
37 |
38 |
39 |
40 |
41 |
42 | {% for link in linklists.main-menu.links %}
43 | {{ link.title | link_to: link.url }}
44 | {% endfor %}
45 |
46 |
47 | {{ content_for_layout }}
48 |
49 |
86 |
87 |
#{link} )
26 | end
27 |
28 | def img_tag(url, alt = "")
29 | %(#{link_to(paginate['previous']['title'], paginate['previous']['url'])} ) if paginate['previous']
74 |
75 | paginate['parts'].each do |part|
76 | html << if part['is_link']
77 | %(#{link_to(part['title'], part['url'])} )
78 | elsif part['title'].to_i == paginate['current_page'].to_i
79 | %(#{part['title']} )
80 | else
81 | %(#{part['title']} )
82 | end
83 | end
84 |
85 | html << %(#{link_to(paginate['next']['title'], paginate['next']['url'])} ) if paginate['next']
86 | html.join(' ')
87 | end
88 |
89 | # Accepts a number, and two words - one for singular, one for plural
90 | # Returns the singular word if input equals 1, otherwise plural
91 | def pluralize(input, singular, plural)
92 | input == 1 ? singular : plural
93 | end
94 |
95 | private
96 |
97 | def to_handle(str)
98 | result = str.dup
99 | result.downcase!
100 | result.delete!("'\"()[]")
101 | result.gsub!(/\W+/, '-')
102 | result.gsub!(/-+\z/, '') if result[-1] == '-'
103 | result.gsub!(/\A-+/, '') if result[0] == '-'
104 | result
105 | end
106 | end
107 |
--------------------------------------------------------------------------------
/performance/tests/tribble/index.liquid:
--------------------------------------------------------------------------------
1 |
2 |
3 |
Three Great Reasons You Should Shop With Us...
4 |
5 |
6 | Free Shipping
7 | On all orders over $25
8 |
9 |
10 | Top Quality
11 | Hand made in our shop
12 |
13 |
14 | 100% Guarantee
15 | Any time, any reason
16 |
17 |
18 |
19 |
22 |
23 |
{{pages.alert.content}}
24 |
25 |
26 |
27 | {% for product in collections.frontpage.products %}
28 |
29 |
59 |
60 | {% endfor %}
61 |
62 |
63 |
64 |
65 |
66 |
Why Shop With Us?
67 |
68 |
69 | 24 Hours
70 | We're always here to help.
71 |
72 |
73 | No Spam
74 | We'll never share your info.
75 |
76 |
77 | Save Energy
78 | We're green, all the way.
79 |
80 |
81 | Secure Servers
82 | Checkout is 256bits encrypted.
83 |
84 |
85 |
86 |
87 |
88 |
Our Company
89 | {{pages.about-us.content | truncatewords: 49}}
read more
90 |
91 |
92 |
93 |
3 |
4 |
5 |
6 |
{{article.title}}
7 |
8 |
{{ article.created_at | date: "%b %d" }}
9 | {{ article.content }}
10 |
11 |
12 |
13 | {% if blog.comments_enabled? %}
14 |
74 | {% endif %}
75 |
76 |
77 |
78 |
79 |
80 |
81 |
82 |
Why Shop With Us?
83 |
84 |
85 | 24 Hours
86 | We're always here to help.
87 |
88 |
89 | No Spam
90 | We'll never share your info.
91 |
92 |
93 | Secure Servers
94 | Checkout is 256bit encrypted.
95 |
96 |
97 |
98 |
\n 1 2 3 \n 4 5 6 \n \n",
26 | '{% tablerow n in numbers cols:3%} {{n}} {% endtablerow %}',
27 | 'numbers' => [])
28 | end
29 |
30 | def test_table_row_with_different_cols
31 | assert_template_result("\n 1 2 3 4 5 \n 6 \n1 2 \n1 2 1 2 \n 1 2 3 \n 4 5 6 \n 1 2 3 \n 4 5 6 \n 1 2 3 \n 4 5 6 \n 1 2 3 \n 4 5 6 \n \n", "{% tablerow char in characters cols:3 %}I WILL NOT BE OUTPUT{% endtablerow %}", 'characters' => '')
65 | end
66 | end
67 |
--------------------------------------------------------------------------------
/lib/liquid.rb:
--------------------------------------------------------------------------------
1 | # frozen_string_literal: true
2 |
3 | # Copyright (c) 2005 Tobias Luetke
4 | #
5 | # Permission is hereby granted, free of charge, to any person obtaining
6 | # a copy of this software and associated documentation files (the
7 | # "Software"), to deal in the Software without restriction, including
8 | # without limitation the rights to use, copy, modify, merge, publish,
9 | # distribute, sublicense, and/or sell copies of the Software, and to
10 | # permit persons to whom the Software is furnished to do so, subject to
11 | # the following conditions:
12 | #
13 | # The above copyright notice and this permission notice shall be
14 | # included in all copies or substantial portions of the Software.
15 | #
16 | # THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND,
17 | # EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF
18 | # MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND
19 | # NONINFRINGEMENT. IN NO EVENT SHALL THE AUTHORS OR COPYRIGHT HOLDERS BE
20 | # LIABLE FOR ANY CLAIM, DAMAGES OR OTHER LIABILITY, WHETHER IN AN ACTION
21 | # OF CONTRACT, TORT OR OTHERWISE, ARISING FROM, OUT OF OR IN CONNECTION
22 | # WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE SOFTWARE.
23 |
24 | module Liquid
25 | FilterSeparator = /\|/
26 | ArgumentSeparator = ','
27 | FilterArgumentSeparator = ':'
28 | VariableAttributeSeparator = '.'
29 | WhitespaceControl = '-'
30 | TagStart = /\{\%/
31 | TagEnd = /\%\}/
32 | VariableSignature = /\(?[\w\-\.\[\]]\)?/
33 | VariableSegment = /[\w\-]/
34 | VariableStart = /\{\{/
35 | VariableEnd = /\}\}/
36 | VariableIncompleteEnd = /\}\}?/
37 | QuotedString = /"[^"]*"|'[^']*'/
38 | QuotedFragment = /#{QuotedString}|(?:[^\s,\|'"]|#{QuotedString})+/o
39 | TagAttributes = /(\w+)\s*\:\s*(#{QuotedFragment})/o
40 | AnyStartingTag = /#{TagStart}|#{VariableStart}/o
41 | PartialTemplateParser = /#{TagStart}.*?#{TagEnd}|#{VariableStart}.*?#{VariableIncompleteEnd}/om
42 | TemplateParser = /(#{PartialTemplateParser}|#{AnyStartingTag})/om
43 | VariableParser = /\[[^\]]+\]|#{VariableSegment}+\??/o
44 |
45 | singleton_class.send(:attr_accessor, :cache_classes)
46 | self.cache_classes = true
47 | end
48 |
49 | require "liquid/version"
50 | require 'liquid/parse_tree_visitor'
51 | require 'liquid/lexer'
52 | require 'liquid/parser'
53 | require 'liquid/i18n'
54 | require 'liquid/drop'
55 | require 'liquid/tablerowloop_drop'
56 | require 'liquid/forloop_drop'
57 | require 'liquid/extensions'
58 | require 'liquid/errors'
59 | require 'liquid/interrupts'
60 | require 'liquid/strainer_factory'
61 | require 'liquid/strainer_template'
62 | require 'liquid/expression'
63 | require 'liquid/context'
64 | require 'liquid/parser_switching'
65 | require 'liquid/tag'
66 | require 'liquid/block'
67 | require 'liquid/block_body'
68 | require 'liquid/document'
69 | require 'liquid/variable'
70 | require 'liquid/variable_lookup'
71 | require 'liquid/range_lookup'
72 | require 'liquid/file_system'
73 | require 'liquid/resource_limits'
74 | require 'liquid/template'
75 | require 'liquid/standardfilters'
76 | require 'liquid/condition'
77 | require 'liquid/utils'
78 | require 'liquid/tokenizer'
79 | require 'liquid/parse_context'
80 | require 'liquid/partial_cache'
81 | require 'liquid/usage'
82 | require 'liquid/register'
83 | require 'liquid/static_registers'
84 | require 'liquid/template_factory'
85 |
86 | # Load all the tags of the standard library
87 | #
88 | Dir["#{__dir__}/liquid/tags/*.rb"].each { |f| require f }
89 | Dir["#{__dir__}/liquid/registers/*.rb"].each { |f| require f }
90 |
--------------------------------------------------------------------------------
/test/integration/variable_test.rb:
--------------------------------------------------------------------------------
1 | # frozen_string_literal: true
2 |
3 | require 'test_helper'
4 |
5 | class VariableTest < Minitest::Test
6 | include Liquid
7 |
8 | def test_simple_variable
9 | template = Template.parse(%({{test}}))
10 | assert_equal('worked', template.render!('test' => 'worked'))
11 | assert_equal('worked wonderfully', template.render!('test' => 'worked wonderfully'))
12 | end
13 |
14 | def test_variable_render_calls_to_liquid
15 | assert_template_result('foobar', '{{ foo }}', 'foo' => ThingWithToLiquid.new)
16 | end
17 |
18 | def test_simple_with_whitespaces
19 | template = Template.parse(%( {{ test }} ))
20 | assert_equal(' worked ', template.render!('test' => 'worked'))
21 | assert_equal(' worked wonderfully ', template.render!('test' => 'worked wonderfully'))
22 | end
23 |
24 | def test_ignore_unknown
25 | template = Template.parse(%({{ test }}))
26 | assert_equal('', template.render!)
27 | end
28 |
29 | def test_using_blank_as_variable_name
30 | template = Template.parse("{% assign foo = blank %}{{ foo }}")
31 | assert_equal('', template.render!)
32 | end
33 |
34 | def test_using_empty_as_variable_name
35 | template = Template.parse("{% assign foo = empty %}{{ foo }}")
36 | assert_equal('', template.render!)
37 | end
38 |
39 | def test_hash_scoping
40 | template = Template.parse(%({{ test.test }}))
41 | assert_equal('worked', template.render!('test' => { 'test' => 'worked' }))
42 | end
43 |
44 | def test_false_renders_as_false
45 | assert_equal('false', Template.parse("{{ foo }}").render!('foo' => false))
46 | assert_equal('false', Template.parse("{{ false }}").render!)
47 | end
48 |
49 | def test_nil_renders_as_empty_string
50 | assert_equal('', Template.parse("{{ nil }}").render!)
51 | assert_equal('cat', Template.parse("{{ nil | append: 'cat' }}").render!)
52 | end
53 |
54 | def test_preset_assigns
55 | template = Template.parse(%({{ test }}))
56 | template.assigns['test'] = 'worked'
57 | assert_equal('worked', template.render!)
58 | end
59 |
60 | def test_reuse_parsed_template
61 | template = Template.parse(%({{ greeting }} {{ name }}))
62 | template.assigns['greeting'] = 'Goodbye'
63 | assert_equal('Hello Tobi', template.render!('greeting' => 'Hello', 'name' => 'Tobi'))
64 | assert_equal('Hello ', template.render!('greeting' => 'Hello', 'unknown' => 'Tobi'))
65 | assert_equal('Hello Brian', template.render!('greeting' => 'Hello', 'name' => 'Brian'))
66 | assert_equal('Goodbye Brian', template.render!('name' => 'Brian'))
67 | assert_equal({ 'greeting' => 'Goodbye' }, template.assigns)
68 | end
69 |
70 | def test_assigns_not_polluted_from_template
71 | template = Template.parse(%({{ test }}{% assign test = 'bar' %}{{ test }}))
72 | template.assigns['test'] = 'baz'
73 | assert_equal('bazbar', template.render!)
74 | assert_equal('bazbar', template.render!)
75 | assert_equal('foobar', template.render!('test' => 'foo'))
76 | assert_equal('bazbar', template.render!)
77 | end
78 |
79 | def test_hash_with_default_proc
80 | template = Template.parse(%(Hello {{ test }}))
81 | assigns = Hash.new { |_h, k| raise "Unknown variable '#{k}'" }
82 | assigns['test'] = 'Tobi'
83 | assert_equal('Hello Tobi', template.render!(assigns))
84 | assigns.delete('test')
85 | e = assert_raises(RuntimeError) do
86 | template.render!(assigns)
87 | end
88 | assert_equal("Unknown variable 'test'", e.message)
89 | end
90 |
91 | def test_multiline_variable
92 | assert_equal('worked', Template.parse("{{\ntest\n}}").render!('test' => 'worked'))
93 | end
94 |
95 | def test_render_symbol
96 | assert_template_result('bar', '{{ foo }}', 'foo' => :bar)
97 | end
98 | end
99 |
--------------------------------------------------------------------------------
Comments
12 | 13 | 14 |15 | {% for comment in article.comments %} 16 |-
17 |
18 | {{ comment.content }}
19 |
20 |
21 |
22 | Posted by {{ comment.author }} on {{ comment.created_at | date: "%B %d, %Y" }}
23 |
24 |
25 | {% endfor %}
26 |
27 | 28 | 29 | {% form article %} 30 |Leave a comment
31 | 32 | 33 | {% if form.posted_successfully? %} 34 | {% if blog.moderated? %} 35 |37 | It will have to be approved by the blog owner first before showing up. 38 |
49 | 50 | 51 | 52 | 53 | 54 | 55 | 56 | 57 |
58 | 59 | {% if blog.moderated? %} 60 |comments have to be approved before showing up
61 | {% endif %} 62 | 63 | 64 | {% endform %} 65 |