From da9051eb184e5ed2494295aa3dd99ab813fceee5 Mon Sep 17 00:00:00 2001 From: Mike Angell Date: Mon, 26 Aug 2019 19:39:22 +1000 Subject: [PATCH] Upgrade rubocop --- .gitignore | 1 + .rubocop.shopify.yml | 1027 +++++++++++++++++ .rubocop.yml | 133 +-- .rubocop_todo.yml | 260 ----- .travis.yml | 11 +- Gemfile | 10 +- History.md | 2 +- Rakefile | 55 +- example/server/example_servlet.rb | 16 +- example/server/liquid_servlet.rb | 15 +- example/server/server.rb | 4 +- lib/liquid.rb | 42 +- lib/liquid/block.rb | 29 +- lib/liquid/block_body.rb | 59 +- lib/liquid/condition.rb | 34 +- lib/liquid/context.rb | 19 +- lib/liquid/document.rb | 10 +- lib/liquid/drop.rb | 7 +- lib/liquid/errors.rb | 22 +- lib/liquid/expression.rb | 30 +- lib/liquid/extensions.rb | 2 + lib/liquid/file_system.rb | 10 +- lib/liquid/forloop_drop.rb | 2 + lib/liquid/i18n.rb | 10 +- lib/liquid/interrupts.rb | 8 +- lib/liquid/lexer.rb | 54 +- lib/liquid/parse_context.rb | 5 +- lib/liquid/parse_tree_visitor.rb | 2 +- lib/liquid/parser.rb | 20 +- lib/liquid/parser_switching.rb | 2 + lib/liquid/profiler.rb | 6 +- lib/liquid/profiler/hooks.rb | 2 + lib/liquid/range_lookup.rb | 2 + lib/liquid/resource_limits.rb | 4 +- lib/liquid/standardfilters.rb | 57 +- lib/liquid/strainer.rb | 22 +- lib/liquid/tablerowloop_drop.rb | 2 + lib/liquid/tag.rb | 7 +- lib/liquid/tags/assign.rb | 14 +- lib/liquid/tags/break.rb | 4 +- lib/liquid/tags/capture.rb | 12 +- lib/liquid/tags/case.rb | 34 +- lib/liquid/tags/comment.rb | 7 +- lib/liquid/tags/continue.rb | 4 +- lib/liquid/tags/cycle.rb | 20 +- lib/liquid/tags/decrement.rb | 4 +- lib/liquid/tags/for.rb | 50 +- lib/liquid/tags/if.rb | 37 +- lib/liquid/tags/ifchanged.rb | 6 +- lib/liquid/tags/include.rb | 28 +- lib/liquid/tags/increment.rb | 4 +- lib/liquid/tags/raw.rb | 24 +- lib/liquid/tags/table_row.rb | 30 +- lib/liquid/tags/unless.rb | 12 +- lib/liquid/template.rb | 26 +- lib/liquid/tokenizer.rb | 6 +- lib/liquid/utils.rb | 18 +- lib/liquid/variable.rb | 31 +- lib/liquid/variable_lookup.rb | 19 +- lib/liquid/version.rb | 4 +- liquid.gemspec | 36 +- performance/benchmark.rb | 8 +- performance/memory_profile.rb | 4 +- performance/profile.rb | 8 +- performance/shopify/comment_form.rb | 14 +- performance/shopify/database.rb | 17 +- performance/shopify/json_filter.rb | 4 +- performance/shopify/liquid.rb | 18 +- performance/shopify/money_filter.rb | 8 +- performance/shopify/paginate.rb | 33 +- performance/shopify/shop_filter.rb | 26 +- performance/shopify/tag_filter.rb | 6 +- performance/shopify/weight_filter.rb | 4 +- performance/theme_runner.rb | 4 +- test/integration/assign_test.rb | 20 +- test/integration/blank_test.rb | 48 +- test/integration/block_test.rb | 4 +- test/integration/capture_test.rb | 10 +- test/integration/context_test.rb | 2 + test/integration/document_test.rb | 6 +- test/integration/drop_test.rb | 64 +- test/integration/error_handling_test.rb | 51 +- test/integration/filter_test.rb | 74 +- test/integration/hash_ordering_test.rb | 8 +- test/integration/output_test.rb | 16 +- test/integration/parse_tree_visitor_test.rb | 68 +- test/integration/parsing_quirks_test.rb | 34 +- test/integration/render_profiling_test.rb | 22 +- test/integration/security_test.rb | 14 +- test/integration/standard_filter_test.rb | 484 ++++---- test/integration/tags/break_tag_test.rb | 2 + test/integration/tags/continue_tag_test.rb | 2 + test/integration/tags/for_tag_test.rb | 118 +- test/integration/tags/if_else_tag_test.rb | 30 +- test/integration/tags/include_tag_test.rb | 127 +- test/integration/tags/increment_tag_test.rb | 16 +- test/integration/tags/raw_tag_test.rb | 4 +- test/integration/tags/standard_tag_test.rb | 158 +-- test/integration/tags/statements_test.rb | 2 + test/integration/tags/table_row_test.rb | 36 +- test/integration/tags/unless_else_tag_test.rb | 4 +- test/integration/template_test.rb | 160 +-- test/integration/trim_mode_test.rb | 62 +- test/integration/variable_test.rb | 14 +- test/test_helper.rb | 23 +- test/unit/block_unit_test.rb | 28 +- test/unit/condition_unit_test.rb | 32 +- test/unit/context_unit_test.rb | 91 +- test/unit/file_system_unit_test.rb | 22 +- test/unit/i18n_unit_test.rb | 12 +- test/unit/lexer_unit_test.rb | 4 +- test/unit/parser_unit_test.rb | 20 +- test/unit/regexp_unit_test.rb | 32 +- test/unit/strainer_unit_test.rb | 39 +- test/unit/tag_unit_test.rb | 18 +- test/unit/tags/case_tag_unit_test.rb | 4 +- test/unit/tags/for_tag_unit_test.rb | 4 +- test/unit/tags/if_tag_unit_test.rb | 4 +- test/unit/template_unit_test.rb | 8 +- test/unit/tokenizer_unit_test.rb | 10 +- test/unit/variable_unit_test.rb | 10 +- 121 files changed, 2736 insertions(+), 1872 deletions(-) create mode 100644 .rubocop.shopify.yml delete mode 100644 .rubocop_todo.yml diff --git a/.gitignore b/.gitignore index 90bf6dc..0462fcc 100644 --- a/.gitignore +++ b/.gitignore @@ -4,6 +4,7 @@ pkg *.rbc .rvmrc +.idea .ruby-version Gemfile.lock .bundle diff --git a/.rubocop.shopify.yml b/.rubocop.shopify.yml new file mode 100644 index 0000000..5f5212c --- /dev/null +++ b/.rubocop.shopify.yml @@ -0,0 +1,1027 @@ +AllCops: + Exclude: + - 'db/schema.rb' + DisabledByDefault: true + StyleGuideBaseURL: https://shopify.github.io/ruby-style-guide/ + +Lint/AssignmentInCondition: + Enabled: true + +Layout/AccessModifierIndentation: + EnforcedStyle: indent + SupportedStyles: + - outdent + - indent + IndentationWidth: + +Style/Alias: + EnforcedStyle: prefer_alias_method + SupportedStyles: + - prefer_alias + - prefer_alias_method + +Layout/AlignHash: + EnforcedHashRocketStyle: key + EnforcedColonStyle: key + EnforcedLastArgumentHashStyle: ignore_implicit + SupportedLastArgumentHashStyles: + - always_inspect + - always_ignore + - ignore_implicit + - ignore_explicit + +Layout/AlignParameters: + EnforcedStyle: with_fixed_indentation + SupportedStyles: + - with_first_parameter + - with_fixed_indentation + IndentationWidth: + +Style/AndOr: + EnforcedStyle: always + SupportedStyles: + - always + - conditionals + +Style/BarePercentLiterals: + EnforcedStyle: bare_percent + SupportedStyles: + - percent_q + - bare_percent + +Style/BlockDelimiters: + EnforcedStyle: line_count_based + SupportedStyles: + - line_count_based + - semantic + - braces_for_chaining + ProceduralMethods: + - benchmark + - bm + - bmbm + - create + - each_with_object + - measure + - new + - realtime + - tap + - with_object + FunctionalMethods: + - let + - let! + - subject + - watch + IgnoredMethods: + - lambda + - proc + - it + +Style/BracesAroundHashParameters: + EnforcedStyle: no_braces + SupportedStyles: + - braces + - no_braces + - context_dependent + +Layout/CaseIndentation: + EnforcedStyle: end + SupportedStyles: + - case + - end + IndentOneStep: false + IndentationWidth: + +Style/ClassAndModuleChildren: + EnforcedStyle: nested + SupportedStyles: + - nested + - compact + +Style/ClassCheck: + EnforcedStyle: is_a? + SupportedStyles: + - is_a? + - kind_of? + +Style/CommandLiteral: + EnforcedStyle: percent_x + SupportedStyles: + - backticks + - percent_x + - mixed + AllowInnerBackticks: false + +Style/CommentAnnotation: + Keywords: + - TODO + - FIXME + - OPTIMIZE + - HACK + - REVIEW + +Style/ConditionalAssignment: + EnforcedStyle: assign_to_condition + SupportedStyles: + - assign_to_condition + - assign_inside_condition + SingleLineConditionsOnly: true + +Layout/DotPosition: + EnforcedStyle: leading + SupportedStyles: + - leading + - trailing + +Style/EmptyElse: + EnforcedStyle: both + SupportedStyles: + - empty + - nil + - both + +Layout/EmptyLineBetweenDefs: + AllowAdjacentOneLineDefs: false + +Layout/EmptyLinesAroundBlockBody: + EnforcedStyle: no_empty_lines + SupportedStyles: + - empty_lines + - no_empty_lines + +Layout/EmptyLinesAroundClassBody: + EnforcedStyle: no_empty_lines + SupportedStyles: + - empty_lines + - empty_lines_except_namespace + - no_empty_lines + +Layout/EmptyLinesAroundModuleBody: + EnforcedStyle: no_empty_lines + SupportedStyles: + - empty_lines + - empty_lines_except_namespace + - no_empty_lines + +Layout/ExtraSpacing: + AllowForAlignment: true + ForceEqualSignAlignment: false + +Naming/FileName: + Exclude: [] + ExpectMatchingDefinition: false + Regex: + IgnoreExecutableScripts: true + +Layout/IndentFirstArgument: + EnforcedStyle: consistent + SupportedStyles: + - consistent + - special_for_inner_method_call + - special_for_inner_method_call_in_parentheses + IndentationWidth: + +Style/For: + EnforcedStyle: each + SupportedStyles: + - for + - each + +Style/FormatString: + EnforcedStyle: format + SupportedStyles: + - format + - sprintf + - percent + +Style/FrozenStringLiteralComment: + Details: >- + Add `# frozen_string_literal: true` to the top of the file. Frozen string + literals will become the default in a future Ruby version, and we want to + make sure we're ready. + EnforcedStyle: always + SupportedStyles: + - always + - never + +Style/GlobalVars: + AllowedVariables: [] + +Style/HashSyntax: + EnforcedStyle: ruby19 + SupportedStyles: + - ruby19 + - hash_rockets + - no_mixed_keys + - ruby19_no_mixed_keys + UseHashRocketsWithSymbolValues: false + PreferHashRocketsForNonAlnumEndingSymbols: false + +Layout/IndentationConsistency: + EnforcedStyle: normal + SupportedStyles: + - normal + - rails + +Layout/IndentationWidth: + Width: 2 + +Layout/IndentFirstArrayElement: + EnforcedStyle: consistent + SupportedStyles: + - special_inside_parentheses + - consistent + - align_brackets + IndentationWidth: + +Layout/IndentAssignment: + IndentationWidth: + +Layout/IndentFirstHashElement: + EnforcedStyle: consistent + SupportedStyles: + - special_inside_parentheses + - consistent + - align_braces + IndentationWidth: + +Style/LambdaCall: + EnforcedStyle: call + SupportedStyles: + - call + - braces + +Style/Next: + EnforcedStyle: skip_modifier_ifs + MinBodyLength: 3 + SupportedStyles: + - skip_modifier_ifs + - always + +Style/NonNilCheck: + IncludeSemanticChanges: false + +Style/MethodCallWithArgsParentheses: + Enabled: true + IgnoreMacros: true + IgnoredMethods: + - require + - require_relative + - require_dependency + - yield + - raise + - puts + Exclude: + - Gemfile + +Style/MethodDefParentheses: + EnforcedStyle: require_parentheses + SupportedStyles: + - require_parentheses + - require_no_parentheses + - require_no_parentheses_except_multiline + +Naming/MethodName: + EnforcedStyle: snake_case + SupportedStyles: + - snake_case + - camelCase + +Layout/MultilineArrayBraceLayout: + EnforcedStyle: symmetrical + SupportedStyles: + - symmetrical + - new_line + - same_line + +Layout/MultilineHashBraceLayout: + EnforcedStyle: symmetrical + SupportedStyles: + - symmetrical + - new_line + - same_line + +Layout/MultilineMethodCallBraceLayout: + EnforcedStyle: symmetrical + SupportedStyles: + - symmetrical + - new_line + - same_line + +Layout/MultilineMethodCallIndentation: + EnforcedStyle: indented + SupportedStyles: + - aligned + - indented + - indented_relative_to_receiver + IndentationWidth: 2 + +Layout/MultilineMethodDefinitionBraceLayout: + EnforcedStyle: symmetrical + SupportedStyles: + - symmetrical + - new_line + - same_line + +Style/NumericLiteralPrefix: + EnforcedOctalStyle: zero_only + SupportedOctalStyles: + - zero_with_o + - zero_only + +Style/ParenthesesAroundCondition: + AllowSafeAssignment: true + +Style/PercentQLiterals: + EnforcedStyle: lower_case_q + SupportedStyles: + - lower_case_q + - upper_case_q + +Naming/PredicateName: + NamePrefix: + - is_ + NamePrefixBlacklist: + - is_ + NameWhitelist: + - is_a? + Exclude: + - 'spec/**/*' + +Style/PreferredHashMethods: + EnforcedStyle: short + SupportedStyles: + - short + - verbose + +Style/RaiseArgs: + EnforcedStyle: exploded + SupportedStyles: + - compact + - exploded + +Style/RedundantReturn: + AllowMultipleReturnValues: false + +Style/RegexpLiteral: + EnforcedStyle: mixed + SupportedStyles: + - slashes + - percent_r + - mixed + AllowInnerSlashes: false + +Style/SafeNavigation: + ConvertCodeThatCanStartToReturnNil: false + Enabled: true + +Lint/SafeNavigationChain: + Enabled: true + +Style/Semicolon: + AllowAsExpressionSeparator: false + +Style/SignalException: + EnforcedStyle: only_raise + SupportedStyles: + - only_raise + - only_fail + - semantic + +Style/SingleLineMethods: + AllowIfMethodIsEmpty: true + +Layout/SpaceBeforeFirstArg: + AllowForAlignment: true + +Style/SpecialGlobalVars: + EnforcedStyle: use_english_names + SupportedStyles: + - use_perl_names + - use_english_names + +Style/StabbyLambdaParentheses: + EnforcedStyle: require_parentheses + SupportedStyles: + - require_parentheses + - require_no_parentheses + +Style/StringLiteralsInInterpolation: + EnforcedStyle: single_quotes + SupportedStyles: + - single_quotes + - double_quotes + +Layout/SpaceAroundBlockParameters: + EnforcedStyleInsidePipes: no_space + SupportedStylesInsidePipes: + - space + - no_space + +Layout/SpaceAroundEqualsInParameterDefault: + EnforcedStyle: space + SupportedStyles: + - space + - no_space + +Layout/SpaceAroundOperators: + AllowForAlignment: true + +Layout/SpaceBeforeBlockBraces: + EnforcedStyle: space + EnforcedStyleForEmptyBraces: space + SupportedStyles: + - space + - no_space + +Layout/SpaceInsideBlockBraces: + EnforcedStyle: space + SupportedStyles: + - space + - no_space + EnforcedStyleForEmptyBraces: no_space + SpaceBeforeBlockParameters: true + +Layout/SpaceInsideHashLiteralBraces: + EnforcedStyle: space + EnforcedStyleForEmptyBraces: no_space + SupportedStyles: + - space + - no_space + - compact + +Layout/SpaceInsideStringInterpolation: + EnforcedStyle: no_space + SupportedStyles: + - space + - no_space + +Style/SymbolProc: + IgnoredMethods: + - respond_to + - define_method + +Style/TernaryParentheses: + EnforcedStyle: require_no_parentheses + SupportedStyles: + - require_parentheses + - require_no_parentheses + AllowSafeAssignment: true + +Layout/TrailingBlankLines: + EnforcedStyle: final_newline + SupportedStyles: + - final_newline + - final_blank_line + +Style/TrivialAccessors: + ExactNameMatch: true + AllowPredicates: true + AllowDSLWriters: false + IgnoreClassMethods: false + Whitelist: + - to_ary + - to_a + - to_c + - to_enum + - to_h + - to_hash + - to_i + - to_int + - to_io + - to_open + - to_path + - to_proc + - to_r + - to_regexp + - to_str + - to_s + - to_sym + +Naming/VariableName: + EnforcedStyle: snake_case + SupportedStyles: + - snake_case + - camelCase + +Style/WhileUntilModifier: + Enabled: true + +Metrics/BlockNesting: + Max: 3 + +Metrics/LineLength: + Max: 120 + AllowHeredoc: true + AllowURI: true + URISchemes: + - http + - https + IgnoreCopDirectives: false + IgnoredPatterns: + - '\A\s*(remote_)?test(_\w+)?\s.*(do|->)(\s|\Z)' + +Metrics/ParameterLists: + Max: 5 + CountKeywordArgs: false + +Layout/BlockAlignment: + EnforcedStyleAlignWith: either + SupportedStylesAlignWith: + - either + - start_of_block + - start_of_line + +Layout/EndAlignment: + EnforcedStyleAlignWith: variable + SupportedStylesAlignWith: + - keyword + - variable + - start_of_line + +Layout/DefEndAlignment: + EnforcedStyleAlignWith: start_of_line + SupportedStylesAlignWith: + - start_of_line + - def + +Lint/InheritException: + EnforcedStyle: runtime_error + SupportedStyles: + - runtime_error + - standard_error + +Lint/UnusedBlockArgument: + IgnoreEmptyBlocks: true + AllowUnusedKeywordArguments: false + +Lint/UnusedMethodArgument: + AllowUnusedKeywordArguments: false + IgnoreEmptyMethods: true + +Naming/AccessorMethodName: + Enabled: true + +Layout/AlignArray: + Enabled: true + +Style/ArrayJoin: + Enabled: true + +Naming/AsciiIdentifiers: + Enabled: true + +Style/Attr: + Enabled: true + +Style/BeginBlock: + Enabled: true + +Style/BlockComments: + Enabled: true + +Layout/BlockEndNewline: + Enabled: true + +Style/CaseEquality: + Enabled: true + +Style/CharacterLiteral: + Enabled: true + +Naming/ClassAndModuleCamelCase: + Enabled: true + +Style/ClassMethods: + Enabled: true + +Style/ClassVars: + Enabled: true + +Layout/ClosingParenthesisIndentation: + Enabled: true + +Style/ColonMethodCall: + Enabled: true + +Layout/CommentIndentation: + Enabled: true + +Naming/ConstantName: + Enabled: true + +Style/DateTime: + Enabled: true + +Style/DefWithParentheses: + Enabled: true + +Style/EachForSimpleLoop: + Enabled: true + +Style/EachWithObject: + Enabled: true + +Layout/ElseAlignment: + Enabled: true + +Style/EmptyCaseCondition: + Enabled: true + +Layout/EmptyLines: + Enabled: true + +Layout/EmptyLinesAroundAccessModifier: + Enabled: true + +Layout/EmptyLinesAroundMethodBody: + Enabled: true + +Style/EmptyLiteral: + Enabled: true + +Style/EndBlock: + Enabled: true + +Layout/EndOfLine: + Enabled: true + +Style/EvenOdd: + Enabled: true + +Layout/InitialIndentation: + Enabled: true + +Lint/FlipFlop: + Enabled: true + +Style/IfInsideElse: + Enabled: true + +Style/IfUnlessModifierOfIfUnless: + Enabled: true + +Style/IfWithSemicolon: + Enabled: true + +Style/IdenticalConditionalBranches: + Enabled: true + +Style/InfiniteLoop: + Enabled: true + +Layout/LeadingCommentSpace: + Enabled: true + +Style/LineEndConcatenation: + Enabled: true + +Style/MethodCallWithoutArgsParentheses: + Enabled: true + +Style/MethodMissingSuper: + Enabled: true + +Style/MissingRespondToMissing: + Enabled: true + +Layout/MultilineBlockLayout: + Enabled: true + +Style/MultilineIfThen: + Enabled: true + +Style/MultilineMemoization: + Enabled: true + +Style/MultilineTernaryOperator: + Enabled: true + +Style/NegatedIf: + Enabled: true + +Style/NegatedWhile: + Enabled: true + +Style/NestedModifier: + Enabled: true + +Style/NestedParenthesizedCalls: + Enabled: true + +Style/NestedTernaryOperator: + Enabled: true + +Style/NilComparison: + Enabled: true + +Style/Not: + Enabled: true + +Style/OneLineConditional: + Enabled: true + +Naming/BinaryOperatorParameterName: + Enabled: true + +Style/OptionalArguments: + Enabled: true + +Style/ParallelAssignment: + Enabled: true + +Style/PerlBackrefs: + Enabled: true + +Style/Proc: + Enabled: true + +Style/RedundantBegin: + Enabled: true + +Style/RedundantException: + Enabled: true + +Style/RedundantFreeze: + Enabled: true + +Style/RedundantParentheses: + Enabled: true + +Style/RedundantSelf: + Enabled: true + +Style/RedundantSortBy: + Enabled: true + +Layout/RescueEnsureAlignment: + Enabled: true + +Style/RescueModifier: + Enabled: true + +Style/Sample: + Enabled: true + +Style/SelfAssignment: + Enabled: true + +Layout/SpaceAfterColon: + Enabled: true + +Layout/SpaceAfterComma: + Enabled: true + +Layout/SpaceAfterMethodName: + Enabled: true + +Layout/SpaceAfterNot: + Enabled: true + +Layout/SpaceAfterSemicolon: + Enabled: true + +Layout/SpaceBeforeComma: + Enabled: true + +Layout/SpaceBeforeComment: + Enabled: true + +Layout/SpaceBeforeSemicolon: + Enabled: true + +Layout/SpaceAroundKeyword: + Enabled: true + +Layout/SpaceInsideArrayPercentLiteral: + Enabled: true + +Layout/SpaceInsidePercentLiteralDelimiters: + Enabled: true + +Layout/SpaceInsideArrayLiteralBrackets: + Enabled: true + +Layout/SpaceInsideParens: + Enabled: true + +Layout/SpaceInsideRangeLiteral: + Enabled: true + +Style/SymbolLiteral: + Enabled: true + +Layout/Tab: + Enabled: true + +Layout/TrailingWhitespace: + Enabled: true + +Style/UnlessElse: + Enabled: true + +Style/UnneededCapitalW: + Enabled: true + +Style/UnneededInterpolation: + Enabled: true + +Style/UnneededPercentQ: + Enabled: true + +Style/VariableInterpolation: + Enabled: true + +Style/WhenThen: + Enabled: true + +Style/WhileUntilDo: + Enabled: true + +Style/ZeroLengthPredicate: + Enabled: true + +Layout/IndentHeredoc: + EnforcedStyle: squiggly + +Lint/AmbiguousOperator: + Enabled: true + +Lint/AmbiguousRegexpLiteral: + Enabled: true + +Lint/CircularArgumentReference: + Enabled: true + +Layout/ConditionPosition: + Enabled: true + +Lint/Debugger: + Enabled: true + +Lint/DeprecatedClassMethods: + Enabled: true + +Lint/DuplicateMethods: + Enabled: true + +Lint/DuplicatedKey: + Enabled: true + +Lint/EachWithObjectArgument: + Enabled: true + +Lint/ElseLayout: + Enabled: true + +Lint/EmptyEnsure: + Enabled: true + +Lint/EmptyInterpolation: + Enabled: true + +Lint/EndInMethod: + Enabled: true + +Lint/EnsureReturn: + Enabled: true + +Lint/FloatOutOfRange: + Enabled: true + +Lint/FormatParameterMismatch: + Enabled: true + +Lint/HandleExceptions: + Enabled: true + +Lint/ImplicitStringConcatenation: + Description: Checks for adjacent string literals on the same line, which could + better be represented as a single string literal. + +Lint/IneffectiveAccessModifier: + Description: Checks for attempts to use `private` or `protected` to set the visibility + of a class method, which does not work. + +Lint/LiteralAsCondition: + Enabled: true + +Lint/LiteralInInterpolation: + Enabled: true + +Lint/Loop: + Description: Use Kernel#loop with break rather than begin/end/until or begin/end/while + for post-loop tests. + +Lint/NestedMethodDefinition: + Enabled: true + +Lint/NextWithoutAccumulator: + Description: Do not omit the accumulator when calling `next` in a `reduce`/`inject` + block. + +Lint/NonLocalExitFromIterator: + Enabled: true + +Lint/ParenthesesAsGroupedExpression: + Enabled: true + +Lint/PercentStringArray: + Enabled: true + +Lint/PercentSymbolArray: + Enabled: true + +Lint/RandOne: + Description: Checks for `rand(1)` calls. Such calls always return `0` and most + likely a mistake. + +Lint/RequireParentheses: + Enabled: true + +Lint/RescueException: + Enabled: true + +Lint/ShadowedException: + Enabled: true + +Lint/ShadowingOuterLocalVariable: + Enabled: true + +Lint/StringConversionInInterpolation: + Enabled: true + +Lint/UnderscorePrefixedVariableName: + Enabled: true + +Lint/UnifiedInteger: + Enabled: true + +Lint/UnneededCopDisableDirective: + Enabled: true + +Lint/UnneededCopEnableDirective: + Enabled: true + +Lint/UnneededSplatExpansion: + Enabled: true + +Lint/UnreachableCode: + Enabled: true + +Lint/UselessAccessModifier: + ContextCreatingMethods: [] + +Lint/UselessAssignment: + Enabled: true + +Lint/UselessComparison: + Enabled: true + +Lint/UselessElseWithoutRescue: + Enabled: true + +Lint/UselessSetterCall: + Enabled: true + +Lint/Void: + Enabled: true + +Security/Eval: + Enabled: true + +Security/JSONLoad: + Enabled: true + +Security/Open: + Enabled: true + +Lint/BigDecimalNew: + Enabled: true + +Style/Strip: + Enabled: true + +Style/TrailingBodyOnClass: + Enabled: true + +Style/TrailingBodyOnModule: + Enabled: true + +Style/TrailingCommaInArrayLiteral: + EnforcedStyleForMultiline: comma + Enabled: true + +Style/TrailingCommaInHashLiteral: + EnforcedStyleForMultiline: comma + Enabled: true + +Layout/SpaceInsideReferenceBrackets: + EnforcedStyle: no_space + EnforcedStyleForEmptyBrackets: no_space + Enabled: true + +Style/ModuleFunction: + EnforcedStyle: extend_self + +Lint/OrderedMagicComments: + Enabled: true diff --git a/.rubocop.yml b/.rubocop.yml index 6a306a1..9373c6c 100644 --- a/.rubocop.yml +++ b/.rubocop.yml @@ -1,132 +1,5 @@ inherit_from: - - .rubocop_todo.yml - - ./.rubocop_todo.yml + - .rubocop.shopify.yml -AllCops: - Exclude: - - 'performance/shopify/*' - - 'pkg/**' - -Metrics/BlockNesting: - Max: 3 - -Metrics/ModuleLength: - Enabled: false - -Metrics/ClassLength: - Enabled: false - -Lint/AssignmentInCondition: - Enabled: false - -Lint/AmbiguousOperator: - Enabled: false - -Lint/AmbiguousRegexpLiteral: - Enabled: false - -Lint/ParenthesesAsGroupedExpression: - Enabled: false - -Lint/UnusedBlockArgument: - Enabled: false - -Layout/EndAlignment: - EnforcedStyleAlignWith: variable - -Lint/UnusedMethodArgument: - Enabled: false - -Style/SingleLineBlockParams: - Enabled: false - -Style/DoubleNegation: - Enabled: false - -Style/StringLiteralsInInterpolation: - Enabled: false - -Style/AndOr: - Enabled: false - -Style/SignalException: - Enabled: false - -Style/StringLiterals: - Enabled: false - -Style/BracesAroundHashParameters: - Enabled: false - -Style/NumericLiterals: - Enabled: false - -Layout/SpaceInsideArrayLiteralBrackets: - Enabled: false - -Layout/SpaceBeforeBlockBraces: - Enabled: false - -Style/Documentation: - Enabled: false - -Style/ClassAndModuleChildren: - Enabled: false - -Style/TrailingCommaInArrayLiteral: - Enabled: false - -Style/TrailingCommaInHashLiteral: - Enabled: false - -Layout/IndentHash: - EnforcedStyle: consistent - -Style/FormatString: - Enabled: false - -Layout/AlignParameters: - EnforcedStyle: with_fixed_indentation - -Layout/MultilineOperationIndentation: - EnforcedStyle: indented - -Style/IfUnlessModifier: - Enabled: false - -Style/RaiseArgs: - Enabled: false - -Style/PreferredHashMethods: - Enabled: false - -Style/RegexpLiteral: - Enabled: false - -Style/SymbolLiteral: - Enabled: false - -Performance/Count: - Enabled: false - -Naming/ConstantName: - Enabled: false - -Layout/CaseIndentation: - Enabled: false - -Style/ClassVars: - Enabled: false - -Style/PerlBackrefs: - Enabled: false - -Style/TrivialAccessors: - AllowPredicates: true - -Style/WordArray: - Enabled: false - -Naming/MethodName: - Exclude: - - 'example/server/liquid_servlet.rb' +Metrics/LineLength: + Enabled: false \ No newline at end of file diff --git a/.rubocop_todo.yml b/.rubocop_todo.yml deleted file mode 100644 index 4af3202..0000000 --- a/.rubocop_todo.yml +++ /dev/null @@ -1,260 +0,0 @@ -# This configuration was generated by -# `rubocop --auto-gen-config` -# on 2019-04-22 19:11:24 -0400 using RuboCop version 0.53.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: 1 -# Cop supports --auto-correct. -# Configuration parameters: Include, TreatCommentsAsGroupSeparators. -# Include: **/*.gemspec -Gemspec/OrderedDependencies: - Exclude: - - 'liquid.gemspec' - -# Offense count: 5 -# Cop supports --auto-correct. -# Configuration parameters: EnforcedStyle. -# SupportedStyles: auto_detection, squiggly, active_support, powerpack, unindent -Layout/IndentHeredoc: - Exclude: - - 'test/integration/tags/for_tag_test.rb' - - 'test/integration/trim_mode_test.rb' - -# Offense count: 6 -# Cop supports --auto-correct. -# Configuration parameters: EnforcedStyle. -# SupportedStyles: symmetrical, new_line, same_line -Layout/MultilineMethodCallBraceLayout: - Exclude: - - 'test/integration/error_handling_test.rb' - - 'test/unit/strainer_unit_test.rb' - -# Offense count: 2 -# Cop supports --auto-correct. -# Configuration parameters: EnforcedStyle. -# SupportedStyles: runtime_error, standard_error -Lint/InheritException: - Exclude: - - 'lib/liquid/interrupts.rb' - -# Offense count: 1 -# Configuration parameters: CheckForMethodsWithNoSideEffects. -Lint/Void: - Exclude: - - 'lib/liquid/parse_context.rb' - -# Offense count: 53 -Metrics/AbcSize: - Max: 56 - -# Offense count: 12 -Metrics/CyclomaticComplexity: - Max: 13 - -# Offense count: 112 -# Configuration parameters: CountComments. -Metrics/MethodLength: - Max: 38 - -# Offense count: 8 -Metrics/PerceivedComplexity: - Max: 11 - -# Offense count: 52 -# Configuration parameters: Blacklist. -# Blacklist: END, (?-mix:EO[A-Z]{1}) -Naming/HeredocDelimiterNaming: - Exclude: - - 'test/integration/assign_test.rb' - - 'test/integration/capture_test.rb' - - 'test/integration/trim_mode_test.rb' - -# Offense count: 23 -# Configuration parameters: MinNameLength, AllowNamesEndingInNumbers, AllowedNames, ForbiddenNames. -# AllowedNames: io, id -Naming/UncommunicativeMethodParamName: - Exclude: - - 'example/server/example_servlet.rb' - - 'lib/liquid/condition.rb' - - 'lib/liquid/context.rb' - - 'lib/liquid/standardfilters.rb' - - 'lib/liquid/tags/if.rb' - - 'lib/liquid/utils.rb' - - 'lib/liquid/variable.rb' - - 'test/integration/filter_test.rb' - - 'test/integration/standard_filter_test.rb' - - 'test/integration/tags/for_tag_test.rb' - - 'test/integration/template_test.rb' - - 'test/unit/condition_unit_test.rb' - -# Offense count: 12 -# Cop supports --auto-correct. -# Configuration parameters: EnforcedStyle. -# SupportedStyles: prefer_alias, prefer_alias_method -Style/Alias: - Exclude: - - 'lib/liquid/drop.rb' - - 'lib/liquid/i18n.rb' - - 'lib/liquid/profiler/hooks.rb' - - 'lib/liquid/standardfilters.rb' - - 'lib/liquid/tag.rb' - - 'lib/liquid/tags/include.rb' - - 'lib/liquid/variable.rb' - -# Offense count: 22 -Style/CommentedKeyword: - Enabled: false - -# Offense count: 1 -# Cop supports --auto-correct. -# Configuration parameters: EnforcedStyle, SingleLineConditionsOnly, IncludeTernaryExpressions. -# SupportedStyles: assign_to_condition, assign_inside_condition -Style/ConditionalAssignment: - Exclude: - - 'lib/liquid/errors.rb' - -# Offense count: 1 -Style/DateTime: - Exclude: - - 'test/unit/context_unit_test.rb' - -# Offense count: 2 -# Cop supports --auto-correct. -Style/EmptyCaseCondition: - Exclude: - - 'lib/liquid/block_body.rb' - - 'lib/liquid/lexer.rb' - -# Offense count: 5 -# Cop supports --auto-correct. -# Configuration parameters: EnforcedStyle. -# SupportedStyles: compact, expanded -Style/EmptyMethod: - Exclude: - - 'lib/liquid/tag.rb' - - 'lib/liquid/tags/comment.rb' - - 'lib/liquid/tags/include.rb' - - 'test/integration/tags/include_tag_test.rb' - - 'test/unit/context_unit_test.rb' - -# Offense count: 3 -# Cop supports --auto-correct. -Style/Encoding: - Exclude: - - 'lib/liquid/version.rb' - - 'liquid.gemspec' - - 'test/integration/standard_filter_test.rb' - -# Offense count: 2 -# Cop supports --auto-correct. -Style/ExpandPathArguments: - Exclude: - - 'Rakefile' - - 'liquid.gemspec' - -# Offense count: 7 -# Configuration parameters: EnforcedStyle. -# SupportedStyles: annotated, template, unannotated -Style/FormatStringToken: - Exclude: - - 'test/integration/filter_test.rb' - - 'test/integration/hash_ordering_test.rb' - -# Offense count: 14 -# Configuration parameters: MinBodyLength. -Style/GuardClause: - Exclude: - - 'lib/liquid/condition.rb' - - 'lib/liquid/lexer.rb' - - 'lib/liquid/strainer.rb' - - 'lib/liquid/tags/assign.rb' - - 'lib/liquid/tags/capture.rb' - - 'lib/liquid/tags/case.rb' - - 'lib/liquid/tags/for.rb' - - 'lib/liquid/tags/include.rb' - - 'lib/liquid/tags/raw.rb' - - 'lib/liquid/tags/table_row.rb' - - 'lib/liquid/variable.rb' - - 'test/unit/tokenizer_unit_test.rb' - -# Offense count: 1 -# Cop supports --auto-correct. -# Configuration parameters: EnforcedStyle, MinBodyLength. -# SupportedStyles: skip_modifier_ifs, always -Style/Next: - Exclude: - - 'lib/liquid/tags/for.rb' - -# Offense count: 4 -# Cop supports --auto-correct. -# Configuration parameters: AutoCorrect, EnforcedStyle. -# SupportedStyles: predicate, comparison -Style/NumericPredicate: - Exclude: - - 'spec/**/*' - - 'lib/liquid/context.rb' - - 'lib/liquid/forloop_drop.rb' - - 'lib/liquid/standardfilters.rb' - - 'lib/liquid/tablerowloop_drop.rb' - -# Offense count: 14 -# Cop supports --auto-correct. -# Configuration parameters: PreferredDelimiters. -Style/PercentLiteralDelimiters: - Exclude: - - 'lib/liquid/tags/if.rb' - - 'liquid.gemspec' - - 'test/integration/assign_test.rb' - - 'test/integration/standard_filter_test.rb' - -# Offense count: 1 -# Cop supports --auto-correct. -Style/RedundantSelf: - Exclude: - - 'lib/liquid/strainer.rb' - -# Offense count: 9 -# Cop supports --auto-correct. -# Configuration parameters: AllowAsExpressionSeparator. -Style/Semicolon: - Exclude: - - 'test/integration/error_handling_test.rb' - - 'test/integration/template_test.rb' - - 'test/unit/context_unit_test.rb' - -# Offense count: 7 -# Cop supports --auto-correct. -# Configuration parameters: MinSize. -# SupportedStyles: percent, brackets -Style/SymbolArray: - EnforcedStyle: brackets - -# Offense count: 2 -# Cop supports --auto-correct. -# Configuration parameters: EnforcedStyle, AllowSafeAssignment. -# SupportedStyles: require_parentheses, require_no_parentheses, require_parentheses_when_complex -Style/TernaryParentheses: - Exclude: - - 'lib/liquid/context.rb' - - 'lib/liquid/utils.rb' - -# Offense count: 2 -# Cop supports --auto-correct. -Style/UnneededPercentQ: - Exclude: - - 'test/integration/error_handling_test.rb' - -# Offense count: 1 -# Cop supports --auto-correct. -Style/WhileUntilModifier: - Exclude: - - 'lib/liquid/tags/case.rb' - -# Offense count: 648 -# Configuration parameters: AllowHeredoc, AllowURI, URISchemes, IgnoreCopDirectives, IgnoredPatterns. -# URISchemes: http, https -Metrics/LineLength: - Max: 294 diff --git a/.travis.yml b/.travis.yml index 3a01754..593c955 100644 --- a/.travis.yml +++ b/.travis.yml @@ -1,14 +1,13 @@ language: ruby rvm: - - 2.1 - - 2.2 - - 2.3 - 2.4 - 2.5 + - 2.6 + - 2.7 - ruby-head - jruby-head -# - rbx-2 + - truffleruby sudo: false @@ -22,6 +21,10 @@ matrix: - rvm: ruby-head - rvm: jruby-head +before_install: + - gem update --system + - gem install bundler + install: - bundle install diff --git a/Gemfile b/Gemfile index 37ffe1d..4dede32 100644 --- a/Gemfile +++ b/Gemfile @@ -1,3 +1,5 @@ +# frozen_string_literal: true + source 'https://rubygems.org' git_source(:github) do |repo_name| "https://github.com/#{repo_name}.git" @@ -9,15 +11,15 @@ group :benchmark, :test do gem 'benchmark-ips' gem 'memory_profiler' - install_if -> { RUBY_PLATFORM !~ /mingw|mswin|java/ } do + install_if -> { RUBY_PLATFORM !~ /mingw|mswin|java/ && RUBY_ENGINE != 'truffleruby' } do gem 'stackprof' end end group :test do - gem 'rubocop', '~> 0.53.0' + gem 'rubocop', '~> 0.74.0', require: false - platform :mri do - gem 'liquid-c', github: 'Shopify/liquid-c', ref: '9168659de45d6d576fce30c735f857e597fa26f6' + platform :mri, :truffleruby do + gem 'liquid-c', github: 'Shopify/liquid-c', ref: '7ba926791ef8411984d0f3e41c6353fd716041c6' end end diff --git a/History.md b/History.md index 9a82faa..547340b 100644 --- a/History.md +++ b/History.md @@ -274,7 +274,7 @@ Yanked from rubygems, as it contained too many changes that broke compatibility. * Fixed bad error reporting when a filter called a method which doesn't exist. Liquid told you that it couldn't find the filter which was obviously misleading [Tobias Luetke] * Removed count helper from standard lib. use size [Tobias Luetke] * Fixed bug with string filter parameters failing to tolerate commas in strings. [Paul Hammond] -* Improved filter parameters. Filter parameters are now context sensitive; Types are resolved according to the rules of the context. Multiple parameters are now separated by the Liquid::ArgumentSeparator: , by default [Paul Hammond] +* Improved filter parameters. Filter parameters are now context sensitive; Types are resolved according to the rules of the context. Multiple parameters are now separated by the Liquid::ARGUMENT_SEPARATOR: , by default [Paul Hammond] {{ 'Typo' | link_to: 'http://typo.leetsoft.com', 'Typo - a modern weblog engine' }} * Added Liquid::Drop. A base class which you can use for exporting proxy objects to liquid which can acquire more data when used in liquid. [Tobias Luetke] diff --git a/Rakefile b/Rakefile index 9650abb..62d8921 100755 --- a/Rakefile +++ b/Rakefile @@ -1,29 +1,33 @@ +# frozen_string_literal: true + require 'rake' require 'rake/testtask' -$LOAD_PATH.unshift File.expand_path("../lib", __FILE__) -require "liquid/version" +$LOAD_PATH.unshift(File.expand_path('lib', __dir__)) +require 'liquid/version' -task default: [:test, :rubocop] +task(default: %i[test rubocop]) -desc 'run test suite with default parser' +desc('run test suite with default parser') Rake::TestTask.new(:base_test) do |t| t.libs << '.' << 'lib' << 'test' t.test_files = FileList['test/{integration,unit}/**/*_test.rb'] t.verbose = false end -desc 'run test suite with warn error mode' +desc('run test suite with warn error mode') task :warn_test do ENV['LIQUID_PARSER_MODE'] = 'warn' Rake::Task['base_test'].invoke end task :rubocop do - require 'rubocop/rake_task' - RuboCop::RakeTask.new + if RUBY_ENGINE == 'ruby' + require 'rubocop/rake_task' + RuboCop::RakeTask.new + end end -desc 'runs test suite with both strict and lax parsers' +desc('runs test suite with both strict and lax parsers') task :test do ENV['LIQUID_PARSER_MODE'] = 'lax' Rake::Task['base_test'].invoke @@ -32,8 +36,9 @@ task :test do Rake::Task['base_test'].reenable Rake::Task['base_test'].invoke - if RUBY_ENGINE == 'ruby' - ENV['LIQUID-C'] = '1' + if RUBY_ENGINE == 'ruby' || RUBY_ENGINE == 'truffleruby' + + ENV['LIQUID_C'] = '1' ENV['LIQUID_PARSER_MODE'] = 'lax' Rake::Task['base_test'].reenable @@ -45,9 +50,9 @@ task :test do end end -task gem: :build +task(gem: :build) task :build do - system "gem build liquid.gemspec" + system 'gem build liquid.gemspec' end task install: :build do @@ -56,45 +61,45 @@ end task release: :build do system "git tag -a v#{Liquid::VERSION} -m 'Tagging #{Liquid::VERSION}'" - system "git push --tags" + system 'git push --tags' system "gem push liquid-#{Liquid::VERSION}.gem" system "rm liquid-#{Liquid::VERSION}.gem" end namespace :benchmark do - desc "Run the liquid benchmark with lax parsing" + desc 'Run the liquid benchmark with lax parsing' task :run do - ruby "./performance/benchmark.rb lax" + ruby './performance/benchmark.rb lax' end - desc "Run the liquid benchmark with strict parsing" + desc 'Run the liquid benchmark with strict parsing' task :strict do - ruby "./performance/benchmark.rb strict" + ruby './performance/benchmark.rb strict' end end namespace :profile do - desc "Run the liquid profile/performance coverage" + desc 'Run the liquid profile/performance coverage' task :run do - ruby "./performance/profile.rb" + ruby './performance/profile.rb' end - desc "Run the liquid profile/performance coverage with strict parsing" + desc 'Run the liquid profile/performance coverage with strict parsing' task :strict do - ruby "./performance/profile.rb strict" + ruby './performance/profile.rb strict' end end namespace :memory_profile do - desc "Run memory profiler" + desc 'Run memory profiler' task :run do - ruby "./performance/memory_profile.rb" + ruby './performance/memory_profile.rb' end end -desc "Run example" +desc('Run example') task :example do - ruby "-w -d -Ilib example/server/server.rb" + ruby '-w -d -Ilib example/server/server.rb' end task :console do diff --git a/example/server/example_servlet.rb b/example/server/example_servlet.rb index dbc7a4b..d8116a7 100644 --- a/example/server/example_servlet.rb +++ b/example/server/example_servlet.rb @@ -1,6 +1,8 @@ +# frozen_string_literal: true + module ProductsFilter def price(integer) - sprintf("$%.2d USD", integer / 100.0) + format('$%.2d USD', integer / 100.0) end def prettyprint(text) @@ -28,17 +30,17 @@ class Servlet < LiquidServlet 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' }] + [{ 'name' => 'Arbor Draft', 'price' => 39_900, 'description' => 'the *arbor draft* is a excellent product' }, + { 'name' => 'Arbor Element', 'price' => 40_000, 'description' => 'the *arbor element* rocks for freestyling' }, + { 'name' => 'Arbor Diamond', 'price' => 59_900, '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 Catalyst', 'price' => 39_900, 'description' => 'the *arbor catalyst* is an advanced drop-through for freestyle and flatground performance and versatility' }, + { 'name' => 'Arbor Fish', 'price' => 40_000, 'description' => 'the *arbor fish* is a compact pin that features an extended wheelbase and time-honored teardrop shape' }] end def description - "List of Products ~ This is a list of products with price and description." + 'List of Products ~ This is a list of products with price and description.' end end diff --git a/example/server/liquid_servlet.rb b/example/server/liquid_servlet.rb index b2bf515..f9fba61 100644 --- a/example/server/liquid_servlet.rb +++ b/example/server/liquid_servlet.rb @@ -1,23 +1,28 @@ +# frozen_string_literal: true + class LiquidServlet < WEBrick::HTTPServlet::AbstractServlet - def do_GET(req, res) + def get(req, res) handle(:get, req, res) end - def do_POST(req, res) + def post(req, res) handle(:post, req, res) end + alias_method :do_GET, :get + alias_method :do_POST, :post + private - def handle(type, req, res) + def handle(_type, req, res) @request = req @response = res @request.path_info =~ /(\w+)\z/ - @action = $1 || 'index' + @action = Regexp.last_match(1) || 'index' @assigns = send(@action) if respond_to?(@action) - @response['Content-Type'] = "text/html" + @response['Content-Type'] = 'text/html' @response.status = 200 @response.body = Liquid::Template.parse(read_template).render(@assigns, filters: [ProductsFilter]) end diff --git a/example/server/server.rb b/example/server/server.rb index 703b361..6e65c1f 100644 --- a/example/server/server.rb +++ b/example/server/server.rb @@ -1,3 +1,5 @@ +# frozen_string_literal: true + require 'webrick' require 'rexml/document' @@ -8,5 +10,5 @@ require_relative 'example_servlet' # Setup webrick server = WEBrick::HTTPServer.new(Port: ARGV[1] || 3000) server.mount('/', Servlet) -trap("INT"){ server.shutdown } +trap('INT') { server.shutdown } server.start diff --git a/lib/liquid.rb b/lib/liquid.rb index 770d2f9..8d00980 100644 --- a/lib/liquid.rb +++ b/lib/liquid.rb @@ -1,3 +1,5 @@ +# frozen_string_literal: true + # Copyright (c) 2005 Tobias Luetke # # Permission is hereby granted, free of charge, to any person obtaining @@ -20,31 +22,31 @@ # WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE SOFTWARE. module Liquid - FilterSeparator = /\|/ - ArgumentSeparator = ','.freeze - FilterArgumentSeparator = ':'.freeze - VariableAttributeSeparator = '.'.freeze - WhitespaceControl = '-'.freeze - TagStart = /\{\%/ - TagEnd = /\%\}/ - VariableSignature = /\(?[\w\-\.\[\]]\)?/ - VariableSegment = /[\w\-]/ - VariableStart = /\{\{/ - VariableEnd = /\}\}/ - VariableIncompleteEnd = /\}\}?/ - QuotedString = /"[^"]*"|'[^']*'/ - QuotedFragment = /#{QuotedString}|(?:[^\s,\|'"]|#{QuotedString})+/o - TagAttributes = /(\w+)\s*\:\s*(#{QuotedFragment})/o - AnyStartingTag = /#{TagStart}|#{VariableStart}/o - PartialTemplateParser = /#{TagStart}.*?#{TagEnd}|#{VariableStart}.*?#{VariableIncompleteEnd}/om - TemplateParser = /(#{PartialTemplateParser}|#{AnyStartingTag})/om - VariableParser = /\[[^\]]+\]|#{VariableSegment}+\??/o + FILTER_SEPARATOR = /\|/.freeze + ARGUMENT_SEPARATOR = ',' + FILTER_ARGUMENT_SEPARATOR = ':' + VARIABLE_ATTRIBUTE_SEPARATOR = '.' + WHITESPACE_CONTROL = '-' + TAG_START = /\{\%/.freeze + TAG_END = /\%\}/.freeze + VARIABLE_SIGNATURE = /\(?[\w\-\.\[\]]\)?/.freeze + VARIABLE_SEGMENT = /[\w\-]/.freeze + VARIABLE_START = /\{\{/.freeze + VARIABLE_END = /\}\}/.freeze + VARIABLE_INCOMPLETE_END = /\}\}?/.freeze + QUOTED_STRING = /"[^"]*"|'[^']*'/.freeze + QUOTED_FRAGMENT = /#{QUOTED_STRING}|(?:[^\s,\|'"]|#{QUOTED_STRING})+/o.freeze + TAG_ATTRIBUTES = /(\w+)\s*\:\s*(#{QUOTED_FRAGMENT})/o.freeze + ANY_STARTING_TAG = /#{TAG_START}|#{VARIABLE_START}/o.freeze + PARTIAL_TEMPLATE_PARSER = /#{TAG_START}.*?#{TAG_END}|#{VARIABLE_START}.*?#{VARIABLE_INCOMPLETE_END}/om.freeze + TEMPLATE_PARSER = /(#{PARTIAL_TEMPLATE_PARSER}|#{ANY_STARTING_TAG})/om.freeze + VARIABLE_PARSER = /\[[^\]]+\]|#{VARIABLE_SEGMENT}+\??/o.freeze singleton_class.send(:attr_accessor, :cache_classes) self.cache_classes = true end -require "liquid/version" +require 'liquid/version' require 'liquid/parse_tree_visitor' require 'liquid/lexer' require 'liquid/parser' diff --git a/lib/liquid/block.rb b/lib/liquid/block.rb index 549a3a3..196a5d8 100644 --- a/lib/liquid/block.rb +++ b/lib/liquid/block.rb @@ -1,3 +1,5 @@ +# frozen_string_literal: true + module Liquid class Block < Tag MAX_DEPTH = 100 @@ -27,16 +29,16 @@ module Liquid end def unknown_tag(tag, _params, _tokens) - if tag == 'else'.freeze - raise SyntaxError.new(parse_context.locale.t("errors.syntax.unexpected_else".freeze, - block_name: block_name)) - elsif tag.start_with?('end'.freeze) - raise SyntaxError.new(parse_context.locale.t("errors.syntax.invalid_delimiter".freeze, - tag: tag, - block_name: block_name, - block_delimiter: block_delimiter)) + if tag == 'else' + raise SyntaxError, parse_context.locale.t('errors.syntax.unexpected_else', + block_name: block_name) + elsif tag.start_with?('end') + raise SyntaxError, parse_context.locale.t('errors.syntax.invalid_delimiter', + tag: tag, + block_name: block_name, + block_delimiter: block_delimiter) else - raise SyntaxError.new(parse_context.locale.t("errors.syntax.unknown_tag".freeze, tag: tag)) + raise SyntaxError, parse_context.locale.t('errors.syntax.unknown_tag', tag: tag) end end @@ -51,18 +53,15 @@ module Liquid protected def parse_body(body, tokens) - if parse_context.depth >= MAX_DEPTH - raise StackLevelError, "Nesting too deep".freeze - end + raise StackLevelError, 'Nesting too deep' if parse_context.depth >= MAX_DEPTH + parse_context.depth += 1 begin body.parse(tokens, parse_context) do |end_tag_name, end_tag_params| @blank &&= body.blank? return false if end_tag_name == block_delimiter - unless end_tag_name - raise SyntaxError.new(parse_context.locale.t("errors.syntax.tag_never_closed".freeze, block_name: block_name)) - end + raise SyntaxError, parse_context.locale.t('errors.syntax.tag_never_closed', block_name: block_name) unless end_tag_name # this tag is not registered with the system # pass it to the current block for special handling or error reporting diff --git a/lib/liquid/block_body.rb b/lib/liquid/block_body.rb index c2478ce..04429de 100644 --- a/lib/liquid/block_body.rb +++ b/lib/liquid/block_body.rb @@ -1,10 +1,12 @@ +# frozen_string_literal: true + module Liquid class BlockBody - FullToken = /\A#{TagStart}#{WhitespaceControl}?\s*(\w+)\s*(.*?)#{WhitespaceControl}?#{TagEnd}\z/om - ContentOfVariable = /\A#{VariableStart}#{WhitespaceControl}?(.*?)#{WhitespaceControl}?#{VariableEnd}\z/om - WhitespaceOrNothing = /\A\s*\z/ - TAGSTART = "{%".freeze - VARSTART = "{{".freeze + FULL_TOKEN = /\A#{TAG_START}#{WHITESPACE_CONTROL}?\s*(\w+)\s*(.*?)#{WHITESPACE_CONTROL}?#{TAG_END}\z/om.freeze + CONTENT_OF_VARIABLE = /\A#{VARIABLE_START}#{WHITESPACE_CONTROL}?(.*?)#{WHITESPACE_CONTROL}?#{VARIABLE_END}\z/om.freeze + WHITESPACE_OR_NOTHING = /\A\s*\z/.freeze + TAG_START = '{%' + VAR_START = '{{' attr_reader :nodelist @@ -15,36 +17,34 @@ module Liquid def parse(tokenizer, parse_context) parse_context.line_number = tokenizer.line_number - while token = tokenizer.shift + while (token = tokenizer.shift) next if token.empty? + case - when token.start_with?(TAGSTART) + when token.start_with?(TAG_START) whitespace_handler(token, parse_context) - unless token =~ FullToken - raise_missing_tag_terminator(token, parse_context) - end - tag_name = $1 - markup = $2 + raise_missing_tag_terminator(token, parse_context) unless token =~ FULL_TOKEN + tag_name = Regexp.last_match(1) + markup = Regexp.last_match(2) # fetch the tag from registered blocks - unless tag = registered_tags[tag_name] + unless (tag = registered_tags[tag_name]) # end parsing if we reach an unknown tag and let the caller decide # determine how to proceed return yield tag_name, markup end + new_tag = tag.parse(tag_name, markup, tokenizer, parse_context) @blank &&= new_tag.blank? @nodelist << new_tag - when token.start_with?(VARSTART) + when token.start_with?(VAR_START) whitespace_handler(token, parse_context) @nodelist << create_variable(token, parse_context) @blank = false else - if parse_context.trim_whitespace - token.lstrip! - end + token.lstrip! if parse_context.trim_whitespace parse_context.trim_whitespace = false @nodelist << token - @blank &&= !!(token =~ WhitespaceOrNothing) + @blank &&= !!(token =~ WHITESPACE_OR_NOTHING) end parse_context.line_number = tokenizer.line_number end @@ -53,13 +53,11 @@ module Liquid end def whitespace_handler(token, parse_context) - if token[2] == WhitespaceControl + if token[2] == WHITESPACE_CONTROL previous_token = @nodelist.last - if previous_token.is_a? String - previous_token.rstrip! - end + previous_token.rstrip! if previous_token.is_a?(String) end - parse_context.trim_whitespace = (token[-3] == WhitespaceControl) + parse_context.trim_whitespace = (token[-3] == WHITESPACE_CONTROL) end def blank? @@ -67,14 +65,14 @@ module Liquid end def render(context) - render_to_output_buffer(context, '') + render_to_output_buffer(context, ''.dup) end def render_to_output_buffer(context, output) context.resource_limits.render_score += @nodelist.length idx = 0 - while node = @nodelist[idx] + while (node = @nodelist[idx]) previous_output_size = output.bytesize case node @@ -83,7 +81,7 @@ module Liquid when Variable render_node(context, output, node) when Block - render_node(context, node.blank? ? '' : output, node) + render_node(context, node.blank? ? ''.dup : output, node) break if context.interrupt? # might have happened in a for-block when Continue, Break # If we get an Interrupt that means the block must stop processing. An @@ -117,11 +115,12 @@ module Liquid def raise_if_resource_limits_reached(context, length) context.resource_limits.render_length += length return unless context.resource_limits.reached? - raise MemoryError.new("Memory limits exceeded".freeze) + + raise MemoryError, 'Memory limits exceeded' end def create_variable(token, parse_context) - token.scan(ContentOfVariable) do |content| + token.scan(CONTENT_OF_VARIABLE) do |content| markup = content.first return Variable.new(markup, parse_context) end @@ -129,11 +128,11 @@ module Liquid end def raise_missing_tag_terminator(token, parse_context) - raise SyntaxError.new(parse_context.locale.t("errors.syntax.tag_termination".freeze, token: token, tag_end: TagEnd.inspect)) + raise SyntaxError, parse_context.locale.t('errors.syntax.tag_termination', token: token, tag_end: TAG_END.inspect) end def raise_missing_variable_terminator(token, parse_context) - raise SyntaxError.new(parse_context.locale.t("errors.syntax.variable_termination".freeze, token: token, tag_end: VariableEnd.inspect)) + raise SyntaxError, parse_context.locale.t('errors.syntax.variable_termination', token: token, tag_end: VARIABLE_END.inspect) end def registered_tags diff --git a/lib/liquid/condition.rb b/lib/liquid/condition.rb index 3b51682..a4e8c6f 100644 --- a/lib/liquid/condition.rb +++ b/lib/liquid/condition.rb @@ -1,3 +1,5 @@ +# frozen_string_literal: true + module Liquid # Container for liquid nodes which conveniently wraps decision making logic # @@ -7,26 +9,26 @@ module Liquid # 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 => :<, - '>'.freeze => :>, - '>='.freeze => :>=, - '<='.freeze => :<=, - 'contains'.freeze => lambda do |cond, left, right| + @operators = { + '==' => ->(cond, left, right) { cond.send(:equal_variables, left, right) }, + '!=' => ->(cond, left, right) { !cond.send(:equal_variables, left, right) }, + '<>' => ->(cond, left, right) { !cond.send(:equal_variables, left, right) }, + '<' => :<, + '>' => :>, + '>=' => :>=, + '<=' => :<=, + 'contains' => lambda do |_cond, left, right| if left && right && left.respond_to?(:include?) right = right.to_s if left.is_a?(String) left.include?(right) else false end - end + end, } - def self.operators - @@operators + class << self + attr_accessor :operators end attr_reader :attachment, :child_condition @@ -36,7 +38,7 @@ module Liquid @left = left @operator = operator @right = right - @child_relation = nil + @child_relation = nil @child_condition = nil end @@ -78,7 +80,7 @@ module Liquid end def inspect - "#" + "#" end protected @@ -116,7 +118,7 @@ module Liquid left = context.evaluate(left) right = context.evaluate(right) - operation = self.class.operators[op] || raise(Liquid::ArgumentError.new("Unknown operator #{op}")) + operation = self.class.operators[op] || raise(Liquid::ArgumentError, "Unknown operator #{op}") if operation.respond_to?(:call) operation.call(self, left, right) @@ -124,7 +126,7 @@ module Liquid begin left.send(operation, right) rescue ::ArgumentError => e - raise Liquid::ArgumentError.new(e.message) + raise Liquid::ArgumentError, e.message end end end diff --git a/lib/liquid/context.rb b/lib/liquid/context.rb index 2dcc6af..5deca5f 100644 --- a/lib/liquid/context.rb +++ b/lib/liquid/context.rb @@ -1,3 +1,5 @@ +# frozen_string_literal: true + module Liquid # Context keeps the variable stack and resolves variables, as well as keywords # @@ -28,9 +30,7 @@ module Liquid @this_stack_used = false self.exception_renderer = Template.default_exception_renderer - if rethrow_errors - self.exception_renderer = ->(e) { raise } - end + self.exception_renderer = ->(_e) { raise } if rethrow_errors @interrupts = [] @filters = [] @@ -89,7 +89,7 @@ module Liquid # Push new local scope on the stack. use Context#stack instead def push(new_scope = {}) @scopes.unshift(new_scope) - raise StackLevelError, "Nesting too deep".freeze if @scopes.length > Block::MAX_DEPTH + raise StackLevelError, 'Nesting too deep' if @scopes.length > Block::MAX_DEPTH end # Merge a hash of variables in the current local scope @@ -100,6 +100,7 @@ module Liquid # Pop from the stack. use Context#stack instead def pop raise ContextError if @scopes.size == 1 + @scopes.shift end @@ -190,14 +191,12 @@ module Liquid end def lookup_and_evaluate(obj, key, raise_on_not_found: true) - if @strict_variables && raise_on_not_found && obj.respond_to?(:key?) && !obj.key?(key) - raise Liquid::UndefinedVariable, "undefined variable #{key}" - end + raise Liquid::UndefinedVariable, "undefined variable #{key}" if @strict_variables && raise_on_not_found && obj.respond_to?(:key?) && !obj.key?(key) value = obj[key] if value.is_a?(Proc) && obj.respond_to?(:[]=) - obj[key] = (value.arity == 0) ? value.call : value.call(self) + obj[key] = value.arity == 0 ? value.call : value.call(self) else value end @@ -208,8 +207,8 @@ module Liquid def internal_error # raise and catch to set backtrace and cause on exception raise Liquid::InternalError, 'internal' - rescue Liquid::InternalError => exc - exc + rescue Liquid::InternalError => e + e end def squash_instance_assigns_with_environments diff --git a/lib/liquid/document.rb b/lib/liquid/document.rb index d035dd4..aa89ba5 100644 --- a/lib/liquid/document.rb +++ b/lib/liquid/document.rb @@ -1,3 +1,5 @@ +# frozen_string_literal: true + module Liquid class Document < BlockBody def self.parse(tokens, parse_context) @@ -7,7 +9,7 @@ module Liquid end def parse(tokens, parse_context) - super do |end_tag_name, end_tag_params| + super do |end_tag_name, _end_tag_params| unknown_tag(end_tag_name, parse_context) if end_tag_name end rescue SyntaxError => e @@ -17,10 +19,10 @@ module Liquid def unknown_tag(tag, parse_context) case tag - when 'else'.freeze, 'end'.freeze - raise SyntaxError.new(parse_context.locale.t("errors.syntax.unexpected_outer_tag".freeze, tag: tag)) + when 'else', 'end' + raise SyntaxError, parse_context.locale.t('errors.syntax.unexpected_outer_tag', tag: tag) else - raise SyntaxError.new(parse_context.locale.t("errors.syntax.unknown_tag".freeze, tag: tag)) + raise SyntaxError, parse_context.locale.t('errors.syntax.unknown_tag', tag: tag) end end end diff --git a/lib/liquid/drop.rb b/lib/liquid/drop.rb index 6b5aa99..7c3c97e 100644 --- a/lib/liquid/drop.rb +++ b/lib/liquid/drop.rb @@ -1,3 +1,5 @@ +# frozen_string_literal: true + require 'set' module Liquid @@ -25,7 +27,8 @@ module Liquid # Catch all for the method def liquid_method_missing(method) - return nil unless @context && @context.strict_variables + return nil unless @context&.strict_variables + raise Liquid::UndefinedDropMethod, "undefined method #{method}" end @@ -67,7 +70,7 @@ module Liquid if include?(Enumerable) blacklist += Enumerable.public_instance_methods - blacklist -= [:sort, :count, :first, :min, :max, :include?] + blacklist -= %i[sort count first min max include?] end whitelist = [:to_liquid] + (public_instance_methods - blacklist) diff --git a/lib/liquid/errors.rb b/lib/liquid/errors.rb index defa5ea..e61db4b 100644 --- a/lib/liquid/errors.rb +++ b/lib/liquid/errors.rb @@ -1,3 +1,5 @@ +# frozen_string_literal: true + module Liquid class Error < ::StandardError attr_accessor :line_number @@ -5,12 +7,12 @@ module Liquid attr_accessor :markup_context def to_s(with_prefix = true) - str = "" + str = ''.dup str << message_prefix if with_prefix str << super() if markup_context - str << " " + str << ' ' str << markup_context end @@ -20,20 +22,20 @@ module Liquid private def message_prefix - str = "" - if is_a?(SyntaxError) - str << "Liquid syntax error" + str = ''.dup + str << if is_a?(SyntaxError) + 'Liquid syntax error' else - str << "Liquid error" + 'Liquid error' end if line_number - str << " (" - str << template_name << " " if template_name - str << "line " << line_number.to_s << ")" + str << ' (' + str << template_name << ' ' if template_name + str << 'line ' << line_number.to_s << ')' end - str << ": " + str << ': ' str end end diff --git a/lib/liquid/expression.rb b/lib/liquid/expression.rb index 98be6db..4b7fb34 100644 --- a/lib/liquid/expression.rb +++ b/lib/liquid/expression.rb @@ -1,3 +1,5 @@ +# frozen_string_literal: true + module Liquid class Expression class MethodLiteral @@ -14,18 +16,18 @@ module Liquid end LITERALS = { - nil => nil, 'nil'.freeze => nil, 'null'.freeze => nil, ''.freeze => nil, - 'true'.freeze => true, - 'false'.freeze => false, - 'blank'.freeze => MethodLiteral.new(:blank?, '').freeze, - 'empty'.freeze => MethodLiteral.new(:empty?, '').freeze + nil => nil, 'nil' => nil, 'null' => nil, '' => nil, + 'true' => true, + 'false' => false, + 'blank' => MethodLiteral.new(:blank?, '').freeze, + 'empty' => MethodLiteral.new(:empty?, '').freeze }.freeze - SINGLE_QUOTED_STRING = /\A'(.*)'\z/m - DOUBLE_QUOTED_STRING = /\A"(.*)"\z/m - INTEGERS_REGEX = /\A(-?\d+)\z/ - FLOATS_REGEX = /\A(-?\d[\d\.]+)\z/ - RANGES_REGEX = /\A\((\S+)\.\.(\S+)\)\z/ + SINGLE_QUOTED_STRING = /\A'(.*)'\z/m.freeze + DOUBLE_QUOTED_STRING = /\A"(.*)"\z/m.freeze + INTEGERS_REGEX = /\A(-?\d+)\z/.freeze + FLOATS_REGEX = /\A(-?\d[\d\.]+)\z/.freeze + RANGES_REGEX = /\A\((\S+)\.\.(\S+)\)\z/.freeze def self.parse(markup) if LITERALS.key?(markup) @@ -33,13 +35,13 @@ module Liquid else case markup when SINGLE_QUOTED_STRING, DOUBLE_QUOTED_STRING - $1 + Regexp.last_match(1) when INTEGERS_REGEX - $1.to_i + Regexp.last_match(1).to_i when RANGES_REGEX - RangeLookup.parse($1, $2) + RangeLookup.parse(Regexp.last_match(1), Regexp.last_match(2)) when FLOATS_REGEX - $1.to_f + Regexp.last_match(1).to_f else VariableLookup.parse(markup) end diff --git a/lib/liquid/extensions.rb b/lib/liquid/extensions.rb index 0907819..d185498 100644 --- a/lib/liquid/extensions.rb +++ b/lib/liquid/extensions.rb @@ -1,3 +1,5 @@ +# frozen_string_literal: true + require 'time' require 'date' diff --git a/lib/liquid/file_system.rb b/lib/liquid/file_system.rb index 13f1f46..897666d 100644 --- a/lib/liquid/file_system.rb +++ b/lib/liquid/file_system.rb @@ -1,3 +1,5 @@ +# frozen_string_literal: true + module Liquid # A Liquid file system is a way to let your templates retrieve other templates for use with the include tag. # @@ -15,7 +17,7 @@ module Liquid class BlankFileSystem # Called by Liquid to retrieve a template file def read_template_file(_template_path) - raise FileSystemError, "This liquid context does not allow includes." + raise FileSystemError, 'This liquid context does not allow includes.' end end @@ -44,7 +46,7 @@ module Liquid class LocalFileSystem attr_accessor :root - def initialize(root, pattern = "_%s.liquid".freeze) + def initialize(root, pattern = '_%s.liquid') @root = root @pattern = pattern end @@ -57,9 +59,9 @@ module Liquid end def full_path(template_path) - raise FileSystemError, "Illegal template name '#{template_path}'" unless template_path =~ /\A[^.\/][a-zA-Z0-9_\/]+\z/ + raise FileSystemError, "Illegal template name '#{template_path}'" unless template_path =~ %r{\A[^./][a-zA-Z0-9_/]+\z} - full_path = if template_path.include?('/'.freeze) + full_path = if template_path.include?('/') File.join(root, File.dirname(template_path), @pattern % File.basename(template_path)) else File.join(root, @pattern % template_path) diff --git a/lib/liquid/forloop_drop.rb b/lib/liquid/forloop_drop.rb index 81b2d1a..0ffa255 100644 --- a/lib/liquid/forloop_drop.rb +++ b/lib/liquid/forloop_drop.rb @@ -1,3 +1,5 @@ +# frozen_string_literal: true + module Liquid class ForloopDrop < Drop def initialize(name, length, parentloop) diff --git a/lib/liquid/i18n.rb b/lib/liquid/i18n.rb index 2671507..181bd9d 100644 --- a/lib/liquid/i18n.rb +++ b/lib/liquid/i18n.rb @@ -1,8 +1,10 @@ +# frozen_string_literal: true + require 'yaml' module Liquid class I18n - DEFAULT_LOCALE = File.join(File.expand_path(__dir__), "locales", "en.yml") + DEFAULT_LOCALE = File.join(File.expand_path(__dir__), 'locales', 'en.yml') TranslationError = Class.new(StandardError) @@ -26,13 +28,13 @@ module Liquid def interpolate(name, vars) name.gsub(/%\{(\w+)\}/) do # raise TranslationError, "Undefined key #{$1} for interpolation in translation #{name}" unless vars[$1.to_sym] - (vars[$1.to_sym]).to_s + (vars[Regexp.last_match(1).to_sym]).to_s end end def deep_fetch_translation(name) - name.split('.'.freeze).reduce(locale) do |level, cur| - level[cur] or raise TranslationError, "Translation for #{name} does not exist in locale #{path}" + name.split('.').reduce(locale) do |level, cur| + level[cur] || raise(TranslationError, "Translation for #{name} does not exist in locale #{path}") end end end diff --git a/lib/liquid/interrupts.rb b/lib/liquid/interrupts.rb index 41359d7..c17f22f 100644 --- a/lib/liquid/interrupts.rb +++ b/lib/liquid/interrupts.rb @@ -1,16 +1,18 @@ +# frozen_string_literal: true + 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) - @message = message || "interrupt".freeze + @message = message || 'interrupt' end end # Interrupt that is thrown whenever a {% break %} is called. - class BreakInterrupt < Interrupt; end + class BreakInterrupt < RuntimeError; end # Interrupt that is thrown whenever a {% continue %} is called. - class ContinueInterrupt < Interrupt; end + class ContinueInterrupt < RuntimeError; end end diff --git a/lib/liquid/lexer.rb b/lib/liquid/lexer.rb index f290744..bbab34f 100644 --- a/lib/liquid/lexer.rb +++ b/lib/liquid/lexer.rb @@ -1,25 +1,27 @@ -require "strscan" +# frozen_string_literal: true + +require 'strscan' module Liquid class Lexer SPECIALS = { - '|'.freeze => :pipe, - '.'.freeze => :dot, - ':'.freeze => :colon, - ','.freeze => :comma, - '['.freeze => :open_square, - ']'.freeze => :close_square, - '('.freeze => :open_round, - ')'.freeze => :close_round, - '?'.freeze => :question, - '-'.freeze => :dash + '|' => :pipe, + '.' => :dot, + ':' => :colon, + ',' => :comma, + '[' => :open_square, + ']' => :close_square, + '(' => :open_round, + ')' => :close_round, + '?' => :question, + '-' => :dash, }.freeze - IDENTIFIER = /[a-zA-Z_][\w-]*\??/ - SINGLE_STRING_LITERAL = /'[^\']*'/ - DOUBLE_STRING_LITERAL = /"[^\"]*"/ - NUMBER_LITERAL = /-?\d+(\.\d+)?/ - DOTDOT = /\.\./ - COMPARISON_OPERATOR = /==|!=|<>|<=?|>=?|contains(?=\s)/ - WHITESPACE_OR_NOTHING = /\s*/ + IDENTIFIER = /[a-zA-Z_][\w-]*\??/.freeze + SINGLE_STRING_LITERAL = /'[^\']*'/.freeze + DOUBLE_STRING_LITERAL = /"[^\"]*"/.freeze + NUMBER_LITERAL = /-?\d+(\.\d+)?/.freeze + DOTDOT = /\.\./.freeze + COMPARISON_OPERATOR = /==|!=|<>|<=?|>=?|contains(?=\s)/.freeze + WHITESPACE_OR_NOTHING = /\s*/.freeze def initialize(input) @ss = StringScanner.new(input) @@ -31,16 +33,16 @@ module Liquid until @ss.eos? @ss.skip(WHITESPACE_OR_NOTHING) break if @ss.eos? - tok = case - when t = @ss.scan(COMPARISON_OPERATOR) then [:comparison, t] - when t = @ss.scan(SINGLE_STRING_LITERAL) then [:string, t] - when t = @ss.scan(DOUBLE_STRING_LITERAL) then [:string, t] - when t = @ss.scan(NUMBER_LITERAL) then [:number, t] - when t = @ss.scan(IDENTIFIER) then [:id, t] - when t = @ss.scan(DOTDOT) then [:dotdot, t] + + tok = if (t = @ss.scan(COMPARISON_OPERATOR)) then [:comparison, t] + elsif (t = @ss.scan(SINGLE_STRING_LITERAL)) then [:string, t] + elsif (t = @ss.scan(DOUBLE_STRING_LITERAL)) then [:string, t] + elsif (t = @ss.scan(NUMBER_LITERAL)) then [:number, t] + elsif (t = @ss.scan(IDENTIFIER)) then [:id, t] + elsif (t = @ss.scan(DOTDOT)) then [:dotdot, t] else c = @ss.getch - if s = SPECIALS[c] + if (s = SPECIALS[c]) [s, c] else raise SyntaxError, "Unexpected character #{c}" diff --git a/lib/liquid/parse_context.rb b/lib/liquid/parse_context.rb index abcdaeb..4afdbe5 100644 --- a/lib/liquid/parse_context.rb +++ b/lib/liquid/parse_context.rb @@ -1,3 +1,5 @@ +# frozen_string_literal: true + module Liquid class ParseContext attr_accessor :locale, :line_number, :trim_whitespace, :depth @@ -19,7 +21,6 @@ module Liquid @partial = value @options = value ? partial_options : @template_options @error_mode = @options[:error_mode] || Template.error_mode - value end def partial_options @@ -28,7 +29,7 @@ module Liquid if dont_pass == true { locale: locale } elsif dont_pass.is_a?(Array) - @template_options.reject { |k, v| dont_pass.include?(k) } + @template_options.reject { |k, _v| dont_pass.include?(k) } else @template_options end diff --git a/lib/liquid/parse_tree_visitor.rb b/lib/liquid/parse_tree_visitor.rb index 74f5563..d50943f 100644 --- a/lib/liquid/parse_tree_visitor.rb +++ b/lib/liquid/parse_tree_visitor.rb @@ -28,7 +28,7 @@ module Liquid item, new_context = @callbacks[node.class].call(node, context) [ item, - ParseTreeVisitor.for(node, @callbacks).visit(new_context || context) + ParseTreeVisitor.for(node, @callbacks).visit(new_context || context), ] end end diff --git a/lib/liquid/parser.rb b/lib/liquid/parser.rb index 16df6e9..82920ac 100644 --- a/lib/liquid/parser.rb +++ b/lib/liquid/parser.rb @@ -1,3 +1,5 @@ +# frozen_string_literal: true + module Liquid class Parser def initialize(input) @@ -12,9 +14,8 @@ module Liquid def consume(type = nil) token = @tokens[@p] - if type && token[0] != type - raise SyntaxError, "Expected #{type} but found #{@tokens[@p].first}" - end + raise SyntaxError, "Expected #{type} but found #{@tokens[@p].first}" if type && token[0] != type + @p += 1 token[1] end @@ -25,6 +26,7 @@ module Liquid def consume?(type) token = @tokens[@p] return false unless token && token[0] == type + @p += 1 token[1] end @@ -34,6 +36,7 @@ module Liquid token = @tokens[@p] return false unless token && token[0] == :id return false unless token[1] == str + @p += 1 token[1] end @@ -41,17 +44,18 @@ module Liquid def look(type, ahead = 0) tok = @tokens[@p + ahead] return false unless tok + tok[0] == type end - SINGLE_TOKEN_EXPRESSION_TYPES = [:string, :number].freeze + SINGLE_TOKEN_EXPRESSION_TYPES = %i[string number].freeze private_constant :SINGLE_TOKEN_EXPRESSION_TYPES def expression token = @tokens[@p] if token[0] == :id variable_signature - elsif SINGLE_TOKEN_EXPRESSION_TYPES.include? token[0] + elsif SINGLE_TOKEN_EXPRESSION_TYPES.include?(token[0]) consume elsif token.first == :open_round consume @@ -66,11 +70,9 @@ module Liquid end def argument - str = "" + str = ''.dup # might be a keyword argument (identifier: expression) - if look(:id) && look(:colon, 1) - str << consume << consume << ' '.freeze - end + str << consume << consume << ' ' if look(:id) && look(:colon, 1) str << expression str diff --git a/lib/liquid/parser_switching.rb b/lib/liquid/parser_switching.rb index 3aa664a..402b056 100644 --- a/lib/liquid/parser_switching.rb +++ b/lib/liquid/parser_switching.rb @@ -1,3 +1,5 @@ +# frozen_string_literal: true + module Liquid module ParserSwitching def parse_with_selected_parser(markup) diff --git a/lib/liquid/profiler.rb b/lib/liquid/profiler.rb index dc9db60..94fc82b 100644 --- a/lib/liquid/profiler.rb +++ b/lib/liquid/profiler.rb @@ -1,3 +1,5 @@ +# frozen_string_literal: true + require 'liquid/profiler/hooks' module Liquid @@ -97,9 +99,9 @@ module Liquid end def initialize - @partial_stack = [""] + @partial_stack = [''] - @root_timing = Timing.new("", current_partial) + @root_timing = Timing.new('', current_partial) @timing_stack = [@root_timing] @render_start_at = Time.now diff --git a/lib/liquid/profiler/hooks.rb b/lib/liquid/profiler/hooks.rb index cda166b..e708653 100644 --- a/lib/liquid/profiler/hooks.rb +++ b/lib/liquid/profiler/hooks.rb @@ -1,3 +1,5 @@ +# frozen_string_literal: true + module Liquid class BlockBody def render_node_with_profiling(context, output, node) diff --git a/lib/liquid/range_lookup.rb b/lib/liquid/range_lookup.rb index 93bb420..8e4d765 100644 --- a/lib/liquid/range_lookup.rb +++ b/lib/liquid/range_lookup.rb @@ -1,3 +1,5 @@ +# frozen_string_literal: true + module Liquid class RangeLookup def self.parse(start_markup, end_markup) diff --git a/lib/liquid/resource_limits.rb b/lib/liquid/resource_limits.rb index 08b359b..4db8ede 100644 --- a/lib/liquid/resource_limits.rb +++ b/lib/liquid/resource_limits.rb @@ -1,7 +1,9 @@ +# frozen_string_literal: true + module Liquid class ResourceLimits attr_accessor :render_length, :render_score, :assign_score, - :render_length_limit, :render_score_limit, :assign_score_limit + :render_length_limit, :render_score_limit, :assign_score_limit def initialize(limits) @render_length_limit = limits[:render_length_limit] diff --git a/lib/liquid/standardfilters.rb b/lib/liquid/standardfilters.rb index afcf479..af5fbaa 100644 --- a/lib/liquid/standardfilters.rb +++ b/lib/liquid/standardfilters.rb @@ -1,22 +1,24 @@ +# frozen_string_literal: true + require 'cgi' require 'bigdecimal' module Liquid module StandardFilters HTML_ESCAPE = { - '&'.freeze => '&'.freeze, - '>'.freeze => '>'.freeze, - '<'.freeze => '<'.freeze, - '"'.freeze => '"'.freeze, - "'".freeze => '''.freeze + '&' => '&', + '>' => '>', + '<' => '<', + '"' => '"', + "'" => ''', }.freeze - HTML_ESCAPE_ONCE_REGEXP = /["><']|&(?!([a-zA-Z]+|(#\d+));)/ + HTML_ESCAPE_ONCE_REGEXP = /["><']|&(?!([a-zA-Z]+|(#\d+));)/.freeze STRIP_HTML_BLOCKS = Regexp.union( - //m, + %r{}m, //m, - //m + %r{}m ) - STRIP_HTML_TAGS = /<.*?>/m + STRIP_HTML_TAGS = /<.*?>/m.freeze # Return the size of an array or of an string def size(input) @@ -72,8 +74,9 @@ module Liquid end # Truncate a string down to x characters - def truncate(input, length = 50, truncate_string = "...".freeze) + def truncate(input, length = 50, truncate_string = '...') return if input.nil? + input_str = input.to_s length = Utils.to_integer(length) truncate_string_str = truncate_string.to_s @@ -82,13 +85,14 @@ module Liquid input_str.length > length ? input_str[0...l].concat(truncate_string_str) : input_str end - def truncatewords(input, words = 15, truncate_string = "...".freeze) + def truncatewords(input, words = 15, truncate_string = '...') return if input.nil? + wordlist = input.to_s.split words = Utils.to_integer(words) l = words - 1 l = 0 if l < 0 - wordlist.length > l ? wordlist[0..l].join(" ".freeze).concat(truncate_string.to_s) : input + wordlist.length > l ? wordlist[0..l].join(' ').concat(truncate_string.to_s) : input end # Split input string into an array of substrings separated by given pattern. @@ -113,7 +117,7 @@ module Liquid end def strip_html(input) - empty = ''.freeze + empty = '' result = input.to_s.gsub(STRIP_HTML_BLOCKS, empty) result.gsub!(STRIP_HTML_TAGS, empty) result @@ -121,11 +125,11 @@ module Liquid # Remove all newlines from the string def strip_newlines(input) - input.to_s.gsub(/\r?\n/, ''.freeze) + input.to_s.gsub(/\r?\n/, '') end # Join elements of the array with certain character between them - def join(input, glue = ' '.freeze) + def join(input, glue = ' ') InputIterator.new(input).join(glue) end @@ -220,7 +224,7 @@ module Liquid InputIterator.new(input).map do |e| e = e.call if e.is_a?(Proc) - if property == "to_liquid".freeze + if property == 'to_liquid' e elsif e.respond_to?(:[]) r = e[property] @@ -250,23 +254,23 @@ module Liquid end # Replace occurrences of a string with another - def replace(input, string, replacement = ''.freeze) + def replace(input, string, replacement = '') input.to_s.gsub(string.to_s, replacement.to_s) end # Replace the first occurrences of a string with another - def replace_first(input, string, replacement = ''.freeze) + def replace_first(input, string, replacement = '') input.to_s.sub(string.to_s, replacement.to_s) end # remove a substring def remove(input, string) - input.to_s.gsub(string.to_s, ''.freeze) + input.to_s.gsub(string.to_s, '') end # remove the first occurrences of a substring def remove_first(input, string) - input.to_s.sub(string.to_s, ''.freeze) + input.to_s.sub(string.to_s, '') end # add one string to another @@ -275,9 +279,8 @@ module Liquid end def concat(input, array) - unless array.respond_to?(:to_ary) - raise ArgumentError.new("concat filter requires an array argument") - end + raise ArgumentError, 'concat filter requires an array argument' unless array.respond_to?(:to_ary) + InputIterator.new(input).concat(array) end @@ -288,7 +291,7 @@ module Liquid # Add
tags in front of all newlines in input string def newline_to_br(input) - input.to_s.gsub(/\n/, "
\n".freeze) + input.to_s.gsub(/\n/, "
\n") end # Reformat a date using Ruby's core Time#strftime( string ) -> string @@ -325,7 +328,7 @@ module Liquid def date(input, format) return input if format.to_s.empty? - return input unless date = Utils.to_date(input) + return input unless (date = Utils.to_date(input)) date.strftime(format.to_s) end @@ -419,7 +422,7 @@ module Liquid result.is_a?(BigDecimal) ? result.to_f : result end - def default(input, default_value = ''.freeze) + def default(input, default_value = '') if !input || input.respond_to?(:empty?) && input.empty? default_value else @@ -430,7 +433,7 @@ module Liquid private def raise_property_error(property) - raise Liquid::ArgumentError.new("cannot select the property '#{property}'") + raise Liquid::ArgumentError, "cannot select the property '#{property}'" end def apply_operation(input, operand, operation) diff --git a/lib/liquid/strainer.rb b/lib/liquid/strainer.rb index 76d56d2..2c5af40 100644 --- a/lib/liquid/strainer.rb +++ b/lib/liquid/strainer.rb @@ -1,3 +1,5 @@ +# frozen_string_literal: true + require 'set' module Liquid @@ -7,12 +9,12 @@ module Liquid # 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 + @global_strainer = Class.new(Strainer) do @filter_methods = Set.new end - @@strainer_class_cache = Hash.new do |hash, filters| - hash[filters] = Class.new(@@global_strainer) do - @filter_methods = @@global_strainer.filter_methods.dup + @strainer_class_cache = Hash.new do |hash, filters| + hash[filters] = Class.new(@global_strainer) do + @filter_methods = Strainer.global_strainer.filter_methods.dup filters.each { |f| add_filter(f) } end end @@ -22,12 +24,14 @@ module Liquid end class << self + attr_accessor :strainer_class_cache, :global_strainer attr_reader :filter_methods end def self.add_filter(filter) raise ArgumentError, "Expected module but got: #{filter.class}" unless filter.is_a?(Module) - unless self.include?(filter) + + unless include?(filter) invokable_non_public_methods = (filter.private_instance_methods + filter.protected_instance_methods).select { |m| invokable?(m) } if invokable_non_public_methods.any? raise MethodOverrideError, "Filter overrides registered public methods as non public: #{invokable_non_public_methods.join(', ')}" @@ -39,8 +43,8 @@ module Liquid end def self.global_filter(filter) - @@strainer_class_cache.clear - @@global_strainer.add_filter(filter) + @strainer_class_cache.clear + @global_strainer.add_filter(filter) end def self.invokable?(method) @@ -48,13 +52,13 @@ module Liquid end def self.create(context, filters = []) - @@strainer_class_cache[filters].new(context) + @strainer_class_cache[filters].new(context) end def invoke(method, *args) if self.class.invokable?(method) send(method, *args) - elsif @context && @context.strict_filters + elsif @context&.strict_filters raise Liquid::UndefinedFilter, "undefined filter #{method}" else args.first diff --git a/lib/liquid/tablerowloop_drop.rb b/lib/liquid/tablerowloop_drop.rb index cda4a1e..0d00b6f 100644 --- a/lib/liquid/tablerowloop_drop.rb +++ b/lib/liquid/tablerowloop_drop.rb @@ -1,3 +1,5 @@ +# frozen_string_literal: true + module Liquid class TablerowloopDrop < Drop def initialize(length, cols) diff --git a/lib/liquid/tag.rb b/lib/liquid/tag.rb index 5099ccb..0c5c035 100644 --- a/lib/liquid/tag.rb +++ b/lib/liquid/tag.rb @@ -1,3 +1,5 @@ +# frozen_string_literal: true + module Liquid class Tag attr_reader :nodelist, :tag_name, :line_number, :parse_context @@ -21,8 +23,7 @@ module Liquid @line_number = parse_context.line_number end - def parse(_tokens) - end + def parse(_tokens); end def raw "#{@tag_name} #{@markup}" @@ -33,7 +34,7 @@ module Liquid end def render(_context) - ''.freeze + '' end # For backwards compatibility with custom tags. In a future release, the semantics diff --git a/lib/liquid/tags/assign.rb b/lib/liquid/tags/assign.rb index 767d874..364e25a 100644 --- a/lib/liquid/tags/assign.rb +++ b/lib/liquid/tags/assign.rb @@ -1,3 +1,5 @@ +# frozen_string_literal: true + module Liquid # Assign sets a variable in your template. # @@ -8,17 +10,17 @@ module Liquid # {{ foo }} # class Assign < Tag - Syntax = /(#{VariableSignature}+)\s*=\s*(.*)\s*/om + SYNTAX = /(#{VARIABLE_SIGNATURE}+)\s*=\s*(.*)\s*/om.freeze attr_reader :to, :from def initialize(tag_name, markup, options) super - if markup =~ Syntax - @to = $1 - @from = Variable.new($2, options) + if markup =~ SYNTAX + @to = Regexp.last_match(1) + @from = Variable.new(Regexp.last_match(2), options) else - raise SyntaxError.new options[:locale].t("errors.syntax.assign".freeze) + raise SyntaxError, options[:locale].t('errors.syntax.assign') end end @@ -55,5 +57,5 @@ module Liquid end end - Template.register_tag('assign'.freeze, Assign) + Template.register_tag('assign', Assign) end diff --git a/lib/liquid/tags/break.rb b/lib/liquid/tags/break.rb index 6fe0969..80f4627 100644 --- a/lib/liquid/tags/break.rb +++ b/lib/liquid/tags/break.rb @@ -1,3 +1,5 @@ +# frozen_string_literal: true + module Liquid # Break tag to be used to break out of a for loop. # @@ -14,5 +16,5 @@ module Liquid end end - Template.register_tag('break'.freeze, Break) + Template.register_tag('break', Break) end diff --git a/lib/liquid/tags/capture.rb b/lib/liquid/tags/capture.rb index d717b76..d951953 100644 --- a/lib/liquid/tags/capture.rb +++ b/lib/liquid/tags/capture.rb @@ -1,3 +1,5 @@ +# frozen_string_literal: true + module Liquid # Capture stores the result of a block into a variable without rendering it inplace. # @@ -11,14 +13,14 @@ module Liquid # in a sidebar or footer. # class Capture < Block - Syntax = /(#{VariableSignature}+)/o + SYNTAX = /(#{VARIABLE_SIGNATURE}+)/o.freeze def initialize(tag_name, markup, options) super - if markup =~ Syntax - @to = $1 + if markup =~ SYNTAX + @to = Regexp.last_match(1) else - raise SyntaxError.new(options[:locale].t("errors.syntax.capture")) + raise SyntaxError, options[:locale].t('errors.syntax.capture') end end @@ -35,5 +37,5 @@ module Liquid end end - Template.register_tag('capture'.freeze, Capture) + Template.register_tag('capture', Capture) end diff --git a/lib/liquid/tags/case.rb b/lib/liquid/tags/case.rb index 92b2ed0..4060f46 100644 --- a/lib/liquid/tags/case.rb +++ b/lib/liquid/tags/case.rb @@ -1,7 +1,9 @@ +# frozen_string_literal: true + module Liquid class Case < Block - Syntax = /(#{QuotedFragment})/o - WhenSyntax = /(#{QuotedFragment})(?:(?:\s+or\s+|\s*\,\s*)(#{QuotedFragment}.*))?/om + SYNTAX = /(#{QUOTED_FRAGMENT})/o.freeze + WHEN_SYNTAX = /(#{QUOTED_FRAGMENT})(?:(?:\s+or\s+|\s*\,\s*)(#{QUOTED_FRAGMENT}.*))?/om.freeze attr_reader :blocks, :left @@ -9,18 +11,16 @@ module Liquid super @blocks = [] - if markup =~ Syntax - @left = Expression.parse($1) + if markup =~ SYNTAX + @left = Expression.parse(Regexp.last_match(1)) else - raise SyntaxError.new(options[:locale].t("errors.syntax.case".freeze)) + raise SyntaxError, options[:locale].t('errors.syntax.case') end end def parse(tokens) body = BlockBody.new - while parse_body(body, tokens) - body = @blocks.last.attachment - end + body = @blocks.last.attachment while parse_body(body, tokens) end def nodelist @@ -29,9 +29,9 @@ module Liquid def unknown_tag(tag, markup, tokens) case tag - when 'when'.freeze + when 'when' record_when_condition(markup) - when 'else'.freeze + when 'else' record_else_condition(markup) else super @@ -61,22 +61,18 @@ module Liquid body = BlockBody.new while markup - unless markup =~ WhenSyntax - raise SyntaxError.new(options[:locale].t("errors.syntax.case_invalid_when".freeze)) - end + raise SyntaxError, options[:locale].t('errors.syntax.case_invalid_when') unless markup =~ WHEN_SYNTAX - markup = $2 + markup = Regexp.last_match(2) - block = Condition.new(@left, '=='.freeze, Expression.parse($1)) + block = Condition.new(@left, '==', Expression.parse(Regexp.last_match(1))) block.attach(body) @blocks << block end end def record_else_condition(markup) - unless markup.strip.empty? - raise SyntaxError.new(options[:locale].t("errors.syntax.case_invalid_else".freeze)) - end + raise SyntaxError, options[:locale].t('errors.syntax.case_invalid_else') unless markup.strip.empty? block = ElseCondition.new block.attach(BlockBody.new) @@ -90,5 +86,5 @@ module Liquid end end - Template.register_tag('case'.freeze, Case) + Template.register_tag('case', Case) end diff --git a/lib/liquid/tags/comment.rb b/lib/liquid/tags/comment.rb index cad3931..cc555aa 100644 --- a/lib/liquid/tags/comment.rb +++ b/lib/liquid/tags/comment.rb @@ -1,16 +1,17 @@ +# frozen_string_literal: true + module Liquid class Comment < Block def render_to_output_buffer(_context, output) output end - def unknown_tag(_tag, _markup, _tokens) - end + def unknown_tag(_tag, _markup, _tokens); end def blank? true end end - Template.register_tag('comment'.freeze, Comment) + Template.register_tag('comment', Comment) end diff --git a/lib/liquid/tags/continue.rb b/lib/liquid/tags/continue.rb index 9c81ec2..fb1f371 100644 --- a/lib/liquid/tags/continue.rb +++ b/lib/liquid/tags/continue.rb @@ -1,3 +1,5 @@ +# frozen_string_literal: true + module Liquid # Continue tag to be used to break out of a for loop. # @@ -14,5 +16,5 @@ module Liquid end end - Template.register_tag('continue'.freeze, Continue) + Template.register_tag('continue', Continue) end diff --git a/lib/liquid/tags/cycle.rb b/lib/liquid/tags/cycle.rb index e42244d..b3d217c 100644 --- a/lib/liquid/tags/cycle.rb +++ b/lib/liquid/tags/cycle.rb @@ -1,3 +1,5 @@ +# frozen_string_literal: true + module Liquid # Cycle is usually used within a loop to alternate between values, like colors or DOM classes. # @@ -12,22 +14,22 @@ module Liquid #
Item five
# class Cycle < Tag - SimpleSyntax = /\A#{QuotedFragment}+/o - NamedSyntax = /\A(#{QuotedFragment})\s*\:\s*(.*)/om + SIMPLE_SYNTAX = /\A#{QUOTED_FRAGMENT}+/o.freeze + NAMED_SYNTAX = /\A(#{QUOTED_FRAGMENT})\s*\:\s*(.*)/om.freeze attr_reader :variables def initialize(tag_name, markup, options) super case markup - when NamedSyntax - @variables = variables_from_string($2) - @name = Expression.parse($1) - when SimpleSyntax + when NAMED_SYNTAX + @variables = variables_from_string(Regexp.last_match(2)) + @name = Expression.parse(Regexp.last_match(1)) + when SIMPLE_SYNTAX @variables = variables_from_string(markup) @name = @variables.to_s else - raise SyntaxError.new(options[:locale].t("errors.syntax.cycle".freeze)) + raise SyntaxError, options[:locale].t('errors.syntax.cycle') end end @@ -60,8 +62,8 @@ module Liquid def variables_from_string(markup) markup.split(',').collect do |var| - var =~ /\s*(#{QuotedFragment})\s*/o - $1 ? Expression.parse($1) : nil + var =~ /\s*(#{QUOTED_FRAGMENT})\s*/o + Regexp.last_match(1) ? Expression.parse(Regexp.last_match(1)) : nil end.compact end diff --git a/lib/liquid/tags/decrement.rb b/lib/liquid/tags/decrement.rb index 08ddd4d..d761a0c 100644 --- a/lib/liquid/tags/decrement.rb +++ b/lib/liquid/tags/decrement.rb @@ -1,3 +1,5 @@ +# frozen_string_literal: true + 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 @@ -32,5 +34,5 @@ module Liquid end end - Template.register_tag('decrement'.freeze, Decrement) + Template.register_tag('decrement', Decrement) end diff --git a/lib/liquid/tags/for.rb b/lib/liquid/tags/for.rb index 71c2f91..e73f4e0 100644 --- a/lib/liquid/tags/for.rb +++ b/lib/liquid/tags/for.rb @@ -1,3 +1,5 @@ +# frozen_string_literal: true + module Liquid # "For" iterates over an array or collection. # Several useful variables are available to you within the loop. @@ -44,7 +46,7 @@ module Liquid # forloop.parentloop:: Provides access to the parent loop, if present. # class For < Block - Syntax = /\A(#{VariableSegment}+)\s+in\s+(#{QuotedFragment}+)\s*(reversed)?/o + SYNTAX = /\A(#{VARIABLE_SEGMENT}+)\s+in\s+(#{QUOTED_FRAGMENT}+)\s*(reversed)?/o.freeze attr_reader :collection_name, :variable_name, :limit, :from @@ -58,6 +60,7 @@ module Liquid def parse(tokens) return unless parse_body(@for_block, tokens) + parse_body(@else_block, tokens) end @@ -66,7 +69,8 @@ module Liquid end def unknown_tag(tag, markup, tokens) - return super unless tag == 'else'.freeze + return super unless tag == 'else' + @else_block = BlockBody.new end @@ -85,33 +89,35 @@ module Liquid protected def lax_parse(markup) - if markup =~ Syntax - @variable_name = $1 - collection_name = $2 - @reversed = !!$3 + if markup =~ SYNTAX + @variable_name = Regexp.last_match(1) + collection_name = Regexp.last_match(2) + @reversed = !!Regexp.last_match(3) @name = "#{@variable_name}-#{collection_name}" @collection_name = Expression.parse(collection_name) - markup.scan(TagAttributes) do |key, value| + markup.scan(TAG_ATTRIBUTES) do |key, value| set_attribute(key, value) end else - raise SyntaxError.new(options[:locale].t("errors.syntax.for".freeze)) + raise SyntaxError, options[:locale].t('errors.syntax.for') end end def strict_parse(markup) 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) + raise SyntaxError, options[:locale].t('errors.syntax.for_invalid_in') unless p.id?('in') + collection_name = p.expression @name = "#{@variable_name}-#{collection_name}" @collection_name = Expression.parse(collection_name) - @reversed = p.id?('reversed'.freeze) + @reversed = p.id?('reversed') 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)) + unless (attribute = p.id?('limit') || p.id?('offset')) + raise SyntaxError, options[:locale].t('errors.syntax.for_invalid_attribute') end + p.consume set_attribute(attribute, p.expression) end @@ -162,7 +168,7 @@ module Liquid for_stack.push(loop_vars) begin - context['forloop'.freeze] = loop_vars + context['forloop'] = loop_vars segment.each do |item| context[@variable_name] = item @@ -170,11 +176,11 @@ module Liquid loop_vars.send(:increment!) # Handle any interrupts if they exist. - if context.interrupt? - interrupt = context.pop_interrupt - break if interrupt.is_a? BreakInterrupt - next if interrupt.is_a? ContinueInterrupt - end + next unless context.interrupt? + + interrupt = context.pop_interrupt + break if interrupt.is_a?(BreakInterrupt) + next if interrupt.is_a?(ContinueInterrupt) end ensure for_stack.pop @@ -186,13 +192,13 @@ module Liquid def set_attribute(key, expr) case key - when 'offset'.freeze - @from = if expr == 'continue'.freeze + when 'offset' + @from = if expr == 'continue' :continue else Expression.parse(expr) end - when 'limit'.freeze + when 'limit' @limit = Expression.parse(expr) end end @@ -212,5 +218,5 @@ module Liquid end end - Template.register_tag('for'.freeze, For) + Template.register_tag('for', For) end diff --git a/lib/liquid/tags/if.rb b/lib/liquid/tags/if.rb index 25534a9..7f0289d 100644 --- a/lib/liquid/tags/if.rb +++ b/lib/liquid/tags/if.rb @@ -1,3 +1,5 @@ +# frozen_string_literal: true + module Liquid # If is the conditional block # @@ -10,16 +12,16 @@ module Liquid # There are {% if count < 5 %} less {% else %} more {% endif %} items than you need. # class If < Block - Syntax = /(#{QuotedFragment})\s*([=!<>a-z_]+)?\s*(#{QuotedFragment})?/o - ExpressionsAndOperators = /(?:\b(?:\s?and\s?|\s?or\s?)\b|(?:\s*(?!\b(?:\s?and\s?|\s?or\s?)\b)(?:#{QuotedFragment}|\S+)\s*)+)/o - BOOLEAN_OPERATORS = %w(and or).freeze + SYNTAX = /(#{QUOTED_FRAGMENT})\s*([=!<>a-z_]+)?\s*(#{QUOTED_FRAGMENT})?/o.freeze + EXPRESSIONS_AND_OPERATORS = /(?:\b(?:\s?and\s?|\s?or\s?)\b|(?:\s*(?!\b(?:\s?and\s?|\s?or\s?)\b)(?:#{QUOTED_FRAGMENT}|\S+)\s*)+)/o.freeze + BOOLEAN_OPERATORS = %w[and or].freeze attr_reader :blocks def initialize(tag_name, markup, options) super @blocks = [] - push_block('if'.freeze, markup) + push_block('if', markup) end def nodelist @@ -32,7 +34,7 @@ module Liquid end def unknown_tag(tag, markup, tokens) - if ['elsif'.freeze, 'else'.freeze].include?(tag) + if %w[elsif else].include?(tag) push_block(tag, markup) else super @@ -42,9 +44,7 @@ module Liquid def render_to_output_buffer(context, output) context.stack do @blocks.each do |block| - if block.evaluate(context) - return block.attachment.render_to_output_buffer(context, output) - end + return block.attachment.render_to_output_buffer(context, output) if block.evaluate(context) end end @@ -54,7 +54,7 @@ module Liquid private def push_block(tag, markup) - block = if tag == 'else'.freeze + block = if tag == 'else' ElseCondition.new else parse_with_selected_parser(markup) @@ -65,18 +65,19 @@ module Liquid end def lax_parse(markup) - expressions = markup.scan(ExpressionsAndOperators) - raise(SyntaxError.new(options[:locale].t("errors.syntax.if".freeze))) unless expressions.pop =~ Syntax + expressions = markup.scan(EXPRESSIONS_AND_OPERATORS) + raise SyntaxError, options[:locale].t('errors.syntax.if') unless expressions.pop =~ SYNTAX - condition = Condition.new(Expression.parse($1), $2, Expression.parse($3)) + condition = Condition.new(Expression.parse(Regexp.last_match(1)), Regexp.last_match(2), Expression.parse(Regexp.last_match(3))) until expressions.empty? operator = expressions.pop.to_s.strip - raise(SyntaxError.new(options[:locale].t("errors.syntax.if".freeze))) unless expressions.pop.to_s =~ Syntax + raise SyntaxError, options[:locale].t('errors.syntax.if') unless expressions.pop.to_s =~ SYNTAX + + new_condition = Condition.new(Expression.parse(Regexp.last_match(1)), Regexp.last_match(2), Expression.parse(Regexp.last_match(3))) + raise SyntaxError, options[:locale].t('errors.syntax.if') unless BOOLEAN_OPERATORS.include?(operator) - 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 end @@ -94,7 +95,7 @@ module Liquid def parse_binary_comparisons(p) condition = parse_comparison(p) first_condition = condition - while op = (p.id?('and'.freeze) || p.id?('or'.freeze)) + while (op = (p.id?('and') || p.id?('or'))) child_condition = parse_comparison(p) condition.send(op, child_condition) condition = child_condition @@ -104,7 +105,7 @@ module Liquid def parse_comparison(p) a = Expression.parse(p.expression) - if op = p.consume?(:comparison) + if (op = p.consume?(:comparison)) b = Expression.parse(p.expression) Condition.new(a, op, b) else @@ -119,5 +120,5 @@ module Liquid end end - Template.register_tag('if'.freeze, If) + Template.register_tag('if', If) end diff --git a/lib/liquid/tags/ifchanged.rb b/lib/liquid/tags/ifchanged.rb index e3040ce..92a2ac2 100644 --- a/lib/liquid/tags/ifchanged.rb +++ b/lib/liquid/tags/ifchanged.rb @@ -1,8 +1,10 @@ +# frozen_string_literal: true + module Liquid class Ifchanged < Block def render_to_output_buffer(context, output) context.stack do - block_output = '' + block_output = ''.dup super(context, block_output) if block_output != context.registers[:ifchanged] @@ -15,5 +17,5 @@ module Liquid end end - Template.register_tag('ifchanged'.freeze, Ifchanged) + Template.register_tag('ifchanged', Ifchanged) end diff --git a/lib/liquid/tags/include.rb b/lib/liquid/tags/include.rb index 24acf9d..d57ce1b 100644 --- a/lib/liquid/tags/include.rb +++ b/lib/liquid/tags/include.rb @@ -1,3 +1,5 @@ +# frozen_string_literal: true + module Liquid # Include allows templates to relate with other templates # @@ -14,40 +16,39 @@ module Liquid # {% include 'product' for products %} # class Include < Tag - Syntax = /(#{QuotedFragment}+)(\s+(?:with|for)\s+(#{QuotedFragment}+))?/o + SYNTAX = /(#{QUOTED_FRAGMENT}+)(\s+(?:with|for)\s+(#{QUOTED_FRAGMENT}+))?/o.freeze attr_reader :template_name_expr, :variable_name_expr, :attributes def initialize(tag_name, markup, options) super - if markup =~ Syntax + if markup =~ SYNTAX - template_name = $1 - variable_name = $3 + template_name = Regexp.last_match(1) + variable_name = Regexp.last_match(3) @variable_name_expr = variable_name ? Expression.parse(variable_name) : nil @template_name_expr = Expression.parse(template_name) @attributes = {} - markup.scan(TagAttributes) do |key, value| + markup.scan(TAG_ATTRIBUTES) do |key, value| @attributes[key] = Expression.parse(value) end else - raise SyntaxError.new(options[:locale].t("errors.syntax.include".freeze)) + raise SyntaxError, options[:locale].t('errors.syntax.include') end end - def parse(_tokens) - end + def parse(_tokens); end def render_to_output_buffer(context, output) template_name = context.evaluate(@template_name_expr) - raise ArgumentError.new(options[:locale].t("errors.argument.include")) unless template_name + raise ArgumentError, options[:locale].t('errors.argument.include') unless template_name partial = load_cached_partial(template_name, context) - context_variable_name = template_name.split('/'.freeze).last + context_variable_name = template_name.split('/').last variable = if @variable_name_expr context.evaluate(@variable_name_expr) @@ -91,9 +92,10 @@ module Liquid def load_cached_partial(template_name, context) cached_partials = context.registers[:cached_partials] || {} - if cached = cached_partials[template_name] + if (cached = cached_partials[template_name]) return cached end + source = read_template_from_file_system(context) begin parse_context.partial = true @@ -116,11 +118,11 @@ module Liquid def children [ @node.template_name_expr, - @node.variable_name_expr + @node.variable_name_expr, ] + @node.attributes.values end end end - Template.register_tag('include'.freeze, Include) + Template.register_tag('include', Include) end diff --git a/lib/liquid/tags/increment.rb b/lib/liquid/tags/increment.rb index 5af1242..f8b625c 100644 --- a/lib/liquid/tags/increment.rb +++ b/lib/liquid/tags/increment.rb @@ -1,3 +1,5 @@ +# frozen_string_literal: true + module Liquid # increment is used in a place where one needs to insert a counter # into a template, and needs the counter to survive across @@ -28,5 +30,5 @@ module Liquid end end - Template.register_tag('increment'.freeze, Increment) + Template.register_tag('increment', Increment) end diff --git a/lib/liquid/tags/raw.rb b/lib/liquid/tags/raw.rb index 4fa75d9..95f5bb4 100644 --- a/lib/liquid/tags/raw.rb +++ b/lib/liquid/tags/raw.rb @@ -1,7 +1,9 @@ +# frozen_string_literal: true + module Liquid class Raw < Block - Syntax = /\A\s*\z/ - FullTokenPossiblyInvalid = /\A(.*)#{TagStart}\s*(\w+)\s*(.*)?#{TagEnd}\z/om + SYNTAX = /\A\s*\z/.freeze + FULL_TOKEN_POSSIBLY_INVALID = /\A(.*)#{TAG_START}\s*(\w+)\s*(.*)?#{TAG_END}\z/om.freeze def initialize(tag_name, markup, parse_context) super @@ -10,16 +12,16 @@ module Liquid end def parse(tokens) - @body = '' - while token = tokens.shift - if token =~ FullTokenPossiblyInvalid - @body << $1 if $1 != "".freeze - return if block_delimiter == $2 + @body = ''.dup + while (token = tokens.shift) + if token =~ FULL_TOKEN_POSSIBLY_INVALID + @body << Regexp.last_match(1) if Regexp.last_match(1) != '' + return if block_delimiter == Regexp.last_match(2) end @body << token unless token.empty? end - raise SyntaxError.new(parse_context.locale.t("errors.syntax.tag_never_closed".freeze, block_name: block_name)) + raise SyntaxError, parse_context.locale.t('errors.syntax.tag_never_closed', block_name: block_name) end def render_to_output_buffer(_context, output) @@ -38,11 +40,9 @@ module Liquid protected def ensure_valid_markup(tag_name, markup, parse_context) - unless markup =~ Syntax - raise SyntaxError.new(parse_context.locale.t("errors.syntax.tag_unexpected_args".freeze, tag: tag_name)) - end + raise SyntaxError, parse_context.locale.t('errors.syntax.tag_unexpected_args', tag: tag_name) unless markup =~ SYNTAX end end - Template.register_tag('raw'.freeze, Raw) + Template.register_tag('raw', Raw) end diff --git a/lib/liquid/tags/table_row.rb b/lib/liquid/tags/table_row.rb index 9532102..22a17ef 100644 --- a/lib/liquid/tags/table_row.rb +++ b/lib/liquid/tags/table_row.rb @@ -1,39 +1,41 @@ +# frozen_string_literal: true + module Liquid class TableRow < Block - Syntax = /(\w+)\s+in\s+(#{QuotedFragment}+)/o + SYNTAX = /(\w+)\s+in\s+(#{QUOTED_FRAGMENT}+)/o.freeze attr_reader :variable_name, :collection_name, :attributes def initialize(tag_name, markup, options) super - if markup =~ Syntax - @variable_name = $1 - @collection_name = Expression.parse($2) + if markup =~ SYNTAX + @variable_name = Regexp.last_match(1) + @collection_name = Expression.parse(Regexp.last_match(2)) @attributes = {} - markup.scan(TagAttributes) do |key, value| + markup.scan(TAG_ATTRIBUTES) do |key, value| @attributes[key] = Expression.parse(value) end else - raise SyntaxError.new(options[:locale].t("errors.syntax.table_row".freeze)) + raise SyntaxError, options[:locale].t('errors.syntax.table_row') end end def render_to_output_buffer(context, output) - collection = context.evaluate(@collection_name) or return ''.freeze + (collection = context.evaluate(@collection_name)) || (return '') - 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.key?('offset') ? context.evaluate(@attributes['offset']).to_i : 0 + to = @attributes.key?('limit') ? from + context.evaluate(@attributes['limit']).to_i : nil collection = Utils.slice_collection(collection, from, to) length = collection.length - cols = context.evaluate(@attributes['cols'.freeze]).to_i + cols = context.evaluate(@attributes['cols']).to_i output << "\n" context.stack do tablerowloop = Liquid::TablerowloopDrop.new(length, cols) - context['tablerowloop'.freeze] = tablerowloop + context['tablerowloop'] = tablerowloop collection.each do |item| context[@variable_name] = item @@ -42,9 +44,7 @@ module Liquid super output << '' - if tablerowloop.col_last && !tablerowloop.last - output << "\n" - end + output << "\n" if tablerowloop.col_last && !tablerowloop.last tablerowloop.send(:increment!) end @@ -61,5 +61,5 @@ module Liquid end end - Template.register_tag('tablerow'.freeze, TableRow) + Template.register_tag('tablerow', TableRow) end diff --git a/lib/liquid/tags/unless.rb b/lib/liquid/tags/unless.rb index 18856c3..824dd63 100644 --- a/lib/liquid/tags/unless.rb +++ b/lib/liquid/tags/unless.rb @@ -1,3 +1,5 @@ +# frozen_string_literal: true + require_relative 'if' module Liquid @@ -10,15 +12,11 @@ module Liquid context.stack do # First condition is interpreted backwards ( if not ) first_block = @blocks.first - unless first_block.evaluate(context) - return first_block.attachment.render_to_output_buffer(context, output) - end + return first_block.attachment.render_to_output_buffer(context, output) unless first_block.evaluate(context) # After the first condition unless works just like if @blocks[1..-1].each do |block| - if block.evaluate(context) - return block.attachment.render_to_output_buffer(context, output) - end + return block.attachment.render_to_output_buffer(context, output) if block.evaluate(context) end end @@ -26,5 +24,5 @@ module Liquid end end - Template.register_tag('unless'.freeze, Unless) + Template.register_tag('unless', Unless) end diff --git a/lib/liquid/template.rb b/lib/liquid/template.rb index 91e30fb..0c60069 100644 --- a/lib/liquid/template.rb +++ b/lib/liquid/template.rb @@ -1,3 +1,5 @@ +# frozen_string_literal: true + module Liquid # Templates are central to liquid. # Interpretating templates is a two step process. First you compile the @@ -16,7 +18,11 @@ module Liquid attr_accessor :root attr_reader :resource_limits, :warnings - @@file_system = BlankFileSystem.new + @file_system = BlankFileSystem.new + + class << self + attr_accessor :file_system + end class TagRegistry include Enumerable @@ -74,14 +80,6 @@ module Liquid exception end - def file_system - @@file_system - end - - def file_system=(obj) - @@file_system = obj - end - def register_tag(name, klass) tags[name.to_s] = klass end @@ -165,15 +163,13 @@ module Liquid # filters and tags and might be useful to integrate liquid more with its host application # def render(*args) - return ''.freeze if @root.nil? + return '' if @root.nil? context = case args.first when Liquid::Context c = args.shift - if @rethrow_errors - c.exception_renderer = ->(e) { raise } - end + c.exception_renderer = ->(_e) { raise } if @rethrow_errors c when Liquid::Drop @@ -184,7 +180,7 @@ module Liquid when nil Context.new(assigns, instance_assigns, registers, @rethrow_errors, @resource_limits) else - raise ArgumentError, "Expected Hash or Liquid::Context as parameter" + raise ArgumentError, 'Expected Hash or Liquid::Context as parameter' end output = nil @@ -208,7 +204,7 @@ module Liquid # render the nodelist. # for performance reasons we get an array back here. join will make a string out of it. with_profiling(context) do - @root.render_to_output_buffer(context, output || '') + @root.render_to_output_buffer(context, output || ''.dup) end rescue Liquid::MemoryError => e context.handle_error(e) diff --git a/lib/liquid/tokenizer.rb b/lib/liquid/tokenizer.rb index d03657e..59ca290 100644 --- a/lib/liquid/tokenizer.rb +++ b/lib/liquid/tokenizer.rb @@ -1,3 +1,5 @@ +# frozen_string_literal: true + module Liquid class Tokenizer attr_reader :line_number @@ -20,10 +22,10 @@ module Liquid @source = @source.source if @source.respond_to?(:source) return [] if @source.to_s.empty? - tokens = @source.split(TemplateParser) + tokens = @source.split(TEMPLATE_PARSER) # removes the rogue empty element at the beginning of the array - tokens.shift if tokens[0] && tokens[0].empty? + tokens.shift if tokens[0]&.empty? tokens end diff --git a/lib/liquid/utils.rb b/lib/liquid/utils.rb index 516ac0c..4275f2e 100644 --- a/lib/liquid/utils.rb +++ b/lib/liquid/utils.rb @@ -1,3 +1,5 @@ +# frozen_string_literal: true + module Liquid module Utils def self.slice_collection(collection, from, to) @@ -19,13 +21,9 @@ module Liquid return [] unless collection.respond_to?(:each) collection.each do |item| - if to && to <= index - break - end + break if to && to <= index - if from <= index - segments << item - end + segments << item if from <= index index += 1 end @@ -35,11 +33,12 @@ module Liquid def self.to_integer(num) return num if num.is_a?(Integer) + num = num.to_s begin Integer(num) rescue ::ArgumentError - raise Liquid::ArgumentError, "invalid integer" + raise Liquid::ArgumentError, 'invalid integer' end end @@ -50,7 +49,7 @@ module Liquid when Numeric obj when String - (obj.strip =~ /\A-?\d+\.\d+\z/) ? BigDecimal(obj) : obj.to_i + obj.strip =~ /\A-?\d+\.\d+\z/ ? BigDecimal(obj) : obj.to_i else if obj.respond_to?(:to_number) obj.to_number @@ -65,11 +64,12 @@ module Liquid if obj.is_a?(String) return nil if obj.empty? + obj = obj.downcase end case obj - when 'now'.freeze, 'today'.freeze + when 'now', 'today' Time.now when /\A\d+\z/, Integer Time.at(obj.to_i) diff --git a/lib/liquid/variable.rb b/lib/liquid/variable.rb index cbf9986..cdaf7ef 100644 --- a/lib/liquid/variable.rb +++ b/lib/liquid/variable.rb @@ -1,3 +1,5 @@ +# frozen_string_literal: true + module Liquid # Holds variables. Variables are only loaded "just in time" # and are not evaluated as part of the render stage @@ -10,11 +12,11 @@ module Liquid # {{ user | link }} # class Variable - FilterMarkupRegex = /#{FilterSeparator}\s*(.*)/om - FilterParser = /(?:\s+|#{QuotedFragment}|#{ArgumentSeparator})+/o - FilterArgsRegex = /(?:#{FilterArgumentSeparator}|#{ArgumentSeparator})\s*((?:\w+\s*\:\s*)?#{QuotedFragment})/o - JustTagAttributes = /\A#{TagAttributes}\z/o - MarkupWithQuotedFragment = /(#{QuotedFragment})(.*)/om + FILTER_MARKUP_REGEX = /#{FILTER_SEPARATOR}\s*(.*)/om.freeze + FILTER_PARSER = /(?:\s+|#{QUOTED_FRAGMENT}|#{ARGUMENT_SEPARATOR})+/o.freeze + FILTER_ARGS_REGEX = /(?:#{FILTER_ARGUMENT_SEPARATOR}|#{ARGUMENT_SEPARATOR})\s*((?:\w+\s*\:\s*)?#{QUOTED_FRAGMENT})/o.freeze + JUST_TAG_ATTRIBUTES = /\A#{TAG_ATTRIBUTES}\z/o.freeze + MARKUP_WITH_QUOTED_FRAGMENT = /(#{QUOTED_FRAGMENT})(.*)/om.freeze attr_accessor :filters, :name, :line_number attr_reader :parse_context @@ -41,17 +43,18 @@ module Liquid def lax_parse(markup) @filters = [] - return unless markup =~ MarkupWithQuotedFragment + return unless markup =~ MARKUP_WITH_QUOTED_FRAGMENT - name_markup = $1 - filter_markup = $2 + name_markup = Regexp.last_match(1) + filter_markup = Regexp.last_match(2) @name = Expression.parse(name_markup) - if filter_markup =~ FilterMarkupRegex - filters = $1.scan(FilterParser) + if filter_markup =~ FILTER_MARKUP_REGEX + filters = Regexp.last_match(1).scan(FILTER_PARSER) filters.each do |f| next unless f =~ /\w+/ + filtername = Regexp.last_match(0) - filterargs = f.scan(FilterArgsRegex).flatten + filterargs = f.scan(FILTER_ARGS_REGEX).flatten @filters << parse_filter_expressions(filtername, filterargs) end end @@ -108,7 +111,7 @@ module Liquid filter_args = [] keyword_args = nil unparsed_args.each do |a| - if matches = a.match(JustTagAttributes) + if (matches = a.match(JUST_TAG_ATTRIBUTES)) keyword_args ||= {} keyword_args[matches[1]] = Expression.parse(matches[2]) else @@ -121,7 +124,7 @@ module Liquid end def evaluate_filter_expressions(context, filter_args, filter_kwargs) - parsed_args = filter_args.map{ |expr| context.evaluate(expr) } + parsed_args = filter_args.map { |expr| context.evaluate(expr) } if filter_kwargs parsed_kwargs = {} filter_kwargs.each do |key, expr| @@ -136,7 +139,7 @@ module Liquid return unless obj.tainted? return if Template.taint_mode == :lax - @markup =~ QuotedFragment + @markup =~ QUOTED_FRAGMENT name = Regexp.last_match(0) error = TaintedError.new("variable '#{name}' is tainted and was not escaped") diff --git a/lib/liquid/variable_lookup.rb b/lib/liquid/variable_lookup.rb index 62f4877..8978685 100644 --- a/lib/liquid/variable_lookup.rb +++ b/lib/liquid/variable_lookup.rb @@ -1,7 +1,9 @@ +# frozen_string_literal: true + module Liquid class VariableLookup - SQUARE_BRACKETED = /\A\[(.*)\]\z/m - COMMAND_METHODS = ['size'.freeze, 'first'.freeze, 'last'.freeze].freeze + SQUARE_BRACKETED = /\A\[(.*)\]\z/m.freeze + COMMAND_METHODS = %w[size first last].freeze attr_reader :name, :lookups @@ -10,12 +12,10 @@ module Liquid end def initialize(markup) - lookups = markup.scan(VariableParser) + lookups = markup.scan(VARIABLE_PARSER) name = lookups.shift - if name =~ SQUARE_BRACKETED - name = Expression.parse($1) - end + name = Expression.parse(Regexp.last_match(1)) if name =~ SQUARE_BRACKETED @name = name @lookups = lookups @@ -24,7 +24,7 @@ module Liquid @lookups.each_index do |i| lookup = lookups[i] if lookup =~ SQUARE_BRACKETED - lookups[i] = Expression.parse($1) + lookups[i] = Expression.parse(Regexp.last_match(1)) elsif COMMAND_METHODS.include?(lookup) @command_flags |= 1 << i end @@ -41,8 +41,8 @@ module Liquid # 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?(:key?) && object.key?(key)) || - (object.respond_to?(:fetch) && key.is_a?(Integer))) + ((object.respond_to?(:key?) && object.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) @@ -59,6 +59,7 @@ module Liquid # raise an exception if `strict_variables` option is set to true else return nil unless context.strict_variables + raise Liquid::UndefinedVariable, "undefined variable #{key}" end diff --git a/lib/liquid/version.rb b/lib/liquid/version.rb index da01c47..db086d0 100644 --- a/lib/liquid/version.rb +++ b/lib/liquid/version.rb @@ -1,5 +1,5 @@ -# encoding: utf-8 +# frozen_string_literal: true module Liquid - VERSION = "4.0.3".freeze + VERSION = '4.0.3' end diff --git a/liquid.gemspec b/liquid.gemspec index e0e4ddb..35086ca 100644 --- a/liquid.gemspec +++ b/liquid.gemspec @@ -1,31 +1,31 @@ -# encoding: utf-8 +# frozen_string_literal: true -lib = File.expand_path('../lib/', __FILE__) -$LOAD_PATH.unshift lib unless $LOAD_PATH.include?(lib) +lib = File.expand_path('lib', __dir__) +$LOAD_PATH.unshift(lib) unless $LOAD_PATH.include?(lib) -require "liquid/version" +require 'liquid/version' Gem::Specification.new do |s| - s.name = "liquid" + s.name = 'liquid' 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.email = ["tobi@leetsoft.com"] - s.homepage = "http://www.liquidmarkup.org" - s.license = "MIT" + s.summary = 'A secure, non-evaling end user template engine with aesthetic markup.' + s.authors = ['Tobias Lütke'] + 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.required_ruby_version = ">= 2.1.0" - s.required_rubygems_version = ">= 1.3.7" + s.required_ruby_version = '>= 2.4.0' + s.required_rubygems_version = '>= 1.3.7' - s.test_files = Dir.glob("{test}/**/*") - s.files = Dir.glob("{lib}/**/*") + %w(LICENSE README.md) + s.test_files = Dir.glob('{test}/**/*') + s.files = Dir.glob('{lib}/**/*') + %w[LICENSE README.md] - s.extra_rdoc_files = ["History.md", "README.md"] + s.extra_rdoc_files = ['History.md', 'README.md'] - s.require_path = "lib" + s.require_path = 'lib' - s.add_development_dependency 'rake', '~> 11.3' - s.add_development_dependency 'minitest' + s.add_development_dependency('minitest') + s.add_development_dependency('rake', '~> 11.3') end diff --git a/performance/benchmark.rb b/performance/benchmark.rb index 68c568c..7e61a9d 100644 --- a/performance/benchmark.rb +++ b/performance/benchmark.rb @@ -1,3 +1,5 @@ +# frozen_string_literal: true + require 'benchmark/ips' require_relative 'theme_runner' @@ -12,7 +14,7 @@ Benchmark.ips do |x| puts "Running benchmark for #{x.time} seconds (with #{x.warmup} seconds warmup)." puts - x.report("parse:") { profiler.compile } - x.report("render:") { profiler.render } - x.report("parse & render:") { profiler.run } + x.report('parse:') { profiler.compile } + x.report('render:') { profiler.render } + x.report('parse & render:') { profiler.run } end diff --git a/performance/memory_profile.rb b/performance/memory_profile.rb index bfacde8..7ea64d0 100644 --- a/performance/memory_profile.rb +++ b/performance/memory_profile.rb @@ -22,5 +22,5 @@ Liquid::Template.error_mode = ARGV.first.to_sym if ARGV.first profiler = ThemeRunner.new -profile("Parsing") { profiler.compile } -profile("Rendering") { profiler.render } +profile('Parsing') { profiler.compile } +profile('Rendering') { profiler.render } diff --git a/performance/profile.rb b/performance/profile.rb index c6fb193..e555671 100644 --- a/performance/profile.rb +++ b/performance/profile.rb @@ -1,3 +1,5 @@ +# frozen_string_literal: true + require 'stackprof' require_relative 'theme_runner' @@ -5,7 +7,7 @@ Liquid::Template.error_mode = ARGV.first.to_sym if ARGV.first profiler = ThemeRunner.new profiler.run -[:cpu, :object].each do |profile_type| +%i[cpu object].each do |profile_type| puts "Profiling in #{profile_type} mode..." results = StackProf.run(mode: profile_type) do 200.times do @@ -13,12 +15,12 @@ profiler.run end end - if profile_type == :cpu && graph_filename = ENV['GRAPH_FILENAME'] + 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'] + File.write(ENV['FILENAME'] + '.' + profile_type.to_s, Marshal.dump(results)) if ENV['FILENAME'] end diff --git a/performance/shopify/comment_form.rb b/performance/shopify/comment_form.rb index 7b5bd53..8af7f56 100644 --- a/performance/shopify/comment_form.rb +++ b/performance/shopify/comment_form.rb @@ -1,14 +1,16 @@ +# frozen_string_literal: true + class CommentForm < Liquid::Block - Syntax = /(#{Liquid::VariableSignature}+)/ + SYNTAX = /(#{Liquid::VARIABLE_SIGNATURE}+)/.freeze def initialize(tag_name, markup, options) super - if markup =~ Syntax - @variable_name = $1 + if markup =~ SYNTAX + @variable_name = Regexp.last_match(1) @attributes = {} else - raise SyntaxError.new("Syntax Error in 'comment_form' - Valid syntax: comment_form [article]") + raise SyntaxError, "Syntax Error in 'comment_form' - Valid syntax: comment_form [article]" end end @@ -20,8 +22,8 @@ class CommentForm < Liquid::Block 'posted_successfully?' => context.registers[:posted_successfully], 'errors' => context['comment.errors'], 'author' => context['comment.author'], - 'email' => context['comment.email'], - 'body' => context['comment.body'] + 'email' => context['comment.email'], + 'body' => context['comment.body'], } output << wrap_in_form(article, render_all(@nodelist, context, output)) diff --git a/performance/shopify/database.rb b/performance/shopify/database.rb index 2b5bca4..7c0d6fc 100644 --- a/performance/shopify/database.rb +++ b/performance/shopify/database.rb @@ -1,3 +1,5 @@ +# frozen_string_literal: true + require 'yaml' module Database @@ -16,8 +18,11 @@ module Database end # key the tables by handles, as this is how liquid expects it. - db = db.inject({}) do |assigns, (key, values)| - assigns[key] = values.inject({}) { |h, v| h[v['handle']] = v; h; } + db = db.each_with_object({}) do |(key, values), assigns| + assigns[key] = values.each_with_object({}) do |v, h| + h[v['handle']] = v + h + end assigns end @@ -29,9 +34,9 @@ module Database db['article'] = db['blog']['articles'].first db['cart'] = { - 'total_price' => db['line_items'].values.inject(0) { |sum, item| sum += item['line_price'] * item['quantity'] }, - 'item_count' => db['line_items'].values.inject(0) { |sum, item| sum += item['quantity'] }, - 'items' => db['line_items'].values + 'total_price' => db['line_items'].values.inject(0) { |sum, item| sum + item['line_price'] * item['quantity'] }, + 'item_count' => db['line_items'].values.inject(0) { |sum, item| sum + item['quantity'] }, + 'items' => db['line_items'].values, } db @@ -40,6 +45,6 @@ module Database end if __FILE__ == $PROGRAM_NAME - p Database.tables['collections']['frontpage'].keys + p(Database.tables['collections']['frontpage'].keys) # p Database.tables['blog']['articles'] end diff --git a/performance/shopify/json_filter.rb b/performance/shopify/json_filter.rb index 8fbb5b6..5fb7932 100644 --- a/performance/shopify/json_filter.rb +++ b/performance/shopify/json_filter.rb @@ -1,7 +1,9 @@ +# frozen_string_literal: true + 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 diff --git a/performance/shopify/liquid.rb b/performance/shopify/liquid.rb index 7716deb..40444c3 100644 --- a/performance/shopify/liquid.rb +++ b/performance/shopify/liquid.rb @@ -1,4 +1,6 @@ -$:.unshift __dir__ + '/../../lib' +# frozen_string_literal: true + +$LOAD_PATH.unshift(__dir__ + '/../../lib') require_relative '../../lib/liquid' require_relative 'comment_form' @@ -9,11 +11,11 @@ require_relative 'shop_filter' require_relative 'tag_filter' require_relative 'weight_filter' -Liquid::Template.register_tag 'paginate', Paginate -Liquid::Template.register_tag 'form', CommentForm +Liquid::Template.register_tag('paginate', Paginate) +Liquid::Template.register_tag('form', CommentForm) -Liquid::Template.register_filter JsonFilter -Liquid::Template.register_filter MoneyFilter -Liquid::Template.register_filter WeightFilter -Liquid::Template.register_filter ShopFilter -Liquid::Template.register_filter TagFilter +Liquid::Template.register_filter(JsonFilter) +Liquid::Template.register_filter(MoneyFilter) +Liquid::Template.register_filter(WeightFilter) +Liquid::Template.register_filter(ShopFilter) +Liquid::Template.register_filter(TagFilter) diff --git a/performance/shopify/money_filter.rb b/performance/shopify/money_filter.rb index 8dad789..4909530 100644 --- a/performance/shopify/money_filter.rb +++ b/performance/shopify/money_filter.rb @@ -1,12 +1,16 @@ +# frozen_string_literal: true + module MoneyFilter def money_with_currency(money) return '' if money.nil? - sprintf("$ %.2f USD", money / 100.0) + + format('$ %.2f USD', money / 100.0) end def money(money) return '' if money.nil? - sprintf("$ %.2f", money / 100.0) + + format('$ %.2f', money / 100.0) end private diff --git a/performance/shopify/paginate.rb b/performance/shopify/paginate.rb index 0abd11f..8af40bf 100644 --- a/performance/shopify/paginate.rb +++ b/performance/shopify/paginate.rb @@ -1,23 +1,25 @@ +# frozen_string_literal: true + class Paginate < Liquid::Block - Syntax = /(#{Liquid::QuotedFragment})\s*(by\s*(\d+))?/ + SYNTAX = /(#{Liquid::QUOTED_FRAGMENT})\s*(by\s*(\d+))?/.freeze def initialize(tag_name, markup, options) super - if markup =~ Syntax - @collection_name = $1 - @page_size = if $2 - $3.to_i + if markup =~ SYNTAX + @collection_name = Regexp.last_match(1) + @page_size = if Regexp.last_match(2) + Regexp.last_match(3).to_i else 20 end @attributes = { 'window_size' => 3 } - markup.scan(Liquid::TagAttributes) do |key, value| + markup.scan(Liquid::TAG_ATTRIBUTES) do |key, value| @attributes[key] = value end else - raise SyntaxError.new("Syntax Error in tag 'paginate' - Valid syntax: paginate [collection] by number") + raise SyntaxError, "Syntax Error in tag 'paginate' - Valid syntax: paginate [collection] by number" end end @@ -25,25 +27,25 @@ class Paginate < Liquid::Block @context = context context.stack do - current_page = context['current_page'].to_i + current_page = context['current_page'].to_i pagination = { - 'page_size' => @page_size, - 'current_page' => 5, - 'current_offset' => @page_size * 5 + 'page_size' => @page_size, + 'current_page' => 5, + 'current_offset' => @page_size * 5, } context['paginate'] = pagination - collection_size = context[@collection_name].size + collection_size = context[@collection_name].size - raise ArgumentError.new("Cannot paginate array '#{@collection_name}'. Not found.") if collection_size.nil? + raise ArgumentError, "Cannot paginate array '#{@collection_name}'. Not found." if collection_size.nil? 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['previous'] = link('« Previous', current_page - 1) unless current_page <= 1 pagination['next'] = link('Next »', current_page + 1) unless page_count <= current_page + 1 pagination['parts'] = [] @@ -59,6 +61,7 @@ class Paginate < Liquid::Block pagination['parts'] << link(page, page) elsif page <= current_page - @attributes['window_size'] || page >= current_page + @attributes['window_size'] next if hellip_break + pagination['parts'] << no_link('…') hellip_break = true next @@ -85,6 +88,6 @@ class Paginate < Liquid::Block end def current_url - "/collections/frontpage" + '/collections/frontpage' end end diff --git a/performance/shopify/shop_filter.rb b/performance/shopify/shop_filter.rb index 89c9083..1286017 100644 --- a/performance/shopify/shop_filter.rb +++ b/performance/shopify/shop_filter.rb @@ -1,3 +1,5 @@ +# frozen_string_literal: true + module ShopFilter def asset_url(input) "/files/1/[shop_id]/[shop_id]/assets/#{input}" @@ -15,15 +17,15 @@ module ShopFilter %() end - def stylesheet_tag(url, media = "all") + def stylesheet_tag(url, media = 'all') %() end - def link_to(link, url, title = "") + def link_to(link, url, title = '') %(#{link}) end - def img_tag(url, alt = "") + def img_tag(url, alt = '') %(#{alt}) end @@ -52,15 +54,13 @@ 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 + raise ArgumentError, 'filter "size" can only be called on product images' unless url =~ %r{\Aproducts/([\w\-\_]+)\.(\w{2,4})} case style when 'original' return '/files/shops/random_number/' + url when 'grande', 'large', 'medium', 'compact', 'small', 'thumb', 'icon' - "/files/shops/random_number/products/#{$1}_#{style}.#{$2}" + "/files/shops/random_number/products/#{Regexp.last_match(1)}_#{style}.#{Regexp.last_match(2)}" else raise ArgumentError, 'valid parameters for filter "size" are: original, grande, large, medium, compact, small, thumb and icon ' end @@ -70,16 +70,14 @@ module ShopFilter html = [] html << %(#{link_to(paginate['previous']['title'], paginate['previous']['url'])}) if paginate['previous'] - for part in paginate['parts'] - - if part['is_link'] - html << %(#{link_to(part['title'], part['url'])}) + paginate['parts'].each do |part| + html << if part['is_link'] + %(#{link_to(part['title'], part['url'])}) elsif part['title'].to_i == paginate['current_page'].to_i - html << %(#{part['title']}) + %(#{part['title']}) else - html << %(#{part['title']}) + %(#{part['title']}) end - end html << %(#{link_to(paginate['next']['title'], paginate['next']['url'])}) if paginate['next'] diff --git a/performance/shopify/tag_filter.rb b/performance/shopify/tag_filter.rb index ab5aef6..58f066b 100644 --- a/performance/shopify/tag_filter.rb +++ b/performance/shopify/tag_filter.rb @@ -1,3 +1,5 @@ +# frozen_string_literal: true + module TagFilter def link_to_tag(label, tag) "#{label}" @@ -13,11 +15,11 @@ module TagFilter def link_to_add_tag(label, tag) tags = (@context['current_tags'] + [tag]).uniq - "#{label}" + "#{label}" end def link_to_remove_tag(label, tag) tags = (@context['current_tags'] - [tag]).uniq - "#{label}" + "#{label}" end end diff --git a/performance/shopify/weight_filter.rb b/performance/shopify/weight_filter.rb index a0a15fc..257a3bc 100644 --- a/performance/shopify/weight_filter.rb +++ b/performance/shopify/weight_filter.rb @@ -1,6 +1,8 @@ +# frozen_string_literal: true + module WeightFilter def weight(grams) - sprintf("%.2f", grams / 1000) + format('%.2f', grams / 1000) end def weight_with_unit(grams) diff --git a/performance/theme_runner.rb b/performance/theme_runner.rb index 9f6a1fc..5ad01c5 100644 --- a/performance/theme_runner.rb +++ b/performance/theme_runner.rb @@ -1,3 +1,5 @@ +# frozen_string_literal: true + # This profiler run simulates Shopify. # We are looking in the tests directory for liquid files and render them within the designated layout file. # We will also export a substantial database to liquid which the templates can render values of. @@ -31,7 +33,7 @@ class ThemeRunner { liquid: File.read(test), layout: (File.file?(theme_path) ? File.read(theme_path) : nil), - template_name: test + template_name: test, } end.compact diff --git a/test/integration/assign_test.rb b/test/integration/assign_test.rb index 5502289..adf1e68 100644 --- a/test/integration/assign_test.rb +++ b/test/integration/assign_test.rb @@ -1,3 +1,5 @@ +# frozen_string_literal: true + require 'test_helper' class AssignTest < Minitest::Test @@ -10,29 +12,29 @@ class AssignTest < Minitest::Test END_TEMPLATE template = Template.parse(template_source) rendered = template.render! - assert_equal "Print this-thing", rendered.strip + 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") + '{% assign foo not values %}.', + 'values' => 'foo,bar,baz') end def test_assign_uses_error_mode diff --git a/test/integration/blank_test.rb b/test/integration/blank_test.rb index 2b46ad7..1b5fc5d 100644 --- a/test/integration/blank_test.rb +++ b/test/integration/blank_test.rb @@ -1,7 +1,9 @@ +# frozen_string_literal: true + require 'test_helper' class FoobarTag < Liquid::Tag - def render_to_output_buffer(context, output) + def render_to_output_buffer(_context, output) output << ' ' output end @@ -31,77 +33,77 @@ class BlankTest < Minitest::Test def test_new_tags_are_not_blank_by_default with_custom_tag('foobar', FoobarTag) do - assert_template_result(" " * N, wrap_in_for("{% foobar %}")) + assert_template_result(' ' * N, wrap_in_for('{% foobar %}')) end end def test_loops_are_blank - assert_template_result("", wrap_in_for(" ")) + assert_template_result('', wrap_in_for(' ')) end def test_if_else_are_blank - assert_template_result("", "{% if true %} {% elsif false %} {% else %} {% endif %}") + assert_template_result('', '{% if true %} {% elsif false %} {% else %} {% endif %}') end def test_unless_is_blank - assert_template_result("", wrap("{% unless true %} {% endunless %}")) + assert_template_result('', wrap('{% unless true %} {% endunless %}')) 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 - assert_template_result("", wrap(" {% comment %} whatever {% endcomment %} ")) + assert_template_result('', wrap(' {% comment %} whatever {% endcomment %} ')) end def test_captures_are_blank - assert_template_result("", wrap(" {% capture foo %} whatever {% endcapture %} ")) + assert_template_result('', wrap(' {% capture foo %} whatever {% endcapture %} ')) end def test_nested_blocks_are_blank_but_only_if_all_children_are - assert_template_result("", wrap(wrap(" "))) + assert_template_result('', wrap(wrap(' '))) assert_template_result("\n but this is not " * (N + 1), - wrap('{% if true %} {% comment %} this is blank {% endcomment %} {% endif %} + wrap('{% if true %} {% comment %} this is blank {% endcomment %} {% endif %} {% if true %} but this is not {% endif %}')) end def test_assigns_are_blank - assert_template_result("", wrap(' {% assign foo = "bar" %} ')) + assert_template_result('', wrap(' {% assign foo = "bar" %} ')) end def test_whitespace_is_blank - assert_template_result("", wrap(" ")) - assert_template_result("", wrap("\t")) + assert_template_result('', wrap(' ')) + assert_template_result('', wrap("\t")) end def test_whitespace_is_not_blank_if_other_stuff_is_present - body = " x " + body = ' x ' 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('', 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 %} ")) end end diff --git a/test/integration/block_test.rb b/test/integration/block_test.rb index 0824530..94fc2a1 100644 --- a/test/integration/block_test.rb +++ b/test/integration/block_test.rb @@ -1,3 +1,5 @@ +# frozen_string_literal: true + require 'test_helper' class BlockTest < Minitest::Test @@ -5,7 +7,7 @@ class BlockTest < Minitest::Test def test_unexpected_end_tag exc = assert_raises(SyntaxError) do - Template.parse("{% if true %}{% endunless %}") + Template.parse('{% if true %}{% endunless %}') end assert_equal exc.message, "Liquid syntax error: 'endunless' is not a valid delimiter for if tags. use endif" end diff --git a/test/integration/capture_test.rb b/test/integration/capture_test.rb index 8d965b3..0dfd174 100644 --- a/test/integration/capture_test.rb +++ b/test/integration/capture_test.rb @@ -1,10 +1,12 @@ +# frozen_string_literal: true + require 'test_helper' class CaptureTest < Minitest::Test include Liquid def test_captures_block_content_in_variable - assert_template_result("test string", "{% capture 'var' %}test string{% endcapture %}{{var}}", {}) + assert_template_result('test string', "{% capture 'var' %}test string{% endcapture %}{{var}}", {}) end def test_capture_with_hyphen_in_variable_name @@ -14,7 +16,7 @@ class CaptureTest < Minitest::Test END_TEMPLATE template = Template.parse(template_source) rendered = template.render! - assert_equal "Print this-thing", rendered.strip + assert_equal 'Print this-thing', rendered.strip end def test_capture_to_variable_from_outer_scope_if_existing @@ -30,7 +32,7 @@ class CaptureTest < Minitest::Test END_TEMPLATE template = Template.parse(template_source) rendered = template.render! - assert_equal "test-string", rendered.gsub(/\s/, '') + assert_equal 'test-string', rendered.gsub(/\s/, '') end def test_assigning_from_capture @@ -45,6 +47,6 @@ class CaptureTest < Minitest::Test END_TEMPLATE template = Template.parse(template_source) rendered = template.render! - assert_equal "3-3", rendered.gsub(/\s/, '') + assert_equal '3-3', rendered.gsub(/\s/, '') end end # CaptureTest diff --git a/test/integration/context_test.rb b/test/integration/context_test.rb index 2d109bb..cd6d7a8 100644 --- a/test/integration/context_test.rb +++ b/test/integration/context_test.rb @@ -1,3 +1,5 @@ +# frozen_string_literal: true + require 'test_helper' class ContextTest < Minitest::Test diff --git a/test/integration/document_test.rb b/test/integration/document_test.rb index bcc4a21..eefb29e 100644 --- a/test/integration/document_test.rb +++ b/test/integration/document_test.rb @@ -1,3 +1,5 @@ +# frozen_string_literal: true + require 'test_helper' class DocumentTest < Minitest::Test @@ -5,14 +7,14 @@ class DocumentTest < Minitest::Test def test_unexpected_outer_tag exc = assert_raises(SyntaxError) do - Template.parse("{% else %}") + 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 %}") + Template.parse('{% foo %}') end assert_equal exc.message, "Liquid syntax error: Unknown tag 'foo'" end diff --git a/test/integration/drop_test.rb b/test/integration/drop_test.rb index 2de4a5a..0e106c2 100644 --- a/test/integration/drop_test.rb +++ b/test/integration/drop_test.rb @@ -1,3 +1,5 @@ +# frozen_string_literal: true + require 'test_helper' class ContextDrop < Liquid::Drop @@ -21,7 +23,7 @@ end class ProductDrop < Liquid::Drop class TextDrop < Liquid::Drop def array - ['text1', 'text2'] + %w[text1 text2] end def text @@ -31,7 +33,7 @@ class ProductDrop < Liquid::Drop class CatchallDrop < Liquid::Drop def liquid_method_missing(method) - 'catchall_method: ' << method.to_s + 'catchall_method: '.dup << method.to_s end end @@ -48,13 +50,13 @@ class ProductDrop < Liquid::Drop end def user_input - "foo".taint + 'foo'.dup.taint end protected def callmenot - "protected" + 'protected' end end @@ -139,17 +141,17 @@ class DropsTest < Minitest::Test end def test_drop_does_only_respond_to_whitelisted_methods - assert_equal "", Liquid::Template.parse("{{ product.inspect }}").render!('product' => ProductDrop.new) - assert_equal "", Liquid::Template.parse("{{ product.pretty_inspect }}").render!('product' => ProductDrop.new) - assert_equal "", Liquid::Template.parse("{{ product.whatever }}").render!('product' => ProductDrop.new) - assert_equal "", Liquid::Template.parse('{{ product | map: "inspect" }}').render!('product' => ProductDrop.new) - assert_equal "", Liquid::Template.parse('{{ product | map: "pretty_inspect" }}').render!('product' => ProductDrop.new) - assert_equal "", Liquid::Template.parse('{{ product | map: "whatever" }}').render!('product' => ProductDrop.new) + assert_equal '', Liquid::Template.parse('{{ product.inspect }}').render!('product' => ProductDrop.new) + assert_equal '', Liquid::Template.parse('{{ product.pretty_inspect }}').render!('product' => ProductDrop.new) + assert_equal '', Liquid::Template.parse('{{ product.whatever }}').render!('product' => ProductDrop.new) + assert_equal '', Liquid::Template.parse('{{ product | map: "inspect" }}').render!('product' => ProductDrop.new) + assert_equal '', Liquid::Template.parse('{{ product | map: "pretty_inspect" }}').render!('product' => ProductDrop.new) + assert_equal '', Liquid::Template.parse('{{ product | map: "whatever" }}').render!('product' => ProductDrop.new) end def test_drops_respond_to_to_liquid - assert_equal "text1", Liquid::Template.parse("{{ product.to_liquid.texts.text }}").render!('product' => ProductDrop.new) - assert_equal "text1", Liquid::Template.parse('{{ product | map: "to_liquid" | map: "texts" | map: "text" }}').render!('product' => ProductDrop.new) + assert_equal 'text1', Liquid::Template.parse('{{ product.to_liquid.texts.text }}').render!('product' => ProductDrop.new) + assert_equal 'text1', Liquid::Template.parse('{{ product | map: "to_liquid" | map: "texts" | map: "text" }}').render!('product' => ProductDrop.new) end def test_text_drop @@ -173,12 +175,12 @@ class DropsTest < Minitest::Test 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 @@ -188,7 +190,7 @@ class DropsTest < Minitest::Test end def test_object_methods_not_allowed - [:dup, :clone, :singleton_class, :eval, :class_eval, :inspect].each do |method| + %i[dup clone singleton_class eval class_eval inspect].each do |method| output = Liquid::Template.parse(" {{ product.#{method} }} ").render!('product' => ProductDrop.new) assert_equal ' ', output end @@ -201,9 +203,9 @@ class DropsTest < Minitest::Test 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 { |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]) end def test_scope_with_assigns @@ -232,7 +234,7 @@ class DropsTest < Minitest::Test end def test_enumerable_drop_will_invoke_liquid_method_missing_for_clashing_method_names - ["select", "each", "map", "cycle"].each do |method| + %w[select each map cycle].each do |method| assert_equal method.to_s, Liquid::Template.parse("{{collection.#{method}}}").render!('collection' => EnumerableDrop.new) assert_equal method.to_s, Liquid::Template.parse("{{collection[\"#{method}\"]}}").render!('collection' => EnumerableDrop.new) assert_equal method.to_s, Liquid::Template.parse("{{collection.#{method}}}").render!('collection' => RealEnumerableDrop.new) @@ -241,20 +243,20 @@ class DropsTest < Minitest::Test end def test_some_enumerable_methods_still_get_invoked - [ :count, :max ].each do |method| - assert_equal "3", Liquid::Template.parse("{{collection.#{method}}}").render!('collection' => RealEnumerableDrop.new) - assert_equal "3", Liquid::Template.parse("{{collection[\"#{method}\"]}}").render!('collection' => RealEnumerableDrop.new) - assert_equal "3", Liquid::Template.parse("{{collection.#{method}}}").render!('collection' => EnumerableDrop.new) - assert_equal "3", Liquid::Template.parse("{{collection[\"#{method}\"]}}").render!('collection' => EnumerableDrop.new) + %i[count max].each do |method| + assert_equal '3', Liquid::Template.parse("{{collection.#{method}}}").render!('collection' => RealEnumerableDrop.new) + assert_equal '3', Liquid::Template.parse("{{collection[\"#{method}\"]}}").render!('collection' => RealEnumerableDrop.new) + assert_equal '3', Liquid::Template.parse("{{collection.#{method}}}").render!('collection' => EnumerableDrop.new) + assert_equal '3', Liquid::Template.parse("{{collection[\"#{method}\"]}}").render!('collection' => EnumerableDrop.new) end - assert_equal "yes", Liquid::Template.parse("{% if collection contains 3 %}yes{% endif %}").render!('collection' => RealEnumerableDrop.new) + assert_equal 'yes', Liquid::Template.parse('{% if collection contains 3 %}yes{% endif %}').render!('collection' => RealEnumerableDrop.new) - [ :min, :first ].each do |method| - assert_equal "1", Liquid::Template.parse("{{collection.#{method}}}").render!('collection' => RealEnumerableDrop.new) - assert_equal "1", Liquid::Template.parse("{{collection[\"#{method}\"]}}").render!('collection' => RealEnumerableDrop.new) - assert_equal "1", Liquid::Template.parse("{{collection.#{method}}}").render!('collection' => EnumerableDrop.new) - assert_equal "1", Liquid::Template.parse("{{collection[\"#{method}\"]}}").render!('collection' => EnumerableDrop.new) + %i[min first].each do |method| + assert_equal '1', Liquid::Template.parse("{{collection.#{method}}}").render!('collection' => RealEnumerableDrop.new) + assert_equal '1', Liquid::Template.parse("{{collection[\"#{method}\"]}}").render!('collection' => RealEnumerableDrop.new) + assert_equal '1', Liquid::Template.parse("{{collection.#{method}}}").render!('collection' => EnumerableDrop.new) + assert_equal '1', Liquid::Template.parse("{{collection[\"#{method}\"]}}").render!('collection' => EnumerableDrop.new) end end @@ -267,7 +269,7 @@ class DropsTest < Minitest::Test end def test_default_to_s_on_drops - assert_equal 'ProductDrop', Liquid::Template.parse("{{ product }}").render!('product' => ProductDrop.new) + assert_equal 'ProductDrop', Liquid::Template.parse('{{ product }}').render!('product' => ProductDrop.new) assert_equal 'EnumerableDrop', Liquid::Template.parse('{{ collection }}').render!('collection' => EnumerableDrop.new) end end # DropsTest diff --git a/test/integration/error_handling_test.rb b/test/integration/error_handling_test.rb index b2d186c..40380f3 100644 --- a/test/integration/error_handling_test.rb +++ b/test/integration/error_handling_test.rb @@ -1,3 +1,5 @@ +# frozen_string_literal: true + require 'test_helper' class ErrorHandlingTest < Minitest::Test @@ -83,15 +85,14 @@ class ErrorHandlingTest < Minitest::Test def test_with_line_numbers_adds_numbers_to_parser_errors err = assert_raises(SyntaxError) do - Liquid::Template.parse(%q( + Liquid::Template.parse(' foobar {% "cat" | foobar %} bla - ), - line_numbers: true - ) + ', + line_numbers: true) end assert_match(/Liquid syntax error \(line 4\)/, err.message) @@ -99,15 +100,14 @@ class ErrorHandlingTest < Minitest::Test def test_with_line_numbers_adds_numbers_to_parser_errors_with_whitespace_trim err = assert_raises(SyntaxError) do - Liquid::Template.parse(%q( + Liquid::Template.parse(' foobar {%- "cat" | foobar -%} bla - ), - line_numbers: true - ) + ', + line_numbers: true) end assert_match(/Liquid syntax error \(line 4\)/, err.message) @@ -121,12 +121,11 @@ class ErrorHandlingTest < Minitest::Test bla ', - error_mode: :warn, - line_numbers: true - ) + error_mode: :warn, + line_numbers: true) assert_equal ['Liquid syntax error (line 4): Unexpected character = in "1 =! 2"'], - template.warnings.map(&:message) + template.warnings.map(&:message) end def test_parsing_strict_with_line_numbers_adds_numbers_to_lexer_errors @@ -138,9 +137,8 @@ class ErrorHandlingTest < Minitest::Test bla ', - error_mode: :strict, - line_numbers: true - ) + error_mode: :strict, + line_numbers: true) end assert_equal 'Liquid syntax error (line 4): Unexpected character = in "1 =! 2"', err.message @@ -157,8 +155,7 @@ class ErrorHandlingTest < Minitest::Test bla ', - line_numbers: true - ) + line_numbers: true) end assert_equal "Liquid syntax error (line 5): Unknown tag 'foo'", err.message @@ -205,7 +202,7 @@ class ErrorHandlingTest < Minitest::Test def test_default_exception_renderer_with_internal_error template = Liquid::Template.parse('This is a runtime error: {{ errors.runtime_error }}', line_numbers: true) - output = template.render({ 'errors' => ErrorDrop.new }) + output = template.render('errors' => ErrorDrop.new) assert_equal 'This is a runtime error: Liquid error (line 1): internal', output assert_equal [Liquid::InternalError], template.errors.map(&:class) @@ -214,10 +211,13 @@ class ErrorHandlingTest < Minitest::Test def test_setting_default_exception_renderer old_exception_renderer = Liquid::Template.default_exception_renderer exceptions = [] - Liquid::Template.default_exception_renderer = ->(e) { exceptions << e; '' } + Liquid::Template.default_exception_renderer = lambda { |e| + exceptions << e + '' + } template = Liquid::Template.parse('This is a runtime error: {{ errors.argument_error }}') - output = template.render({ 'errors' => ErrorDrop.new }) + output = template.render('errors' => ErrorDrop.new) assert_equal 'This is a runtime error: ', output assert_equal [Liquid::ArgumentError], template.errors.map(&:class) @@ -228,7 +228,10 @@ class ErrorHandlingTest < Minitest::Test def test_exception_renderer_exposing_non_liquid_error template = Liquid::Template.parse('This is a runtime error: {{ errors.runtime_error }}', line_numbers: true) exceptions = [] - handler = ->(e) { exceptions << e; e.cause } + handler = lambda { |e| + exceptions << e + e.cause + } output = template.render({ 'errors' => ErrorDrop.new }, exception_renderer: handler) @@ -239,8 +242,8 @@ class ErrorHandlingTest < Minitest::Test end class TestFileSystem - def read_template_file(template_path) - "{{ errors.argument_error }}" + def read_template_file(_template_path) + '{{ errors.argument_error }}' end end @@ -255,6 +258,6 @@ class ErrorHandlingTest < Minitest::Test Liquid::Template.file_system = old_file_system end assert_equal "Argument error:\nLiquid error (product line 1): argument error", page - assert_equal "product", template.errors.first.template_name + assert_equal 'product', template.errors.first.template_name end end diff --git a/test/integration/filter_test.rb b/test/integration/filter_test.rb index d3c880e..8f54ad0 100644 --- a/test/integration/filter_test.rb +++ b/test/integration/filter_test.rb @@ -1,24 +1,26 @@ +# frozen_string_literal: true + require 'test_helper' module MoneyFilter def money(input) - sprintf(' %d$ ', input) + format(' %d$ ', input) end def money_with_underscore(input) - sprintf(' %d$ ', input) + format(' %d$ ', input) end end module CanadianMoneyFilter def money(input) - sprintf(' %d$ CAD ', input) + format(' %d$ CAD ', input) end end module SubstituteFilter def substitute(input, params = {}) - input.gsub(/%\{(\w+)\}/) { |match| params[$1] } + input.gsub(/%\{(\w+)\}/) { |_match| params[Regexp.last_match(1)] } end end @@ -26,8 +28,8 @@ class FiltersTest < Minitest::Test include Liquid module OverrideObjectMethodFilter - def tap(input) - "tap overridden" + def tap(_input) + 'tap overridden' end end @@ -39,13 +41,13 @@ class FiltersTest < Minitest::Test @context['var'] = 1000 @context.add_filters(MoneyFilter) - assert_equal ' 1000$ ', Template.parse("{{var | money}}").render(@context) + assert_equal ' 1000$ ', Template.parse('{{var | money}}').render(@context) end def test_underscore_in_filter_name @context['var'] = 1000 @context.add_filters(MoneyFilter) - assert_equal ' 1000$ ', Template.parse("{{var | money_with_underscore}}").render(@context) + assert_equal ' 1000$ ', Template.parse('{{var | money_with_underscore}}').render(@context) end def test_second_filter_overwrites_first @@ -53,43 +55,43 @@ class FiltersTest < Minitest::Test @context.add_filters(MoneyFilter) @context.add_filters(CanadianMoneyFilter) - assert_equal ' 1000$ CAD ', Template.parse("{{var | money}}").render(@context) + assert_equal ' 1000$ CAD ', Template.parse('{{var | money}}').render(@context) end def test_size @context['var'] = 'abcd' @context.add_filters(MoneyFilter) - assert_equal '4', Template.parse("{{var | size}}").render(@context) + assert_equal '4', Template.parse('{{var | size}}').render(@context) end def test_join @context['var'] = [1, 2, 3, 4] - assert_equal "1 2 3 4", Template.parse("{{var | join}}").render(@context) + assert_equal '1 2 3 4', Template.parse('{{var | join}}').render(@context) end def test_sort @context['value'] = 3 @context['numbers'] = [2, 1, 4, 3] - @context['words'] = ['expected', 'as', 'alphabetic'] - @context['arrays'] = ['flower', 'are'] - @context['case_sensitive'] = ['sensitive', 'Expected', 'case'] + @context['words'] = %w[expected as alphabetic] + @context['arrays'] = %w[flower are] + @context['case_sensitive'] = %w[sensitive Expected case] - assert_equal '1 2 3 4', Template.parse("{{numbers | sort | join}}").render(@context) - assert_equal 'alphabetic as expected', Template.parse("{{words | sort | join}}").render(@context) - assert_equal '3', Template.parse("{{value | sort}}").render(@context) - assert_equal 'are flower', Template.parse("{{arrays | sort | join}}").render(@context) - assert_equal 'Expected case sensitive', Template.parse("{{case_sensitive | sort | join}}").render(@context) + assert_equal '1 2 3 4', Template.parse('{{numbers | sort | join}}').render(@context) + assert_equal 'alphabetic as expected', Template.parse('{{words | sort | join}}').render(@context) + assert_equal '3', Template.parse('{{value | sort}}').render(@context) + assert_equal 'are flower', Template.parse('{{arrays | sort | join}}').render(@context) + assert_equal 'Expected case sensitive', Template.parse('{{case_sensitive | sort | join}}').render(@context) end def test_sort_natural - @context['words'] = ['case', 'Assert', 'Insensitive'] + @context['words'] = %w[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', Template.parse("{{words | sort_natural | join}}").render(@context) + assert_equal 'Assert case Insensitive', Template.parse('{{words | sort_natural | join}}').render(@context) # Test hashes assert_equal 'A b C', Template.parse("{{hashes | sort_natural: 'a' | map: 'a' | join}}").render(@context) @@ -104,7 +106,7 @@ class FiltersTest < Minitest::Test @context['objects'] = [TestObject.new('A'), TestObject.new(nil), TestObject.new('C')] # Test strings - assert_equal 'a b c', Template.parse("{{words | compact | join}}").render(@context) + assert_equal 'a b c', Template.parse('{{words | compact | join}}').render(@context) # Test hashes assert_equal 'A C', Template.parse("{{hashes | compact: 'a' | map: 'a' | join}}").render(@context) @@ -114,27 +116,27 @@ class FiltersTest < Minitest::Test end def test_strip_html - @context['var'] = "bla blub" + @context['var'] = 'bla blub' - assert_equal "bla blub", Template.parse("{{ var | strip_html }}").render(@context) + assert_equal 'bla blub', Template.parse('{{ var | strip_html }}').render(@context) end def test_strip_html_ignore_comments_with_html - @context['var'] = "bla blub" + @context['var'] = 'bla blub' - assert_equal "bla blub", Template.parse("{{ var | strip_html }}").render(@context) + assert_equal 'bla blub', Template.parse('{{ var | strip_html }}').render(@context) end def test_capitalize - @context['var'] = "blub" + @context['var'] = 'blub' - assert_equal "Blub", Template.parse("{{ var | capitalize }}").render(@context) + assert_equal 'Blub', Template.parse('{{ var | capitalize }}').render(@context) end def test_nonexistent_filter_is_ignored @context['var'] = 1000 - assert_equal '1000', Template.parse("{{ var | xyzzy }}").render(@context) + assert_equal '1000', Template.parse('{{ var | xyzzy }}').render(@context) end def test_filter_with_keyword_arguments @@ -146,10 +148,10 @@ class FiltersTest < Minitest::Test end def test_override_object_method_in_filter - assert_equal "tap overridden", Template.parse("{{var | tap}}").render!({ 'var' => 1000 }, filters: [OverrideObjectMethodFilter]) + 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 }) + assert_equal '1000', Template.parse('{{var | tap}}').render!('var' => 1000) end end @@ -158,15 +160,15 @@ class FiltersInTemplate < Minitest::Test 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]) + 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 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]) + assert_equal ' 1000$ CAD ', Template.parse('{{1000 | money}}').render!(nil, CanadianMoneyFilter) + assert_equal ' 1000$ CAD ', Template.parse('{{1000 | money}}').render!(nil, [CanadianMoneyFilter]) end end # FiltersTest diff --git a/test/integration/hash_ordering_test.rb b/test/integration/hash_ordering_test.rb index dfc1c29..f8f24a2 100644 --- a/test/integration/hash_ordering_test.rb +++ b/test/integration/hash_ordering_test.rb @@ -1,15 +1,17 @@ +# frozen_string_literal: true + require 'test_helper' class HashOrderingTest < Minitest::Test module MoneyFilter def money(input) - sprintf(' %d$ ', input) + format(' %d$ ', input) end end module CanadianMoneyFilter def money(input) - sprintf(' %d$ CAD ', input) + format(' %d$ CAD ', input) end end @@ -17,7 +19,7 @@ class HashOrderingTest < Minitest::Test def test_global_register_order with_global_filter(MoneyFilter, CanadianMoneyFilter) do - assert_equal " 1000$ CAD ", Template.parse("{{1000 | money}}").render(nil, nil) + assert_equal ' 1000$ CAD ', Template.parse('{{1000 | money}}').render(nil, nil) end end end diff --git a/test/integration/output_test.rb b/test/integration/output_test.rb index b4cf9d7..8e33bad 100644 --- a/test/integration/output_test.rb +++ b/test/integration/output_test.rb @@ -1,7 +1,9 @@ +# frozen_string_literal: true + require 'test_helper' module FunnyFilter - def make_funny(input) + def make_funny(_input) 'LOL' end @@ -9,11 +11,11 @@ module FunnyFilter "LOL: #{input}" end - def add_smiley(input, smiley = ":-)") + def add_smiley(input, smiley = ':-)') "#{input} #{smiley}" end - def add_tag(input, tag = "p", id = "foo") + def add_tag(input, tag = 'p', id = 'foo') %(<#{tag} id="#{id}">#{input}) end @@ -32,7 +34,7 @@ class OutputTest < Minitest::Test def setup @assigns = { 'best_cars' => 'bmw', - 'car' => { 'bmw' => 'good', 'gm' => 'bad' } + 'car' => { 'bmw' => 'good', 'gm' => 'bad' }, } end @@ -45,9 +47,9 @@ class OutputTest < Minitest::Test def test_variable_traversing_with_two_brackets text = %({{ site.data.menu[include.menu][include.locale] }}) - assert_equal "it works!", Template.parse(text).render!( - "site" => { "data" => { "menu" => { "foo" => { "bar" => "it works!" } } } }, - "include" => { "menu" => "foo", "locale" => "bar" } + assert_equal 'it works!', Template.parse(text).render!( + 'site' => { 'data' => { 'menu' => { 'foo' => { 'bar' => 'it works!' } } } }, + 'include' => { 'menu' => 'foo', 'locale' => 'bar' } ) end diff --git a/test/integration/parse_tree_visitor_test.rb b/test/integration/parse_tree_visitor_test.rb index 6ad6a2d..e1a53fa 100644 --- a/test/integration/parse_tree_visitor_test.rb +++ b/test/integration/parse_tree_visitor_test.rb @@ -7,217 +7,217 @@ class ParseTreeVisitorTest < Minitest::Test def test_variable assert_equal( - ["test"], + ['test'], visit(%({{ test }})) ) end def test_varible_with_filter assert_equal( - ["test", "infilter"], + %w[test infilter], visit(%({{ test | split: infilter }})) ) end def test_dynamic_variable assert_equal( - ["test", "inlookup"], + %w[test inlookup], visit(%({{ test[inlookup] }})) ) end def test_if_condition assert_equal( - ["test"], + ['test'], visit(%({% if test %}{% endif %})) ) end def test_complex_if_condition assert_equal( - ["test"], + ['test'], visit(%({% if 1 == 1 and 2 == test %}{% endif %})) ) end def test_if_body assert_equal( - ["test"], + ['test'], visit(%({% if 1 == 1 %}{{ test }}{% endif %})) ) end def test_unless_condition assert_equal( - ["test"], + ['test'], visit(%({% unless test %}{% endunless %})) ) end def test_complex_unless_condition assert_equal( - ["test"], + ['test'], visit(%({% unless 1 == 1 and 2 == test %}{% endunless %})) ) end def test_unless_body assert_equal( - ["test"], + ['test'], visit(%({% unless 1 == 1 %}{{ test }}{% endunless %})) ) end def test_elsif_condition assert_equal( - ["test"], + ['test'], visit(%({% if 1 == 1 %}{% elsif test %}{% endif %})) ) end def test_complex_elsif_condition assert_equal( - ["test"], + ['test'], visit(%({% if 1 == 1 %}{% elsif 1 == 1 and 2 == test %}{% endif %})) ) end def test_elsif_body assert_equal( - ["test"], + ['test'], visit(%({% if 1 == 1 %}{% elsif 2 == 2 %}{{ test }}{% endif %})) ) end def test_else_body assert_equal( - ["test"], + ['test'], visit(%({% if 1 == 1 %}{% else %}{{ test }}{% endif %})) ) end def test_case_left assert_equal( - ["test"], + ['test'], visit(%({% case test %}{% endcase %})) ) end def test_case_condition assert_equal( - ["test"], + ['test'], visit(%({% case 1 %}{% when test %}{% endcase %})) ) end def test_case_when_body assert_equal( - ["test"], + ['test'], visit(%({% case 1 %}{% when 2 %}{{ test }}{% endcase %})) ) end def test_case_else_body assert_equal( - ["test"], + ['test'], visit(%({% case 1 %}{% else %}{{ test }}{% endcase %})) ) end def test_for_in assert_equal( - ["test"], + ['test'], visit(%({% for x in test %}{% endfor %})) ) end def test_for_limit assert_equal( - ["test"], + ['test'], visit(%({% for x in (1..5) limit: test %}{% endfor %})) ) end def test_for_offset assert_equal( - ["test"], + ['test'], visit(%({% for x in (1..5) offset: test %}{% endfor %})) ) end def test_for_body assert_equal( - ["test"], + ['test'], visit(%({% for x in (1..5) %}{{ test }}{% endfor %})) ) end def test_tablerow_in assert_equal( - ["test"], + ['test'], visit(%({% tablerow x in test %}{% endtablerow %})) ) end def test_tablerow_limit assert_equal( - ["test"], + ['test'], visit(%({% tablerow x in (1..5) limit: test %}{% endtablerow %})) ) end def test_tablerow_offset assert_equal( - ["test"], + ['test'], visit(%({% tablerow x in (1..5) offset: test %}{% endtablerow %})) ) end def test_tablerow_body assert_equal( - ["test"], + ['test'], visit(%({% tablerow x in (1..5) %}{{ test }}{% endtablerow %})) ) end def test_cycle assert_equal( - ["test"], + ['test'], visit(%({% cycle test %})) ) end def test_assign assert_equal( - ["test"], + ['test'], visit(%({% assign x = test %})) ) end def test_capture assert_equal( - ["test"], + ['test'], visit(%({% capture x %}{{ test }}{% endcapture %})) ) end def test_include assert_equal( - ["test"], + ['test'], visit(%({% include test %})) ) end def test_include_with assert_equal( - ["test"], + ['test'], visit(%({% include "hai" with test %})) ) end def test_include_for assert_equal( - ["test"], + ['test'], visit(%({% include "hai" for test %})) ) end @@ -225,9 +225,9 @@ class ParseTreeVisitorTest < Minitest::Test def test_preserve_tree_structure assert_equal( [[nil, [ - [nil, [[nil, [["other", []]]]]], - ["test", []], - ["xs", []] + [nil, [[nil, [['other', []]]]]], + ['test', []], + ['xs', []], ]]], traversal(%({% for x in xs offset: test %}{{ other }}{% endfor %})).visit ) diff --git a/test/integration/parsing_quirks_test.rb b/test/integration/parsing_quirks_test.rb index 29cb6d6..c790e7b 100644 --- a/test/integration/parsing_quirks_test.rb +++ b/test/integration/parsing_quirks_test.rb @@ -1,41 +1,43 @@ +# frozen_string_literal: true + require 'test_helper' class ParsingQuirksTest < Minitest::Test include Liquid def test_parsing_css - text = " div { font-weight: bold; } " + text = ' div { font-weight: bold; } ' assert_equal text, Template.parse(text).render! end def test_raise_on_single_close_bracet assert_raises(SyntaxError) do - Template.parse("text {{method} oh nos!") + Template.parse('text {{method} oh nos!') end end def test_raise_on_label_and_no_close_bracets assert_raises(SyntaxError) do - Template.parse("TEST {{ ") + Template.parse('TEST {{ ') end end def test_raise_on_label_and_no_close_bracets_percent assert_raises(SyntaxError) do - Template.parse("TEST {% ") + Template.parse('TEST {% ') end end def test_error_on_empty_filter - assert Template.parse("{{test}}") + assert Template.parse('{{test}}') with_error_mode(:lax) do - assert Template.parse("{{|test}}") + assert Template.parse('{{|test}}') end with_error_mode(:strict) do - assert_raises(SyntaxError) { Template.parse("{{|test}}") } - assert_raises(SyntaxError) { Template.parse("{{test |a|b|}}") } + assert_raises(SyntaxError) { Template.parse('{{|test}}') } + assert_raises(SyntaxError) { Template.parse('{{test |a|b|}}') } end end @@ -51,20 +53,20 @@ class ParsingQuirksTest < Minitest::Test def test_unexpected_characters_syntax_error with_error_mode(:strict) do assert_raises(SyntaxError) do - markup = "true && false" + markup = 'true && false' Template.parse("{% if #{markup} %} YES {% endif %}") end assert_raises(SyntaxError) do - markup = "false || true" + markup = 'false || true' Template.parse("{% if #{markup} %} YES {% endif %}") end end 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 Template.parse('{{test |a|b|}}', error_mode: :lax) + assert Template.parse('{{test}}', error_mode: :lax) + assert Template.parse('{{|test|}}', error_mode: :lax) end def test_meaningless_parens_lax @@ -77,9 +79,9 @@ class ParsingQuirksTest < Minitest::Test def test_unexpected_characters_silently_eat_logic_lax with_error_mode(:lax) do - markup = "true && false" + markup = 'true && false' assert_template_result(' YES ', "{% if #{markup} %} YES {% endif %}") - markup = "false || true" + markup = 'false || true' assert_template_result('', "{% if #{markup} %} YES {% endif %}") end end @@ -112,7 +114,7 @@ class ParsingQuirksTest < Minitest::Test def test_extra_dots_in_ranges with_error_mode(:lax) do - assert_template_result('12345', "{% for i in (1...5) %}{{ i }}{% endfor %}") + assert_template_result('12345', '{% for i in (1...5) %}{{ i }}{% endfor %}') end end diff --git a/test/integration/render_profiling_test.rb b/test/integration/render_profiling_test.rb index d0111e7..03fe23e 100644 --- a/test/integration/render_profiling_test.rb +++ b/test/integration/render_profiling_test.rb @@ -1,3 +1,5 @@ +# frozen_string_literal: true + require 'test_helper' class RenderProfilingTest < Minitest::Test @@ -72,7 +74,7 @@ class RenderProfilingTest < Minitest::Test t = Template.parse("{% include 'a_template' %}", profile: true) t.render! - assert t.profiler.total_render_time >= 0, "Total render time was not calculated" + assert t.profiler.total_render_time >= 0, 'Total render time was not calculated' end def test_profiling_uses_include_to_mark_children @@ -89,7 +91,7 @@ class RenderProfilingTest < Minitest::Test include_node = t.profiler[1] include_node.children.each do |child| - assert_equal "a_template", child.partial + assert_equal 'a_template', child.partial end end @@ -99,12 +101,12 @@ class RenderProfilingTest < Minitest::Test a_template = t.profiler[1] a_template.children.each do |child| - assert_equal "a_template", child.partial + assert_equal 'a_template', child.partial end b_template = t.profiler[2] b_template.children.each do |child| - assert_equal "b_template", child.partial + assert_equal 'b_template', child.partial end end @@ -114,12 +116,12 @@ class RenderProfilingTest < Minitest::Test a_template1 = t.profiler[1] a_template1.children.each do |child| - assert_equal "a_template", child.partial + assert_equal 'a_template', child.partial end a_template2 = t.profiler[2] a_template2.children.each do |child| - assert_equal "a_template", child.partial + assert_equal 'a_template', child.partial end end @@ -128,7 +130,7 @@ class RenderProfilingTest < Minitest::Test t.render! timing_count = 0 - t.profiler.each do |timing| + t.profiler.each do |_timing| timing_count += 1 end @@ -136,7 +138,7 @@ class RenderProfilingTest < Minitest::Test end def test_profiling_marks_children_of_if_blocks - t = Template.parse("{% if true %} {% increment test %} {{ test }} {% endif %}", profile: true) + t = Template.parse('{% if true %} {% increment test %} {{ test }} {% endif %}', profile: true) t.render! assert_equal 1, t.profiler.length @@ -144,8 +146,8 @@ class RenderProfilingTest < Minitest::Test 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"] }) + t = Template.parse('{% for item in collection %} {{ item }} {% endfor %}', profile: true) + t.render!('collection' => %w[one two]) assert_equal 1, t.profiler.length # Will profile each invocation of the for block diff --git a/test/integration/security_test.rb b/test/integration/security_test.rb index f603ff0..be97b53 100644 --- a/test/integration/security_test.rb +++ b/test/integration/security_test.rb @@ -1,3 +1,5 @@ +# frozen_string_literal: true + require 'test_helper' module SecurityFilter @@ -57,22 +59,22 @@ class SecurityTest < Minitest::Test current_symbols = Symbol.all_symbols assigns = { 'drop' => Drop.new } - assert_equal "", Template.parse("{{ drop.custom_method_1 }}", assigns).render! - assert_equal "", Template.parse("{{ drop.custom_method_2 }}", assigns).render! - assert_equal "", Template.parse("{{ drop.custom_method_3 }}", assigns).render! + assert_equal '', Template.parse('{{ drop.custom_method_1 }}', assigns).render! + assert_equal '', Template.parse('{{ drop.custom_method_2 }}', assigns).render! + assert_equal '', Template.parse('{{ drop.custom_method_3 }}', assigns).render! assert_equal [], (Symbol.all_symbols - current_symbols) end def test_max_depth_nested_blocks_does_not_raise_exception depth = Liquid::Block::MAX_DEPTH - code = "{% if true %}" * depth + "rendered" + "{% endif %}" * depth - assert_equal "rendered", Template.parse(code).render! + code = '{% if true %}' * depth + 'rendered' + '{% endif %}' * depth + assert_equal 'rendered', Template.parse(code).render! end def test_more_than_max_depth_nested_blocks_raises_exception depth = Liquid::Block::MAX_DEPTH + 1 - code = "{% if true %}" * depth + "rendered" + "{% endif %}" * depth + code = '{% if true %}' * depth + 'rendered' + '{% endif %}' * depth assert_raises(Liquid::StackLevelError) do Template.parse(code).render! end diff --git a/test/integration/standard_filter_test.rb b/test/integration/standard_filter_test.rb index 6090951..77f9e4d 100644 --- a/test/integration/standard_filter_test.rb +++ b/test/integration/standard_filter_test.rb @@ -1,4 +1,4 @@ -# encoding: utf-8 +# frozen_string_literal: true require 'test_helper' @@ -17,7 +17,7 @@ class TestThing "woot: #{@foo}" end - def [](whatever) + def [](_whatever) to_s end @@ -29,7 +29,7 @@ end class TestDrop < Liquid::Drop def test - "testfoo" + 'testfoo' end end @@ -37,7 +37,7 @@ class TestEnumerable < Liquid::Drop include Enumerable def each(&block) - [ { "foo" => 1, "bar" => 2 }, { "foo" => 2, "bar" => 1 }, { "foo" => 3, "bar" => 3 } ].each(&block) + [{ 'foo' => 1, 'bar' => 2 }, { 'foo' => 2, 'bar' => 1 }, { 'foo' => 3, 'bar' => 3 }].each(&block) end end @@ -65,12 +65,12 @@ class StandardFiltersTest < Minitest::Test end def test_downcase - assert_equal 'testing', @filters.downcase("Testing") + assert_equal 'testing', @filters.downcase('Testing') assert_equal '', @filters.downcase(nil) end def test_upcase - assert_equal 'TESTING', @filters.upcase("Testing") + assert_equal 'TESTING', @filters.upcase('Testing') assert_equal '', @filters.upcase(nil) end @@ -91,22 +91,22 @@ class StandardFiltersTest < Minitest::Test @filters.slice('foobar', nil) end assert_raises(Liquid::ArgumentError) do - @filters.slice('foobar', 0, "") + @filters.slice('foobar', 0, '') end 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) + 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 @@ -114,16 +114,16 @@ class StandardFiltersTest < Minitest::Test assert_equal '1234567890', @filters.truncate('1234567890', 20) assert_equal '...', @filters.truncate('1234567890', 0) assert_equal '1234567890', @filters.truncate('1234567890') - assert_equal "测试...", @filters.truncate("测试测试测试测试", 5) - assert_equal '12341', @filters.truncate("1234567890", 5, 1) + assert_equal '测试...', @filters.truncate('测试测试测试测试', 5) + assert_equal '12341', @filters.truncate('1234567890', 5, 1) end def test_split - assert_equal ['12', '34'], @filters.split('12~34', '~') + assert_equal %w[12 34], @filters.split('12~34', '~') assert_equal ['A? ', ' ,Z'], @filters.split('A? ~ ~ ~ ,Z', '~ ~ ~') assert_equal ['A?Z'], @filters.split('A?Z', '~') assert_equal [], @filters.split(nil, ' ') - assert_equal ['A', 'Z'], @filters.split('A1Z', 1) + assert_equal %w[A Z], @filters.split('A1Z', 1) end def test_escape @@ -169,12 +169,12 @@ class StandardFiltersTest < Minitest::Test assert_equal 'one two...', @filters.truncatewords('one two three', 2) assert_equal 'one two three', @filters.truncatewords('one two three') assert_equal 'Two small (13” x 5.5” x 10” high) baskets fit inside one large basket (13”...', @filters.truncatewords('Two small (13” x 5.5” x 10” high) baskets fit inside one large basket (13” x 16” x 10.5” high) with cover.', 15) - assert_equal "测试测试测试测试", @filters.truncatewords('测试测试测试测试', 5) - assert_equal 'one two1', @filters.truncatewords("one two three", 2, 1) + assert_equal '测试测试测试测试', @filters.truncatewords('测试测试测试测试', 5) + assert_equal 'one two1', @filters.truncatewords('one two three', 2, 1) end def test_strip_html - assert_equal 'test', @filters.strip_html("
test
") + assert_equal 'test', @filters.strip_html('
test
') assert_equal 'test', @filters.strip_html("
test
") assert_equal '', @filters.strip_html("") assert_equal '', @filters.strip_html("") @@ -183,7 +183,7 @@ class StandardFiltersTest < Minitest::Test assert_equal '', @filters.strip_html(nil) # Quirk of the existing implementation - assert_equal 'foo;', @filters.strip_html("<<") + assert_equal 'foo;', @filters.strip_html('<<') end def test_join @@ -194,163 +194,163 @@ class StandardFiltersTest < Minitest::Test 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 [{ 'a' => 1 }, { 'a' => 2 }, { 'a' => 3 }, { 'a' => 4 }], @filters.sort([{ 'a' => 4 }, { 'a' => 3 }, { 'a' => 1 }, { 'a' => 2 }], 'a') end def test_sort_with_nils assert_equal [1, 2, 3, 4, nil], @filters.sort([nil, 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 [{ 'a' => 1 }, { 'a' => 2 }, { 'a' => 3 }, { 'a' => 4 }, {}], @filters.sort([{ 'a' => 4 }, { 'a' => 3 }, {}, { 'a' => 1 }, { 'a' => 2 }], 'a') end def test_sort_when_property_is_sometimes_missing_puts_nils_last input = [ - { "price" => 4, "handle" => "alpha" }, - { "handle" => "beta" }, - { "price" => 1, "handle" => "gamma" }, - { "handle" => "delta" }, - { "price" => 2, "handle" => "epsilon" } + { 'price' => 4, 'handle' => 'alpha' }, + { 'handle' => 'beta' }, + { 'price' => 1, 'handle' => 'gamma' }, + { 'handle' => 'delta' }, + { 'price' => 2, 'handle' => 'epsilon' }, ] expectation = [ - { "price" => 1, "handle" => "gamma" }, - { "price" => 2, "handle" => "epsilon" }, - { "price" => 4, "handle" => "alpha" }, - { "handle" => "delta" }, - { "handle" => "beta" } + { 'price' => 1, 'handle' => 'gamma' }, + { 'price' => 2, 'handle' => 'epsilon' }, + { 'price' => 4, 'handle' => 'alpha' }, + { 'handle' => 'delta' }, + { 'handle' => 'beta' }, ] - assert_equal expectation, @filters.sort(input, "price") + assert_equal expectation, @filters.sort(input, 'price') end def test_sort_natural - assert_equal ["a", "B", "c", "D"], @filters.sort_natural(["c", "D", "a", "B"]) - assert_equal [{ "a" => "a" }, { "a" => "B" }, { "a" => "c" }, { "a" => "D" }], @filters.sort_natural([{ "a" => "D" }, { "a" => "c" }, { "a" => "a" }, { "a" => "B" }], "a") + assert_equal %w[a B c D], @filters.sort_natural(%w[c D a B]) + assert_equal [{ 'a' => 'a' }, { 'a' => 'B' }, { 'a' => 'c' }, { 'a' => 'D' }], @filters.sort_natural([{ 'a' => 'D' }, { 'a' => 'c' }, { 'a' => 'a' }, { 'a' => 'B' }], 'a') end def test_sort_natural_with_nils - assert_equal ["a", "B", "c", "D", nil], @filters.sort_natural([nil, "c", "D", "a", "B"]) - assert_equal [{ "a" => "a" }, { "a" => "B" }, { "a" => "c" }, { "a" => "D" }, {}], @filters.sort_natural([{ "a" => "D" }, { "a" => "c" }, {}, { "a" => "a" }, { "a" => "B" }], "a") + assert_equal ['a', 'B', 'c', 'D', nil], @filters.sort_natural([nil, 'c', 'D', 'a', 'B']) + assert_equal [{ 'a' => 'a' }, { 'a' => 'B' }, { 'a' => 'c' }, { 'a' => 'D' }, {}], @filters.sort_natural([{ 'a' => 'D' }, { 'a' => 'c' }, {}, { 'a' => 'a' }, { 'a' => 'B' }], 'a') end def test_sort_natural_when_property_is_sometimes_missing_puts_nils_last input = [ - { "price" => "4", "handle" => "alpha" }, - { "handle" => "beta" }, - { "price" => "1", "handle" => "gamma" }, - { "handle" => "delta" }, - { "price" => 2, "handle" => "epsilon" } + { 'price' => '4', 'handle' => 'alpha' }, + { 'handle' => 'beta' }, + { 'price' => '1', 'handle' => 'gamma' }, + { 'handle' => 'delta' }, + { 'price' => 2, 'handle' => 'epsilon' }, ] expectation = [ - { "price" => "1", "handle" => "gamma" }, - { "price" => 2, "handle" => "epsilon" }, - { "price" => "4", "handle" => "alpha" }, - { "handle" => "delta" }, - { "handle" => "beta" } + { 'price' => '1', 'handle' => 'gamma' }, + { 'price' => 2, 'handle' => 'epsilon' }, + { 'price' => '4', 'handle' => 'alpha' }, + { 'handle' => 'delta' }, + { 'handle' => 'beta' }, ] - assert_equal expectation, @filters.sort_natural(input, "price") + assert_equal expectation, @filters.sort_natural(input, 'price') end def test_sort_natural_case_check input = [ - { "key" => "X" }, - { "key" => "Y" }, - { "key" => "Z" }, - { "fake" => "t" }, - { "key" => "a" }, - { "key" => "b" }, - { "key" => "c" } + { 'key' => 'X' }, + { 'key' => 'Y' }, + { 'key' => 'Z' }, + { 'fake' => 't' }, + { 'key' => 'a' }, + { 'key' => 'b' }, + { 'key' => 'c' }, ] expectation = [ - { "key" => "a" }, - { "key" => "b" }, - { "key" => "c" }, - { "key" => "X" }, - { "key" => "Y" }, - { "key" => "Z" }, - { "fake" => "t" } + { 'key' => 'a' }, + { 'key' => 'b' }, + { 'key' => 'c' }, + { 'key' => 'X' }, + { 'key' => 'Y' }, + { 'key' => 'Z' }, + { 'fake' => 't' }, ] - assert_equal expectation, @filters.sort_natural(input, "key") - assert_equal ["a", "b", "c", "X", "Y", "Z"], @filters.sort_natural(["X", "Y", "Z", "a", "b", "c"]) + assert_equal expectation, @filters.sort_natural(input, 'key') + assert_equal %w[a b c X Y Z], @filters.sort_natural(%w[X Y Z a b c]) end def test_sort_empty_array - assert_equal [], @filters.sort([], "a") + assert_equal [], @filters.sort([], 'a') end def test_sort_invalid_property foo = [ [1], [2], - [3] + [3], ] assert_raises Liquid::ArgumentError do - @filters.sort(foo, "bar") + @filters.sort(foo, 'bar') end end def test_sort_natural_empty_array - assert_equal [], @filters.sort_natural([], "a") + assert_equal [], @filters.sort_natural([], 'a') end def test_sort_natural_invalid_property foo = [ [1], [2], - [3] + [3], ] assert_raises Liquid::ArgumentError do - @filters.sort_natural(foo, "bar") + @filters.sort_natural(foo, 'bar') end 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 ["10", "2"], @filters.sort(["10", "2"]) - assert_equal [{ "a" => "10" }, { "a" => "2" }], @filters.sort([{ "a" => "10" }, { "a" => "2" }], "a") + assert_equal [{ 'a' => 2 }, { 'a' => 10 }], @filters.sort([{ 'a' => 10 }, { 'a' => 2 }], 'a') + assert_equal %w[10 2], @filters.sort(%w[10 2]) + assert_equal [{ 'a' => '10' }, { 'a' => '2' }], @filters.sort([{ 'a' => '10' }, { 'a' => '2' }], 'a') end def test_uniq - assert_equal ["foo"], @filters.uniq("foo") + assert_equal ['foo'], @filters.uniq('foo') 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") + 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') end def test_uniq_empty_array - assert_equal [], @filters.uniq([], "a") + assert_equal [], @filters.uniq([], 'a') end def test_uniq_invalid_property foo = [ [1], [2], - [3] + [3], ] assert_raises Liquid::ArgumentError do - @filters.uniq(foo, "bar") + @filters.uniq(foo, 'bar') end end def test_compact_empty_array - assert_equal [], @filters.compact([], "a") + assert_equal [], @filters.compact([], 'a') end def test_compact_invalid_property foo = [ [1], [2], - [3] + [3], ] assert_raises Liquid::ArgumentError do - @filters.compact(foo, "bar") + @filters.compact(foo, 'bar') end end @@ -363,71 +363,71 @@ class StandardFiltersTest < Minitest::Test 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 - assert_template_result "", '{{ "foo" | map: "__id__" }}' - assert_template_result "", '{{ "foo" | map: "inspect" }}' + assert_template_result '', '{{ "foo" | map: "__id__" }}' + assert_template_result '', '{{ "foo" | map: "inspect" }}' end def test_map_calls_to_liquid t = TestThing.new - assert_template_result "woot: 1", '{{ foo | map: "whatever" }}', "foo" => [t] + assert_template_result 'woot: 1', '{{ foo | map: "whatever" }}', 'foo' => [t] end def test_map_on_hashes - assert_template_result "4217", '{{ thing | map: "foo" | map: "bar" }}', - "thing" => { "foo" => [ { "bar" => 42 }, { "bar" => 17 } ] } + assert_template_result '4217', '{{ thing | map: "foo" | map: "bar" }}', + 'thing' => { 'foo' => [{ 'bar' => 42 }, { 'bar' => 17 }] } end def test_legacy_map_on_hashes_with_dynamic_key template = "{% assign key = 'foo' %}{{ thing | map: key | map: 'bar' }}" - hash = { "foo" => { "bar" => 42 } } - assert_template_result "42", template, "thing" => hash + hash = { 'foo' => { 'bar' => 42 } } + assert_template_result '42', template, 'thing' => hash end def test_sort_calls_to_liquid t = TestThing.new - Liquid::Template.parse('{{ foo | sort: "whatever" }}').render("foo" => [t]) - assert t.foo > 0 + Liquid::Template.parse('{{ foo | sort: "whatever" }}').render('foo' => [t]) + assert t.foo.positive? end def test_map_over_proc drop = TestDrop.new - p = proc{ drop } + p = proc { drop } templ = '{{ procs | map: "test" }}' - assert_template_result "testfoo", templ, "procs" => [p] + assert_template_result 'testfoo', templ, 'procs' => [p] end def test_map_over_drops_returning_procs drops = [ { - "proc" => ->{ "foo" }, + 'proc' => -> { 'foo' }, }, { - "proc" => ->{ "bar" }, + 'proc' => -> { 'bar' }, }, ] templ = '{{ drops | map: "proc" }}' - assert_template_result "foobar", templ, "drops" => drops + assert_template_result 'foobar', templ, 'drops' => drops end def test_map_works_on_enumerables - assert_template_result "123", '{{ foo | map: "foo" }}', "foo" => TestEnumerable.new + assert_template_result '123', '{{ foo | map: "foo" }}', 'foo' => TestEnumerable.new end def test_map_returns_empty_on_2d_input_array foo = [ [1], [2], - [3] + [3], ] assert_raises Liquid::ArgumentError do - @filters.map(foo, "bar") + @filters.map(foo, 'bar') end end @@ -435,7 +435,7 @@ class StandardFiltersTest < Minitest::Test foo = [ [1], [2], - [3] + [3], ] assert_raises Liquid::ArgumentError do @filters.map(foo, nil) @@ -443,7 +443,7 @@ class StandardFiltersTest < Minitest::Test end def test_sort_works_on_enumerables - assert_template_result "213", '{{ foo | sort: "bar" | map: "foo" }}', "foo" => TestEnumerable.new + assert_template_result '213', '{{ foo | sort: "bar" | map: "foo" }}', 'foo' => TestEnumerable.new end def test_first_and_last_call_to_liquid @@ -452,37 +452,37 @@ class StandardFiltersTest < Minitest::Test end def test_truncate_calls_to_liquid - assert_template_result "wo...", '{{ foo | truncate: 5 }}', "foo" => TestThing.new + assert_template_result 'wo...', '{{ foo | truncate: 5 }}', 'foo' => TestThing.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") - assert_equal 'July', @filters.date(Time.parse("2006-07-05 10:00:00"), "%B") + 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') + assert_equal 'July', @filters.date(Time.parse('2006-07-05 10:00:00'), '%B') - assert_equal 'May', @filters.date("2006-05-05 10:00:00", "%B") - assert_equal 'June', @filters.date("2006-06-05 10:00:00", "%B") - assert_equal 'July', @filters.date("2006-07-05 10:00:00", "%B") + assert_equal 'May', @filters.date('2006-05-05 10:00:00', '%B') + assert_equal 'June', @filters.date('2006-06-05 10:00:00', '%B') + assert_equal 'July', @filters.date('2006-07-05 10:00:00', '%B') - assert_equal '2006-07-05 10:00:00', @filters.date("2006-07-05 10:00:00", "") - assert_equal '2006-07-05 10:00:00', @filters.date("2006-07-05 10:00:00", "") - assert_equal '2006-07-05 10:00:00', @filters.date("2006-07-05 10:00:00", "") - assert_equal '2006-07-05 10:00:00', @filters.date("2006-07-05 10:00:00", nil) + assert_equal '2006-07-05 10:00:00', @filters.date('2006-07-05 10:00:00', '') + assert_equal '2006-07-05 10:00:00', @filters.date('2006-07-05 10:00:00', '') + assert_equal '2006-07-05 10:00:00', @filters.date('2006-07-05 10:00:00', '') + assert_equal '2006-07-05 10:00:00', @filters.date('2006-07-05 10:00:00', nil) - assert_equal '07/05/2006', @filters.date("2006-07-05 10:00:00", "%m/%d/%Y") + assert_equal '07/05/2006', @filters.date('2006-07-05 10:00:00', '%m/%d/%Y') - assert_equal "07/16/2004", @filters.date("Fri Jul 16 01:00:00 2004", "%m/%d/%Y") + assert_equal '07/16/2004', @filters.date('Fri Jul 16 01:00:00 2004', '%m/%d/%Y') assert_equal Date.today.year.to_s, @filters.date('now', '%Y') assert_equal Date.today.year.to_s, @filters.date('today', '%Y') assert_equal Date.today.year.to_s, @filters.date('Today', '%Y') - assert_nil @filters.date(nil, "%B") + assert_nil @filters.date(nil, '%B') - assert_equal '', @filters.date('', "%B") + assert_equal '', @filters.date('', '%B') - with_timezone("UTC") do - assert_equal "07/05/2006", @filters.date(1152098955, "%m/%d/%Y") - assert_equal "07/05/2006", @filters.date("1152098955", "%m/%d/%Y") + with_timezone('UTC') do + assert_equal '07/05/2006', @filters.date(1_152_098_955, '%m/%d/%Y') + assert_equal '07/05/2006', @filters.date('1152098955', '%m/%d/%Y') end end @@ -502,10 +502,10 @@ class StandardFiltersTest < Minitest::Test end def test_remove - assert_equal ' ', @filters.remove("a a a a", 'a') - assert_equal ' ', @filters.remove("1 1 1 1", 1) - assert_equal 'a a a', @filters.remove_first("a a a a", 'a ') - assert_equal ' 1 1 1', @filters.remove_first("1 1 1 1", 1) + assert_equal ' ', @filters.remove('a a a a', 'a') + assert_equal ' ', @filters.remove('1 1 1 1', 1) + assert_equal 'a a a', @filters.remove_first('a a a a', 'a ') + assert_equal ' 1 1 1', @filters.remove_first('1 1 1 1', 1) assert_template_result 'a a a', "{{ 'a a a a' | remove_first: 'a ' }}" end @@ -514,148 +514,148 @@ class StandardFiltersTest < Minitest::Test end def test_strip - assert_template_result 'ab c', "{{ source | strip }}", 'source' => " ab c " - assert_template_result 'ab c', "{{ source | strip }}", 'source' => " \tab c \n \t" + assert_template_result 'ab c', '{{ source | strip }}', 'source' => ' ab c ' + assert_template_result 'ab c', '{{ source | strip }}', 'source' => " \tab c \n \t" end def test_lstrip - assert_template_result 'ab c ', "{{ source | lstrip }}", 'source' => " ab c " - assert_template_result "ab c \n \t", "{{ source | lstrip }}", 'source' => " \tab c \n \t" + assert_template_result 'ab c ', '{{ source | lstrip }}', 'source' => ' ab c ' + assert_template_result "ab c \n \t", '{{ source | lstrip }}', 'source' => " \tab c \n \t" end def test_rstrip - assert_template_result " ab c", "{{ source | rstrip }}", 'source' => " ab c " - assert_template_result " \tab c", "{{ source | rstrip }}", 'source' => " \tab c \n \t" + assert_template_result ' ab c', '{{ source | rstrip }}', 'source' => ' ab c ' + assert_template_result " \tab c", '{{ source | rstrip }}', 'source' => " \tab c \n \t" end def test_strip_newlines - assert_template_result 'abc', "{{ source | strip_newlines }}", 'source' => "a\nb\nc" - assert_template_result 'abc', "{{ source | strip_newlines }}", 'source' => "a\r\nb\nc" + assert_template_result 'abc', '{{ source | strip_newlines }}', 'source' => "a\nb\nc" + assert_template_result 'abc', '{{ source | strip_newlines }}', 'source' => "a\r\nb\nc" end def test_newlines_to_br - assert_template_result "a
\nb
\nc", "{{ source | newline_to_br }}", 'source' => "a\nb\nc" + assert_template_result "a
\nb
\nc", '{{ source | newline_to_br }}', 'source' => "a\nb\nc" end def test_plus - assert_template_result "2", "{{ 1 | plus:1 }}" - assert_template_result "2.0", "{{ '1' | plus:'1.0' }}" + assert_template_result '2', '{{ 1 | plus:1 }}' + assert_template_result '2.0', "{{ '1' | plus:'1.0' }}" - assert_template_result "5", "{{ price | plus:'2' }}", 'price' => NumberLikeThing.new(3) + assert_template_result '5', "{{ price | plus:'2' }}", 'price' => NumberLikeThing.new(3) end def test_minus - assert_template_result "4", "{{ input | minus:operand }}", 'input' => 5, 'operand' => 1 - assert_template_result "2.3", "{{ '4.3' | minus:'2' }}" + assert_template_result '4', '{{ input | minus:operand }}', 'input' => 5, 'operand' => 1 + assert_template_result '2.3', "{{ '4.3' | minus:'2' }}" - assert_template_result "5", "{{ price | minus:'2' }}", 'price' => NumberLikeThing.new(7) + assert_template_result '5', "{{ price | minus:'2' }}", 'price' => NumberLikeThing.new(7) end def test_abs - assert_template_result "17", "{{ 17 | abs }}" - assert_template_result "17", "{{ -17 | abs }}" - assert_template_result "17", "{{ '17' | abs }}" - assert_template_result "17", "{{ '-17' | abs }}" - assert_template_result "0", "{{ 0 | abs }}" - assert_template_result "0", "{{ '0' | abs }}" - assert_template_result "17.42", "{{ 17.42 | abs }}" - assert_template_result "17.42", "{{ -17.42 | abs }}" - assert_template_result "17.42", "{{ '17.42' | abs }}" - assert_template_result "17.42", "{{ '-17.42' | abs }}" + assert_template_result '17', '{{ 17 | abs }}' + assert_template_result '17', '{{ -17 | abs }}' + assert_template_result '17', "{{ '17' | abs }}" + assert_template_result '17', "{{ '-17' | abs }}" + assert_template_result '0', '{{ 0 | abs }}' + assert_template_result '0', "{{ '0' | abs }}" + assert_template_result '17.42', '{{ 17.42 | abs }}' + assert_template_result '17.42', '{{ -17.42 | abs }}' + assert_template_result '17.42', "{{ '17.42' | abs }}" + assert_template_result '17.42', "{{ '-17.42' | abs }}" end def test_times - assert_template_result "12", "{{ 3 | times:4 }}" - assert_template_result "0", "{{ 'foo' | times:4 }}" - assert_template_result "6", "{{ '2.1' | times:3 | replace: '.','-' | plus:0}}" - assert_template_result "7.25", "{{ 0.0725 | times:100 }}" - assert_template_result "-7.25", '{{ "-0.0725" | times:100 }}' - assert_template_result "7.25", '{{ "-0.0725" | times: -100 }}' - assert_template_result "4", "{{ price | times:2 }}", 'price' => NumberLikeThing.new(2) + assert_template_result '12', '{{ 3 | times:4 }}' + assert_template_result '0', "{{ 'foo' | times:4 }}" + assert_template_result '6', "{{ '2.1' | times:3 | replace: '.','-' | plus:0}}" + assert_template_result '7.25', '{{ 0.0725 | times:100 }}' + assert_template_result '-7.25', '{{ "-0.0725" | times:100 }}' + assert_template_result '7.25', '{{ "-0.0725" | times: -100 }}' + assert_template_result '4', '{{ price | times:2 }}', 'price' => NumberLikeThing.new(2) end def test_divided_by - assert_template_result "4", "{{ 12 | divided_by:3 }}" - assert_template_result "4", "{{ 14 | divided_by:3 }}" + assert_template_result '4', '{{ 12 | divided_by:3 }}' + assert_template_result '4', '{{ 14 | divided_by:3 }}' - assert_template_result "5", "{{ 15 | divided_by:3 }}" - assert_equal "Liquid error: divided by 0", Template.parse("{{ 5 | divided_by:0 }}").render + assert_template_result '5', '{{ 15 | divided_by:3 }}' + assert_equal 'Liquid error: divided by 0', Template.parse('{{ 5 | divided_by:0 }}').render - assert_template_result "0.5", "{{ 2.0 | divided_by:4 }}" + assert_template_result '0.5', '{{ 2.0 | divided_by:4 }}' assert_raises(Liquid::ZeroDivisionError) do - assert_template_result "4", "{{ 1 | modulo: 0 }}" + assert_template_result '4', '{{ 1 | modulo: 0 }}' end - assert_template_result "5", "{{ price | divided_by:2 }}", 'price' => NumberLikeThing.new(10) + assert_template_result '5', '{{ price | divided_by:2 }}', 'price' => NumberLikeThing.new(10) end def test_modulo - assert_template_result "1", "{{ 3 | modulo:2 }}" + assert_template_result '1', '{{ 3 | modulo:2 }}' assert_raises(Liquid::ZeroDivisionError) do - assert_template_result "4", "{{ 1 | modulo: 0 }}" + assert_template_result '4', '{{ 1 | modulo: 0 }}' end - assert_template_result "1", "{{ price | modulo:2 }}", 'price' => NumberLikeThing.new(3) + assert_template_result '1', '{{ price | modulo:2 }}', 'price' => NumberLikeThing.new(3) end def test_round - assert_template_result "5", "{{ input | round }}", 'input' => 4.6 - assert_template_result "4", "{{ '4.3' | round }}" - assert_template_result "4.56", "{{ input | round: 2 }}", 'input' => 4.5612 + assert_template_result '5', '{{ input | round }}', 'input' => 4.6 + assert_template_result '4', "{{ '4.3' | round }}" + assert_template_result '4.56', '{{ input | round: 2 }}', 'input' => 4.5612 assert_raises(Liquid::FloatDomainError) do - assert_template_result "4", "{{ 1.0 | divided_by: 0.0 | round }}" + assert_template_result '4', '{{ 1.0 | divided_by: 0.0 | round }}' end - assert_template_result "5", "{{ price | round }}", 'price' => NumberLikeThing.new(4.6) - assert_template_result "4", "{{ price | round }}", 'price' => NumberLikeThing.new(4.3) + assert_template_result '5', '{{ price | round }}', 'price' => NumberLikeThing.new(4.6) + assert_template_result '4', '{{ price | round }}', 'price' => NumberLikeThing.new(4.3) end def test_ceil - assert_template_result "5", "{{ input | ceil }}", 'input' => 4.6 - assert_template_result "5", "{{ '4.3' | ceil }}" + assert_template_result '5', '{{ input | ceil }}', 'input' => 4.6 + assert_template_result '5', "{{ '4.3' | ceil }}" assert_raises(Liquid::FloatDomainError) do - assert_template_result "4", "{{ 1.0 | divided_by: 0.0 | ceil }}" + assert_template_result '4', '{{ 1.0 | divided_by: 0.0 | ceil }}' end - assert_template_result "5", "{{ price | ceil }}", 'price' => NumberLikeThing.new(4.6) + assert_template_result '5', '{{ price | ceil }}', 'price' => NumberLikeThing.new(4.6) end def test_floor - assert_template_result "4", "{{ input | floor }}", 'input' => 4.6 - assert_template_result "4", "{{ '4.3' | floor }}" + assert_template_result '4', '{{ input | floor }}', 'input' => 4.6 + assert_template_result '4', "{{ '4.3' | floor }}" assert_raises(Liquid::FloatDomainError) do - assert_template_result "4", "{{ 1.0 | divided_by: 0.0 | floor }}" + assert_template_result '4', '{{ 1.0 | divided_by: 0.0 | floor }}' end - assert_template_result "5", "{{ price | floor }}", 'price' => NumberLikeThing.new(5.4) + assert_template_result '5', '{{ price | floor }}', 'price' => NumberLikeThing.new(5.4) end def test_at_most - assert_template_result "4", "{{ 5 | at_most:4 }}" - assert_template_result "5", "{{ 5 | at_most:5 }}" - assert_template_result "5", "{{ 5 | at_most:6 }}" + assert_template_result '4', '{{ 5 | at_most:4 }}' + assert_template_result '5', '{{ 5 | at_most:5 }}' + assert_template_result '5', '{{ 5 | at_most:6 }}' - assert_template_result "4.5", "{{ 4.5 | at_most:5 }}" - assert_template_result "5", "{{ width | at_most:5 }}", 'width' => NumberLikeThing.new(6) - assert_template_result "4", "{{ width | at_most:5 }}", 'width' => NumberLikeThing.new(4) - assert_template_result "4", "{{ 5 | at_most: width }}", 'width' => NumberLikeThing.new(4) + assert_template_result '4.5', '{{ 4.5 | at_most:5 }}' + assert_template_result '5', '{{ width | at_most:5 }}', 'width' => NumberLikeThing.new(6) + assert_template_result '4', '{{ width | at_most:5 }}', 'width' => NumberLikeThing.new(4) + assert_template_result '4', '{{ 5 | at_most: width }}', 'width' => NumberLikeThing.new(4) end def test_at_least - assert_template_result "5", "{{ 5 | at_least:4 }}" - assert_template_result "5", "{{ 5 | at_least:5 }}" - assert_template_result "6", "{{ 5 | at_least:6 }}" + assert_template_result '5', '{{ 5 | at_least:4 }}' + assert_template_result '5', '{{ 5 | at_least:5 }}' + assert_template_result '6', '{{ 5 | at_least:6 }}' - assert_template_result "5", "{{ 4.5 | at_least:5 }}" - assert_template_result "6", "{{ width | at_least:5 }}", 'width' => NumberLikeThing.new(6) - assert_template_result "5", "{{ width | at_least:5 }}", 'width' => NumberLikeThing.new(4) - assert_template_result "6", "{{ 5 | at_least: width }}", 'width' => NumberLikeThing.new(6) + assert_template_result '5', '{{ 4.5 | at_least:5 }}' + assert_template_result '6', '{{ width | at_least:5 }}', 'width' => NumberLikeThing.new(6) + assert_template_result '5', '{{ width | at_least:5 }}', 'width' => NumberLikeThing.new(4) + assert_template_result '6', '{{ 5 | at_least: width }}', 'width' => NumberLikeThing.new(6) 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) + assert_template_result('bcd', '{{ a | append: b}}', assigns) end def test_concat @@ -663,7 +663,7 @@ class StandardFiltersTest < Minitest::Test assert_equal [1, 2, 'a'], @filters.concat([1, 2], ['a']) assert_equal [1, 2, 10], @filters.concat([1, 2], [10]) - assert_raises(Liquid::ArgumentError, "concat filter requires an array argument") do + assert_raises(Liquid::ArgumentError, 'concat filter requires an array argument') do @filters.concat([1, 2], 10) end end @@ -671,16 +671,16 @@ class StandardFiltersTest < Minitest::Test def test_prepend assigns = { 'a' => 'bc', 'b' => 'a' } assert_template_result('abc', "{{ a | prepend: 'a'}}", assigns) - assert_template_result('abc', "{{ a | prepend: b}}", assigns) + assert_template_result('abc', '{{ a | prepend: b}}', assigns) end def test_default - assert_equal "foo", @filters.default("foo", "bar") - assert_equal "bar", @filters.default(nil, "bar") - assert_equal "bar", @filters.default("", "bar") - assert_equal "bar", @filters.default(false, "bar") - assert_equal "bar", @filters.default([], "bar") - assert_equal "bar", @filters.default({}, "bar") + assert_equal 'foo', @filters.default('foo', 'bar') + assert_equal 'bar', @filters.default(nil, 'bar') + assert_equal 'bar', @filters.default('', 'bar') + assert_equal 'bar', @filters.default(false, 'bar') + assert_equal 'bar', @filters.default([], 'bar') + assert_equal 'bar', @filters.default({}, 'bar') end def test_cannot_access_private_methods @@ -694,74 +694,74 @@ class StandardFiltersTest < Minitest::Test def test_where input = [ - { "handle" => "alpha", "ok" => true }, - { "handle" => "beta", "ok" => false }, - { "handle" => "gamma", "ok" => false }, - { "handle" => "delta", "ok" => true } + { 'handle' => 'alpha', 'ok' => true }, + { 'handle' => 'beta', 'ok' => false }, + { 'handle' => 'gamma', 'ok' => false }, + { 'handle' => 'delta', 'ok' => true }, ] expectation = [ - { "handle" => "alpha", "ok" => true }, - { "handle" => "delta", "ok" => true } + { 'handle' => 'alpha', 'ok' => true }, + { 'handle' => 'delta', 'ok' => true }, ] - assert_equal expectation, @filters.where(input, "ok", true) - assert_equal expectation, @filters.where(input, "ok") + assert_equal expectation, @filters.where(input, 'ok', true) + assert_equal expectation, @filters.where(input, 'ok') end def test_where_no_key_set input = [ - { "handle" => "alpha", "ok" => true }, - { "handle" => "beta" }, - { "handle" => "gamma" }, - { "handle" => "delta", "ok" => true } + { 'handle' => 'alpha', 'ok' => true }, + { 'handle' => 'beta' }, + { 'handle' => 'gamma' }, + { 'handle' => 'delta', 'ok' => true }, ] expectation = [ - { "handle" => "alpha", "ok" => true }, - { "handle" => "delta", "ok" => true } + { 'handle' => 'alpha', 'ok' => true }, + { 'handle' => 'delta', 'ok' => true }, ] - assert_equal expectation, @filters.where(input, "ok", true) - assert_equal expectation, @filters.where(input, "ok") + assert_equal expectation, @filters.where(input, 'ok', true) + assert_equal expectation, @filters.where(input, 'ok') end def test_where_non_array_map_input - assert_equal [{ "a" => "ok" }], @filters.where({ "a" => "ok" }, "a", "ok") - assert_equal [], @filters.where({ "a" => "not ok" }, "a", "ok") + assert_equal [{ 'a' => 'ok' }], @filters.where({ 'a' => 'ok' }, 'a', 'ok') + assert_equal [], @filters.where({ 'a' => 'not ok' }, 'a', 'ok') end def test_where_indexable_but_non_map_value - assert_raises(Liquid::ArgumentError) { @filters.where(1, "ok", true) } - assert_raises(Liquid::ArgumentError) { @filters.where(1, "ok") } + assert_raises(Liquid::ArgumentError) { @filters.where(1, 'ok', true) } + assert_raises(Liquid::ArgumentError) { @filters.where(1, 'ok') } end def test_where_non_boolean_value input = [ - { "message" => "Bonjour!", "language" => "French" }, - { "message" => "Hello!", "language" => "English" }, - { "message" => "Hallo!", "language" => "German" } + { 'message' => 'Bonjour!', 'language' => 'French' }, + { 'message' => 'Hello!', 'language' => 'English' }, + { 'message' => 'Hallo!', 'language' => 'German' }, ] - assert_equal [{ "message" => "Bonjour!", "language" => "French" }], @filters.where(input, "language", "French") - assert_equal [{ "message" => "Hallo!", "language" => "German" }], @filters.where(input, "language", "German") - assert_equal [{ "message" => "Hello!", "language" => "English" }], @filters.where(input, "language", "English") + assert_equal [{ 'message' => 'Bonjour!', 'language' => 'French' }], @filters.where(input, 'language', 'French') + assert_equal [{ 'message' => 'Hallo!', 'language' => 'German' }], @filters.where(input, 'language', 'German') + assert_equal [{ 'message' => 'Hello!', 'language' => 'English' }], @filters.where(input, 'language', 'English') end def test_where_array_of_only_unindexable_values - assert_nil @filters.where([nil], "ok", true) - assert_nil @filters.where([nil], "ok") + assert_nil @filters.where([nil], 'ok', true) + assert_nil @filters.where([nil], 'ok') end def test_where_no_target_value input = [ - { "foo" => false }, - { "foo" => true }, - { "foo" => "for sure" }, - { "bar" => true } + { 'foo' => false }, + { 'foo' => true }, + { 'foo' => 'for sure' }, + { 'bar' => true }, ] - assert_equal [{ "foo" => true }, { "foo" => "for sure" }], @filters.where(input, "foo") + assert_equal [{ 'foo' => true }, { 'foo' => 'for sure' }], @filters.where(input, 'foo') end private diff --git a/test/integration/tags/break_tag_test.rb b/test/integration/tags/break_tag_test.rb index 0fbde83..c3a4679 100644 --- a/test/integration/tags/break_tag_test.rb +++ b/test/integration/tags/break_tag_test.rb @@ -1,3 +1,5 @@ +# frozen_string_literal: true + require 'test_helper' class BreakTagTest < Minitest::Test diff --git a/test/integration/tags/continue_tag_test.rb b/test/integration/tags/continue_tag_test.rb index ce4c158..00cca17 100644 --- a/test/integration/tags/continue_tag_test.rb +++ b/test/integration/tags/continue_tag_test.rb @@ -1,3 +1,5 @@ +# frozen_string_literal: true + require 'test_helper' class ContinueTagTest < Minitest::Test diff --git a/test/integration/tags/for_tag_test.rb b/test/integration/tags/for_tag_test.rb index 9980e25..1bedb2a 100644 --- a/test/integration/tags/for_tag_test.rb +++ b/test/integration/tags/for_tag_test.rb @@ -1,3 +1,5 @@ +# frozen_string_literal: true + require 'test_helper' class ThingWithValue < Liquid::Drop @@ -23,16 +25,16 @@ class ForTagTest < Minitest::Test yo HERE - template = < [1, 2, 3]) end def test_for_reversed - assigns = { 'array' => [ 1, 2, 3] } + assigns = { 'array' => [1, 2, 3] } assert_template_result('321', '{%for item in array reversed %}{{item}}{%endfor%}', assigns) end @@ -40,31 +42,31 @@ HERE assert_template_result(' 1 2 3 ', '{%for item in (1..3) %} {{item}} {%endfor%}') assert_raises(Liquid::ArgumentError) do - Template.parse('{% for i in (a..2) %}{% endfor %}').render!("a" => [1, 2]) + Template.parse('{% for i in (a..2) %}{% endfor %}').render!('a' => [1, 2]) end - assert_template_result(' 0 1 2 3 ', '{% for item in (a..3) %} {{item}} {% endfor %}', "a" => "invalid integer") + assert_template_result(' 0 1 2 3 ', '{% for item in (a..3) %} {{item}} {% endfor %}', 'a' => 'invalid integer') 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) + foobar = { 'value' => 3 } + 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('abcd', '{%for item in array%}{{item}}{%endfor%}', 'array' => %w[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 @@ -72,8 +74,8 @@ HERE def test_for_helpers 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) @@ -85,8 +87,8 @@ HERE def test_for_and_if 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 @@ -114,7 +116,7 @@ HERE exception = assert_raises(Liquid::ArgumentError) do Template.parse(template).render!(assigns) end - assert_equal("Liquid error: invalid integer", exception.message) + assert_equal('Liquid error: invalid integer', exception.message) end def test_limiting_with_invalid_offset @@ -128,7 +130,7 @@ HERE exception = assert_raises(Liquid::ArgumentError) do Template.parse(template).render!(assigns) end - assert_equal("Liquid error: invalid integer", exception.message) + assert_equal('Liquid error: invalid integer', exception.message) end def test_dynamic_variable_limiting @@ -157,14 +159,14 @@ HERE {%for i in array.items offset:continue limit: 3 %}{{i}}{%endfor%} next {%for i in array.items offset:continue limit: 3 %}{{i}}{%endfor%} - MKUP + MKUP expected = <<-XPCTD 123 next 456 next 789 - XPCTD + XPCTD assert_template_result(expected, markup, assigns) end @@ -176,14 +178,14 @@ HERE {%for i in array.items offset:continue limit:3 %}{{i}}{%endfor%} next {%for i in array.items offset:continue limit:1 %}{{i}}{%endfor%} - MKUP + MKUP expected = <<-XPCTD 123 next 456 next 7 - XPCTD + XPCTD assert_template_result(expected, markup, assigns) end @@ -195,14 +197,14 @@ HERE {%for i in array.items offset:continue limit:3 %}{{i}}{%endfor%} next {%for i in array.items offset:continue limit:1000 %}{{i}}{%endfor%} - MKUP + MKUP expected = <<-XPCTD 123 next 456 next 7890 - XPCTD + XPCTD assert_template_result(expected, markup, assigns) end @@ -225,19 +227,19 @@ HERE assigns = { 'array' => { 'items' => [1, 2, 3, 4, 5, 6, 7, 8, 9, 10] } } markup = '{% for i in array.items %}{% break %}{% endfor %}' - expected = "" + expected = '' assert_template_result(expected, markup, assigns) markup = '{% for i in array.items %}{{ i }}{% break %}{% endfor %}' - expected = "1" + expected = '1' assert_template_result(expected, markup, assigns) markup = '{% for i in array.items %}{% break %}{{ i }}{% endfor %}' - expected = "" + expected = '' assert_template_result(expected, markup, assigns) markup = '{% for i in array.items %}{{ i }}{% if i > 3 %}{% break %}{% endif %}{% endfor %}' - expected = "1234" + expected = '1234' assert_template_result(expected, markup, assigns) # tests to ensure it only breaks out of the local for loop @@ -265,23 +267,23 @@ HERE assigns = { 'array' => { 'items' => [1, 2, 3, 4, 5] } } markup = '{% for i in array.items %}{% continue %}{% endfor %}' - expected = "" + expected = '' assert_template_result(expected, markup, assigns) markup = '{% for i in array.items %}{{ i }}{% continue %}{% endfor %}' - expected = "12345" + expected = '12345' assert_template_result(expected, markup, assigns) markup = '{% for i in array.items %}{% continue %}{{ i }}{% endfor %}' - expected = "" + expected = '' assert_template_result(expected, markup, assigns) markup = '{% for i in array.items %}{% if i > 3 %}{% continue %}{% endif %}{{ i }}{% endfor %}' - expected = "123" + expected = '123' assert_template_result(expected, markup, assigns) markup = '{% for i in array.items %}{% if i == 3 %}{% continue %}{% else %}{{ i }}{% endif %}{% endfor %}' - expected = "1245" + expected = '1245' assert_template_result(expected, markup, assigns) # tests to ensure it only continues the local for loop and not all of them. @@ -310,41 +312,41 @@ 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") + '{%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]]) + '{% 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]]) + '{% 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 @@ -352,7 +354,7 @@ HERE end def test_blank_string_not_iterable - assert_template_result('', "{% for char in characters %}I WILL NOT BE OUTPUT{% endfor %}", 'characters' => '') + assert_template_result('', '{% for char in characters %}I WILL NOT BE OUTPUT{% endfor %}', 'characters' => '') end def test_bad_variable_naming_in_for_loop diff --git a/test/integration/tags/if_else_tag_test.rb b/test/integration/tags/if_else_tag_test.rb index 45a5d3a..8c9f257 100644 --- a/test/integration/tags/if_else_tag_test.rb +++ b/test/integration/tags/if_else_tag_test.rb @@ -1,3 +1,5 @@ +# frozen_string_literal: true + require 'test_helper' class IfElseTagTest < Minitest::Test @@ -6,7 +8,7 @@ class IfElseTagTest < Minitest::Test def test_if 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 %} ') + ' {% 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 @@ -49,12 +51,12 @@ class IfElseTagTest < Minitest::Test 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) + assert_template_result('YES', + "{% if android.name == 'Roy' %}YES{% endif %}", + assigns) + assert_template_result('YES', + '{% if order.items_count == 0 %}YES{% endif %}', + assigns) end def test_if_and @@ -75,14 +77,14 @@ class IfElseTagTest < Minitest::Test 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' => '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' => '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' => [] }) @@ -90,11 +92,11 @@ class IfElseTagTest < Minitest::Test 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" %} 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 %} 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 }) @@ -132,7 +134,7 @@ class IfElseTagTest < Minitest::Test end def test_syntax_error_no_variable - assert_raises(SyntaxError){ assert_template_result('', '{% if jerry == 1 %}') } + assert_raises(SyntaxError) { assert_template_result('', '{% if jerry == 1 %}') } end def test_syntax_error_no_expression @@ -154,7 +156,7 @@ class IfElseTagTest < Minitest::Test Condition.operators['contains'] = :[] assert_template_result('yes', - %({% if 'gnomeslab-and-or-liquid' contains 'gnomeslab-and-or-liquid' %}yes{% endif %})) + %({% if 'gnomeslab-and-or-liquid' contains 'gnomeslab-and-or-liquid' %}yes{% endif %})) ensure Condition.operators['contains'] = original_op end @@ -166,7 +168,7 @@ class IfElseTagTest < Minitest::Test end def test_multiple_conditions - tpl = "{% if a or b and c %}true{% else %}false{% endif %}" + tpl = '{% if a or b and c %}true{% else %}false{% endif %}' tests = { [true, true, true] => true, diff --git a/test/integration/tags/include_tag_test.rb b/test/integration/tags/include_tag_test.rb index 14bb8c3..d3c7c35 100644 --- a/test/integration/tags/include_tag_test.rb +++ b/test/integration/tags/include_tag_test.rb @@ -1,37 +1,39 @@ +# frozen_string_literal: true + require 'test_helper' class TestFileSystem def read_template_file(template_path) case template_path - when "product" - "Product: {{ product.title }} " + when 'product' + 'Product: {{ product.title }} ' - when "locale_variables" - "Locale: {{echo1}} {{echo2}}" + when 'locale_variables' + 'Locale: {{echo1}} {{echo2}}' - when "variant" - "Variant: {{ variant.title }}" + when 'variant' + 'Variant: {{ variant.title }}' - when "nested_template" + when 'nested_template' "{% include 'header' %} {% include 'body' %} {% include 'footer' %}" - when "body" + when 'body' "body {% include 'body_detail' %}" - when "nested_product_template" + when 'nested_product_template' "Product: {{ nested_product_template.title }} {%include 'details'%} " - when "recursively_nested_template" + when 'recursively_nested_template' "-{% include 'recursively_nested_template' %}" - when "pick_a_source" - "from TestFileSystem" + when 'pick_a_source' + 'from TestFileSystem' when 'assignments' "{% assign foo = 'bar' %}" when 'break' - "{% break %}" + '{% break %}' else template_path @@ -40,14 +42,14 @@ class TestFileSystem end class OtherFileSystem - def read_template_file(template_path) + def read_template_file(_template_path) 'from OtherFileSystem' end end class CountingFileSystem attr_reader :count - def read_template_file(template_path) + def read_template_file(_template_path) @count ||= 0 @count += 1 'from CountingFileSystem' @@ -55,18 +57,17 @@ class CountingFileSystem end class CustomInclude < Liquid::Tag - Syntax = /(#{Liquid::QuotedFragment}+)(\s+(?:with|for)\s+(#{Liquid::QuotedFragment}+))?/o + SYNTAX = /(#{Liquid::QUOTED_FRAGMENT}+)(\s+(?:with|for)\s+(#{Liquid::QUOTED_FRAGMENT}+))?/o.freeze def initialize(tag_name, markup, tokens) - markup =~ Syntax - @template_name = $1 + markup =~ SYNTAX + @template_name = Regexp.last_match(1) super end - def parse(tokens) - end + def parse(tokens); end - def render_to_output_buffer(context, output) + def render_to_output_buffer(_context, output) output << @template_name[1..-2] output end @@ -81,60 +82,60 @@ 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' } ] + assert_template_result 'Product: Draft 151cm ', + "{% 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' } + assert_template_result 'Product: 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' } ] + assert_template_result 'Product: Draft 151cm Product: Element 155cm ', + "{% include 'product' for products %}", 'products' => [{ 'title' => 'Draft 151cm' }, { 'title' => 'Element 155cm' }] end def test_include_tag_with_local_variables - assert_template_result "Locale: test123 ", "{% include 'locale_variables' echo1: 'test123' %}" + assert_template_result 'Locale: test123 ', "{% include 'locale_variables' echo1: 'test123' %}" end def test_include_tag_with_multiple_local_variables - assert_template_result "Locale: test123 test321", - "{% include 'locale_variables' echo1: 'test123', echo2: 'test321' %}" + assert_template_result 'Locale: test123 test321', + "{% include 'locale_variables' echo1: 'test123', echo2: 'test321' %}" end 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' } + 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 }}" + assert_template_result 'bar', "{% include 'assignments' %}{{ foo }}" end def test_nested_include_tag - assert_template_result "body body_detail", "{% include 'body' %}" + assert_template_result 'body body_detail', "{% include 'body' %}" - assert_template_result "header body body_detail footer", "{% include 'nested_template' %}" + assert_template_result 'header body body_detail footer', "{% include 'nested_template' %}" end def test_nested_include_with_variable - assert_template_result "Product: Draft 151cm details ", - "{% include 'nested_product_template' with product %}", "product" => { "title" => 'Draft 151cm' } + assert_template_result 'Product: Draft 151cm details ', + "{% 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' }] + assert_template_result 'Product: Draft 151cm details Product: Element 155cm details ', + "{% 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) "-{% include 'loop' %}" end end @@ -147,41 +148,41 @@ class IncludeTagTest < Minitest::Test end def test_dynamically_choosen_template - assert_template_result "Test123", "{% include template %}", "template" => 'Test123' - assert_template_result "Test321", "{% include template %}", "template" => 'Test321' + assert_template_result 'Test123', '{% include template %}', 'template' => 'Test123' + assert_template_result 'Test321', '{% include template %}', 'template' => 'Test321' - assert_template_result "Product: Draft 151cm ", "{% include template for product %}", - "template" => 'product', 'product' => { 'title' => 'Draft 151cm' } + assert_template_result 'Product: Draft 151cm ', '{% include template for product %}', + '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 def test_include_tag_within_if_statement - assert_template_result "foo_if_true", "{% if true %}{% include 'foo_if_true' %}{% endif %}" + assert_template_result 'foo_if_true', "{% if true %}{% include 'foo_if_true' %}{% endif %}" end def test_custom_include_tag original_tag = Liquid::Template.tags['include'] Liquid::Template.tags['include'] = CustomInclude begin - assert_equal "custom_foo", - Template.parse("{% include 'custom_foo' %}").render! + assert_equal 'custom_foo', + Template.parse("{% include 'custom_foo' %}").render! ensure Liquid::Template.tags['include'] = original_tag end @@ -191,8 +192,8 @@ class IncludeTagTest < Minitest::Test original_tag = Liquid::Template.tags['include'] Liquid::Template.tags['include'] = CustomInclude begin - assert_equal "custom_foo_if_true", - Template.parse("{% if true %}{% include 'custom_foo_if_true' %}{% endif %}").render! + assert_equal 'custom_foo_if_true', + Template.parse("{% if true %}{% include 'custom_foo_if_true' %}{% endif %}").render! ensure Liquid::Template.tags['include'] = original_tag end @@ -208,16 +209,16 @@ class IncludeTagTest < Minitest::Test def test_passing_options_to_included_templates assert_raises(Liquid::SyntaxError) do - Template.parse("{% include template %}", error_mode: :strict).render!("template" => '{{ "X" || downcase }}') + 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 }}') + 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 }}') + 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 }}') + assert_equal 'x', Template.parse('{% include template %}', error_mode: :strict, include_options_blacklist: [:error_mode]).render!('template' => '{{ "X" || downcase }}') end end @@ -233,11 +234,11 @@ class IncludeTagTest < Minitest::Test end def test_including_via_variable_value - assert_template_result "from TestFileSystem", "{% assign page = 'pick_a_source' %}{% include page %}" + 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 %}", 'product' => { 'title' => 'Draft 151cm' } - assert_template_result "Product: Draft 151cm ", "{% assign page = 'product' %}{% include page for foo %}", "foo" => { 'title' => 'Draft 151cm' } + assert_template_result 'Product: Draft 151cm ', "{% assign page = 'product' %}{% include page for foo %}", 'foo' => { 'title' => 'Draft 151cm' } end def test_including_with_strict_variables @@ -248,7 +249,7 @@ class IncludeTagTest < Minitest::Test end def test_break_through_include - assert_template_result "1", "{% for i in (1..3) %}{{ i }}{% break %}{{ i }}{% endfor %}" - assert_template_result "1", "{% for i in (1..3) %}{{ i }}{% include 'break' %}{{ i }}{% endfor %}" + assert_template_result '1', '{% for i in (1..3) %}{{ i }}{% break %}{{ i }}{% endfor %}' + assert_template_result '1', "{% for i in (1..3) %}{{ i }}{% include 'break' %}{{ i }}{% endfor %}" end end # IncludeTagTest diff --git a/test/integration/tags/increment_tag_test.rb b/test/integration/tags/increment_tag_test.rb index 97c51ac..20129a9 100644 --- a/test/integration/tags/increment_tag_test.rb +++ b/test/integration/tags/increment_tag_test.rb @@ -1,3 +1,5 @@ +# frozen_string_literal: true + require 'test_helper' class IncrementTagTest < Minitest::Test @@ -7,17 +9,17 @@ class IncrementTagTest < Minitest::Test 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('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 diff --git a/test/integration/tags/raw_tag_test.rb b/test/integration/tags/raw_tag_test.rb index 634d052..d6b1706 100644 --- a/test/integration/tags/raw_tag_test.rb +++ b/test/integration/tags/raw_tag_test.rb @@ -1,3 +1,5 @@ +# frozen_string_literal: true + require 'test_helper' class RawTagTest < Minitest::Test @@ -5,7 +7,7 @@ class RawTagTest < Minitest::Test 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 diff --git a/test/integration/tags/standard_tag_test.rb b/test/integration/tags/standard_tag_test.rb index 4b4703a..2ab2f65 100644 --- a/test/integration/tags/standard_tag_test.rb +++ b/test/integration/tags/standard_tag_test.rb @@ -1,3 +1,5 @@ +# frozen_string_literal: true + require 'test_helper' class StandardTagTest < Minitest::Test @@ -5,7 +7,7 @@ class StandardTagTest < Minitest::Test 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('', '') @@ -19,7 +21,7 @@ class StandardTagTest < Minitest::Test 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?)) + %(the comment block should be removed {%comment%} be gone.. {%endcomment%} .. right?)) assert_template_result('', '{%comment%}{%endcomment%}') assert_template_result('', '{%comment%}{% endcomment %}') @@ -61,60 +63,60 @@ class StandardTagTest < Minitest::Test def test_capture 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_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 } 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 } 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 } 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 } 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 } 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 } 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 +130,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 }}" 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 @@ -246,33 +248,33 @@ class StandardTagTest < Minitest::Test 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"%}') + '{%cycle "text-align: left", "text-align: right" %} {%cycle "text-align: left", "text-align: right"%}') end def test_multiple_cycles assert_template_result('1 2 1 1 2 3 1', - '{%cycle 1,2%} {%cycle 1,2%} {%cycle 1,2%} {%cycle 1,2,3%} {%cycle 1,2,3%} {%cycle 1,2,3%} {%cycle 1,2,3%}') + '{%cycle 1,2%} {%cycle 1,2%} {%cycle 1,2%} {%cycle 1,2,3%} {%cycle 1,2,3%} {%cycle 1,2,3%} {%cycle 1,2,3%}') end def test_multiple_named_cycles assert_template_result('one one two two one one', - '{%cycle 1: "one", "two" %} {%cycle 2: "one", "two" %} {%cycle 1: "one", "two" %} {%cycle 2: "one", "two" %} {%cycle 1: "one", "two" %} {%cycle 2: "one", "two" %}') + '{%cycle 1: "one", "two" %} {%cycle 2: "one", "two" %} {%cycle 1: "one", "two" %} {%cycle 2: "one", "two" %} {%cycle 1: "one", "two" %} {%cycle 2: "one", "two" %}') 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) + '{%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] } - assert_template_result('array has 4 elements', "array has {{ array.size }} elements", assigns) + 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 } } - assert_template_result('hash has 4 elements', "hash has {{ hash.size }} elements", assigns) + assigns = { 'hash' => { a: 1, b: 2, c: 3, d: 4 } } + assert_template_result('hash has 4 elements', 'hash has {{ hash.size }} elements', assigns) end def test_illegal_symbols @@ -283,10 +285,10 @@ class StandardTagTest < Minitest::Test end def test_ifchanged - assigns = { 'array' => [ 1, 1, 2, 2, 3, 3] } + 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] } + assigns = { 'array' => [1, 1, 1, 1] } assert_template_result('1', '{%for item in array%}{%ifchanged%}{{item}}{% endifchanged %}{%endfor%}', assigns) end diff --git a/test/integration/tags/statements_test.rb b/test/integration/tags/statements_test.rb index eeff166..0d024d0 100644 --- a/test/integration/tags/statements_test.rb +++ b/test/integration/tags/statements_test.rb @@ -1,3 +1,5 @@ +# frozen_string_literal: true + require 'test_helper' class StatementsTest < Minitest::Test diff --git a/test/integration/tags/table_row_test.rb b/test/integration/tags/table_row_test.rb index d7bc14c..11775c5 100644 --- a/test/integration/tags/table_row_test.rb +++ b/test/integration/tags/table_row_test.rb @@ -1,3 +1,5 @@ +# frozen_string_literal: true + require 'test_helper' class TableRowTest < Minitest::Test @@ -17,48 +19,48 @@ class TableRowTest < Minitest::Test def test_table_row assert_template_result("\n 1 2 3 \n 4 5 6 \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("\n\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("\n 1 2 3 4 5 \n 6 \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("\n12\n12\n12\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("\n 1 2 3 \n 4 5 6 \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("\n 1 2 3 \n 4 5 6 \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("\n 1 2 3 \n 4 5 6 \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("\n 1 2 3 \n 4 5 6 \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 def test_blank_string_not_iterable - assert_template_result("\n\n", "{% tablerow char in characters cols:3 %}I WILL NOT BE OUTPUT{% endtablerow %}", 'characters' => '') + assert_template_result("\n\n", '{% tablerow char in characters cols:3 %}I WILL NOT BE OUTPUT{% endtablerow %}', 'characters' => '') end end diff --git a/test/integration/tags/unless_else_tag_test.rb b/test/integration/tags/unless_else_tag_test.rb index c414a71..6ce49d4 100644 --- a/test/integration/tags/unless_else_tag_test.rb +++ b/test/integration/tags/unless_else_tag_test.rb @@ -1,3 +1,5 @@ +# frozen_string_literal: true + require 'test_helper' class UnlessElseTagTest < Minitest::Test @@ -6,7 +8,7 @@ class UnlessElseTagTest < Minitest::Test def test_unless 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 %} ') + ' {% 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 diff --git a/test/integration/template_test.rb b/test/integration/template_test.rb index 0dc0ae5..cb1f4a1 100644 --- a/test/integration/template_test.rb +++ b/test/integration/template_test.rb @@ -1,3 +1,5 @@ +# frozen_string_literal: true + require 'test_helper' require 'timeout' @@ -39,11 +41,11 @@ class TemplateTest < Minitest::Test def test_instance_assigns_persist_on_same_template_object_between_parses t = Template.new assert_equal 'from instance assigns', t.parse("{% assign foo = 'from instance assigns' %}{{ foo }}").render! - assert_equal 'from instance assigns', t.parse("{{ foo }}").render! + assert_equal 'from instance assigns', t.parse('{{ foo }}').render! end def test_warnings_is_not_exponential_time - str = "false" + str = 'false' 100.times do str = "{% if true %}true{% else %}#{str}{% endif %}" end @@ -60,82 +62,88 @@ class TemplateTest < Minitest::Test def test_custom_assigns_do_not_persist_on_same_template t = Template.new - assert_equal 'from custom assigns', t.parse("{{ foo }}").render!('foo' => 'from custom assigns') - assert_equal '', t.parse("{{ foo }}").render! + assert_equal 'from custom assigns', t.parse('{{ foo }}').render!('foo' => 'from custom assigns') + assert_equal '', t.parse('{{ foo }}').render! end def test_custom_assigns_squash_instance_assigns t = Template.new assert_equal 'from instance assigns', t.parse("{% assign foo = 'from instance assigns' %}{{ foo }}").render! - assert_equal 'from custom assigns', t.parse("{{ foo }}").render!('foo' => 'from custom assigns') + assert_equal 'from custom assigns', t.parse('{{ foo }}').render!('foo' => 'from custom assigns') end def test_persistent_assigns_squash_instance_assigns t = Template.new assert_equal 'from instance assigns', t.parse("{% assign foo = 'from instance assigns' %}{{ foo }}").render! t.assigns['foo'] = 'from persistent assigns' - assert_equal 'from persistent assigns', t.parse("{{ foo }}").render! + assert_equal 'from persistent assigns', t.parse('{{ foo }}').render! end def test_lambda_is_called_once_from_persistent_assigns_over_multiple_parses_and_renders t = Template.new - t.assigns['number'] = -> { @global ||= 0; @global += 1 } - assert_equal '1', t.parse("{{number}}").render! - assert_equal '1', t.parse("{{number}}").render! + 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! @global = nil end def test_lambda_is_called_once_from_custom_assigns_over_multiple_parses_and_renders t = Template.new - assigns = { 'number' => -> { @global ||= 0; @global += 1 } } - assert_equal '1', t.parse("{{number}}").render!(assigns) - assert_equal '1', t.parse("{{number}}").render!(assigns) + 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) @global = nil end def test_resource_limits_works_with_custom_length_method - t = Template.parse("{% assign foo = bar %}") + t = Template.parse('{% assign foo = bar %}') t.resource_limits.render_length_limit = 42 - assert_equal "", t.render!("bar" => SomethingWithLength.new) + assert_equal '', t.render!('bar' => SomethingWithLength.new) end def test_resource_limits_render_length - t = Template.parse("0123456789") + t = Template.parse('0123456789') t.resource_limits.render_length_limit = 5 - assert_equal "Liquid error: Memory limits exceeded", t.render + 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_equal '0123456789', t.render! refute_nil t.resource_limits.render_length end def test_resource_limits_render_score - t = Template.parse("{% for a in (1..10) %} {% for a in (1..10) %} foo {% endfor %} {% endfor %}") + 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_equal 'Liquid error: Memory limits exceeded', t.render assert t.resource_limits.reached? - t = Template.parse("{% for a in (1..100) %} foo {% endfor %}") + 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_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_equal (' foo ' * 100), t.render! refute_nil t.resource_limits.render_score end def test_resource_limits_assign_score - t = Template.parse("{% assign foo = 42 %}{% assign bar = 23 %}") + 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_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_equal '', t.render! refute_nil t.resource_limits.assign_score end @@ -144,7 +152,7 @@ class TemplateTest < Minitest::Test t.render assert_equal 9, t.resource_limits.assign_score - t = Template.parse("{% capture foo %}すごい{% endcapture %}") + t = Template.parse('{% capture foo %}すごい{% endcapture %}') t.render assert_equal 9, t.resource_limits.assign_score end @@ -153,65 +161,65 @@ class TemplateTest < Minitest::Test t = Template.parse("{% assign foo = 'aaaa' | reverse %}") t.resource_limits.assign_score_limit = 3 - assert_equal "Liquid error: Memory limits exceeded", t.render + assert_equal 'Liquid error: Memory limits exceeded', t.render assert t.resource_limits.reached? t.resource_limits.assign_score_limit = 5 - assert_equal "", t.render! + assert_equal '', t.render! 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 = 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_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 = 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 + assert t.resource_limits.assign_score.positive? + assert t.resource_limits.render_score.positive? + assert t.resource_limits.render_length.positive? end def test_render_length_persists_between_blocks - t = Template.parse("{% if true %}aaaa{% endif %}") + t = Template.parse('{% if true %}aaaa{% endif %}') t.resource_limits.render_length_limit = 7 - assert_equal "Liquid error: Memory limits exceeded", t.render + assert_equal 'Liquid error: Memory limits exceeded', t.render t.resource_limits.render_length_limit = 8 - assert_equal "aaaa", t.render + assert_equal 'aaaa', t.render - t = Template.parse("{% if true %}aaaa{% endif %}{% if true %}bbb{% endif %}") + 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 + assert_equal 'Liquid error: Memory limits exceeded', t.render t.resource_limits.render_length_limit = 14 - assert_equal "aaaabbb", t.render + 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 = 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 + 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 + assert_equal 'Liquid error: Memory limits exceeded', t.render t.resource_limits.render_length_limit = 12 - assert_equal "ababab", t.render + assert_equal 'ababab', t.render end def test_render_length_uses_number_of_bytes_not_characters - t = Template.parse("{% if true %}すごい{% endif %}") + t = Template.parse('{% if true %}すごい{% endif %}') t.resource_limits.render_length_limit = 10 - assert_equal "Liquid error: Memory limits exceeded", t.render + assert_equal 'Liquid error: Memory limits exceeded', t.render t.resource_limits.render_length_limit = 18 - assert_equal "すごい", t.render + assert_equal 'すごい', 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 = 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 + assert context.resource_limits.assign_score.positive? + assert context.resource_limits.render_score.positive? + assert context.resource_limits.render_length.positive? end def test_can_use_drop_as_context @@ -220,11 +228,11 @@ class TemplateTest < Minitest::Test drop = TemplateContextDrop.new assert_equal 'fizzbuzz', t.parse('{{foo}}').render!(drop) assert_equal 'bar', t.parse('{{bar}}').render!(drop) - assert_equal 'haha', t.parse("{{baz}}").render!(drop) + assert_equal 'haha', t.parse('{{baz}}').render!(drop) 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 @@ -235,9 +243,12 @@ class TemplateTest < Minitest::Test def test_exception_renderer_that_returns_string exception = nil - handler = ->(e) { exception = e; '' } + handler = lambda { |e| + exception = e + '' + } - output = Template.parse("{{ 1 | divided_by: 0 }}").render({}, exception_renderer: handler) + output = Template.parse('{{ 1 | divided_by: 0 }}').render({}, exception_renderer: handler) assert exception.is_a?(Liquid::ZeroDivisionError) assert_equal '', output @@ -246,28 +257,31 @@ class TemplateTest < Minitest::Test def test_exception_renderer_that_raises exception = nil assert_raises(Liquid::ZeroDivisionError) do - Template.parse("{{ 1 | divided_by: 0 }}").render({}, exception_renderer: ->(e) { exception = e; raise }) + Template.parse('{{ 1 | divided_by: 0 }}').render({}, exception_renderer: lambda { |e| + exception = e + raise + }) end assert exception.is_a?(Liquid::ZeroDivisionError) end def test_global_filter_option_on_render global_filter_proc = ->(output) { "#{output} filtered" } - rendered_template = Template.parse("{{name}}").render({ "name" => "bob" }, global_filter: global_filter_proc) + rendered_template = Template.parse('{{name}}').render({ 'name' => 'bob' }, global_filter: global_filter_proc) assert_equal 'bob filtered', rendered_template end def test_global_filter_option_when_native_filters_exist global_filter_proc = ->(output) { "#{output} filtered" } - rendered_template = Template.parse("{{name | upcase}}").render({ "name" => "bob" }, global_filter: global_filter_proc) + rendered_template = Template.parse('{{name | upcase}}').render({ 'name' => 'bob' }, global_filter: global_filter_proc) assert_equal 'BOB filtered', rendered_template end def test_undefined_variables - t = Template.parse("{{x}} {{y}} {{z.a}} {{z.b}} {{z.c.d}}") - result = t.render({ 'x' => 33, 'z' => { 'a' => 32, 'c' => { 'e' => 31 } } }, { strict_variables: true }) + t = Template.parse('{{x}} {{y}} {{z.a}} {{z.b}} {{z.c.d}}') + result = t.render({ 'x' => 33, 'z' => { 'a' => 32, 'c' => { 'e' => 31 } } }, strict_variables: true) assert_equal '33 32 ', result assert_equal 3, t.errors.count @@ -281,7 +295,7 @@ class TemplateTest < Minitest::Test def test_nil_value_does_not_raise Liquid::Template.error_mode = :strict - t = Template.parse("some{{x}}thing") + t = Template.parse('some{{x}}thing') result = t.render!({ 'x' => nil }, strict_variables: true) assert_equal 0, t.errors.count @@ -289,17 +303,17 @@ class TemplateTest < Minitest::Test end def test_undefined_variables_raise - t = Template.parse("{{x}} {{y}} {{z.a}} {{z.b}} {{z.c.d}}") + t = Template.parse('{{x}} {{y}} {{z.a}} {{z.b}} {{z.c.d}}') assert_raises UndefinedVariable do - t.render!({ 'x' => 33, 'z' => { 'a' => 32, 'c' => { 'e' => 31 } } }, { strict_variables: true }) + t.render!({ 'x' => 33, 'z' => { 'a' => 32, 'c' => { 'e' => 31 } } }, strict_variables: true) end end def test_undefined_drop_methods d = DropWithUndefinedMethod.new t = Template.new.parse('{{ foo }} {{ woot }}') - result = t.render(d, { strict_variables: true }) + result = t.render(d, strict_variables: true) assert_equal 'foo ', result assert_equal 1, t.errors.count @@ -311,18 +325,18 @@ class TemplateTest < Minitest::Test t = Template.new.parse('{{ foo }} {{ woot }}') assert_raises UndefinedDropMethod do - t.render!(d, { strict_variables: true }) + t.render!(d, strict_variables: true) end end def test_undefined_filters - t = Template.parse("{{a}} {{x | upcase | somefilter1 | somefilter2 | somefilter3}}") + t = Template.parse('{{a}} {{x | upcase | somefilter1 | somefilter2 | somefilter3}}') filters = Module.new do def somefilter3(v) "-#{v}-" end end - result = t.render({ 'a' => 123, 'x' => 'foo' }, { filters: [filters], strict_filters: true }) + result = t.render({ 'a' => 123, 'x' => 'foo' }, filters: [filters], strict_filters: true) assert_equal '123 ', result assert_equal 1, t.errors.count @@ -331,20 +345,20 @@ class TemplateTest < Minitest::Test end def test_undefined_filters_raise - t = Template.parse("{{x | somefilter1 | upcase | somefilter2}}") + t = Template.parse('{{x | somefilter1 | upcase | somefilter2}}') assert_raises UndefinedFilter do - t.render!({ 'x' => 'foo' }, { strict_filters: true }) + t.render!({ 'x' => 'foo' }, strict_filters: true) end end def test_using_range_literal_works_as_expected - t = Template.parse("{% assign foo = (x..y) %}{{ foo }}") - result = t.render({ 'x' => 1, 'y' => 5 }) + t = Template.parse('{% assign foo = (x..y) %}{{ foo }}') + result = t.render('x' => 1, 'y' => 5) assert_equal '1..5', result - t = Template.parse("{% assign nums = (x..y) %}{% for num in nums %}{{ num }}{% endfor %}") - result = t.render({ 'x' => 1, 'y' => 5 }) + t = Template.parse('{% assign nums = (x..y) %}{% for num in nums %}{{ num }}{% endfor %}') + result = t.render('x' => 1, 'y' => 5) assert_equal '12345', result end end diff --git a/test/integration/trim_mode_test.rb b/test/integration/trim_mode_test.rb index 52248cf..438f86b 100644 --- a/test/integration/trim_mode_test.rb +++ b/test/integration/trim_mode_test.rb @@ -1,3 +1,5 @@ +# frozen_string_literal: true + require 'test_helper' class TrimModeTest < Minitest::Test @@ -76,14 +78,14 @@ class TrimModeTest < Minitest::Test

END_TEMPLATE - expected = <<-END_EXPECTED -
-

-#{whitespace} - yes -#{whitespace} -

-
+ expected = <<~END_EXPECTED +
+

+ #{whitespace} + yes + #{whitespace} +

+
END_EXPECTED assert_template_result(expected, text) @@ -96,12 +98,12 @@ class TrimModeTest < Minitest::Test

END_TEMPLATE - expected = <<-END_EXPECTED -
-

-#{whitespace} -

-
+ expected = <<~END_EXPECTED +
+

+ #{whitespace} +

+
END_EXPECTED assert_template_result(expected, text) end @@ -337,12 +339,12 @@ class TrimModeTest < Minitest::Test

END_TEMPLATE - expected = <<-END_EXPECTED -
-

-#{whitespace} -

-
+ expected = <<~END_EXPECTED +
+

+ #{whitespace} +

+
END_EXPECTED assert_template_result(expected, text) end @@ -513,16 +515,16 @@ class TrimModeTest < Minitest::Test {% endraw %} END_TEMPLATE - expected = <<-END_EXPECTED -
-#{whitespace} - {%- if true -%} -

- {{- 'John' -}} -

- {%- endif -%} -#{whitespace} -
+ expected = <<~END_EXPECTED +
+ #{whitespace} + {%- if true -%} +

+ {{- 'John' -}} +

+ {%- endif -%} + #{whitespace} +
END_EXPECTED assert_template_result(expected, text) end diff --git a/test/integration/variable_test.rb b/test/integration/variable_test.rb index abd6e70..4a3fa7a 100644 --- a/test/integration/variable_test.rb +++ b/test/integration/variable_test.rb @@ -1,3 +1,5 @@ +# frozen_string_literal: true + require 'test_helper' class VariableTest < Minitest::Test @@ -25,12 +27,12 @@ class VariableTest < Minitest::Test end def test_using_blank_as_variable_name - template = Template.parse("{% assign foo = blank %}{{ foo }}") + template = Template.parse('{% assign foo = blank %}{{ foo }}') assert_equal '', template.render! end def test_using_empty_as_variable_name - template = Template.parse("{% assign foo = empty %}{{ foo }}") + template = Template.parse('{% assign foo = empty %}{{ foo }}') assert_equal '', template.render! end @@ -40,12 +42,12 @@ class VariableTest < Minitest::Test end def test_false_renders_as_false - assert_equal 'false', Template.parse("{{ foo }}").render!('foo' => false) - assert_equal 'false', Template.parse("{{ false }}").render! + 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 '', Template.parse('{{ nil }}').render! assert_equal 'cat', Template.parse("{{ nil | append: 'cat' }}").render! end @@ -76,7 +78,7 @@ class VariableTest < Minitest::Test def test_hash_with_default_proc template = Template.parse(%(Hello {{ test }})) - assigns = Hash.new { |h, k| raise "Unknown variable '#{k}'" } + assigns = Hash.new { |_h, k| raise "Unknown variable '#{k}'" } assigns['test'] = 'Tobi' assert_equal 'Hello Tobi', template.render!(assigns) assigns.delete('test') diff --git a/test/test_helper.rb b/test/test_helper.rb index 34e7553..df4af99 100755 --- a/test/test_helper.rb +++ b/test/test_helper.rb @@ -1,6 +1,7 @@ #!/usr/bin/env ruby +# frozen_string_literal: true -ENV["MT_NO_EXPECTATIONS"] = "1" +ENV['MT_NO_EXPECTATIONS'] = '1' require 'minitest/autorun' $LOAD_PATH.unshift(File.join(File.expand_path(__dir__), '..', 'lib')) @@ -8,14 +9,14 @@ require 'liquid.rb' require 'liquid/profiler' mode = :strict -if env_mode = ENV['LIQUID_PARSER_MODE'] +if (env_mode = ENV['LIQUID_PARSER_MODE']) puts "-- #{env_mode.upcase} ERROR MODE" mode = env_mode.to_sym end Liquid::Template.error_mode = mode -if ENV['LIQUID-C'] == '1' - puts "-- LIQUID C" +if ENV['LIQUID_C'] == '1' + puts '-- LIQUID C' require 'liquid/c' end @@ -29,7 +30,7 @@ end module Minitest class Test def fixture(name) - File.join(File.expand_path(__dir__), "fixtures", name) + File.join(File.expand_path(__dir__), 'fixtures', name) end end @@ -41,7 +42,7 @@ module Minitest end def assert_template_result_matches(expected, template, assigns = {}, message = nil) - return assert_template_result(expected, template, assigns, message) unless expected.is_a? Regexp + return assert_template_result(expected, template, assigns, message) unless expected.is_a?(Regexp) assert_match expected, Template.parse(template).render!(assigns), message end @@ -54,19 +55,19 @@ module Minitest 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 + original_global_strainer = Liquid::Strainer.instance_variable_get(:@global_strainer) + Liquid::Strainer.instance_variable_set(:@global_strainer, Class.new(Liquid::Strainer) do @filter_methods = Set.new end) - Liquid::Strainer.class_variable_get(:@@strainer_class_cache).clear + Liquid::Strainer.instance_variable_get(:@strainer_class_cache).clear globals.each do |global| Liquid::Template.register_filter(global) end yield ensure - Liquid::Strainer.class_variable_get(:@@strainer_class_cache).clear - Liquid::Strainer.class_variable_set(:@@global_strainer, original_global_strainer) + Liquid::Strainer.instance_variable_get(:@strainer_class_cache).clear + Liquid::Strainer.instance_variable_set(:@global_strainer, original_global_strainer) end def with_taint_mode(mode) diff --git a/test/unit/block_unit_test.rb b/test/unit/block_unit_test.rb index 9f7b94f..815ee77 100644 --- a/test/unit/block_unit_test.rb +++ b/test/unit/block_unit_test.rb @@ -1,29 +1,31 @@ +# frozen_string_literal: true + require 'test_helper' class BlockUnitTest < Minitest::Test include Liquid def test_blankspace - template = Liquid::Template.parse(" ") - assert_equal [" "], template.root.nodelist + template = Liquid::Template.parse(' ') + assert_equal [' '], template.root.nodelist end def test_variable_beginning - template = Liquid::Template.parse("{{funk}} ") + template = Liquid::Template.parse('{{funk}} ') assert_equal 2, template.root.nodelist.size assert_equal Variable, template.root.nodelist[0].class assert_equal String, template.root.nodelist[1].class end def test_variable_end - template = Liquid::Template.parse(" {{funk}}") + template = Liquid::Template.parse(' {{funk}}') assert_equal 2, template.root.nodelist.size assert_equal String, template.root.nodelist[0].class assert_equal Variable, template.root.nodelist[1].class end def test_variable_middle - template = Liquid::Template.parse(" {{funk}} ") + template = Liquid::Template.parse(' {{funk}} ') assert_equal 3, template.root.nodelist.size assert_equal String, template.root.nodelist[0].class assert_equal Variable, template.root.nodelist[1].class @@ -31,21 +33,21 @@ class BlockUnitTest < Minitest::Test end def test_variable_many_embedded_fragments - template = Liquid::Template.parse(" {{funk}} {{so}} {{brother}} ") + 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 - template = Liquid::Template.parse(" {% comment %} {% endcomment %} ") + template = Liquid::Template.parse(' {% comment %} {% endcomment %} ') assert_equal [String, Comment, String], block_types(template.root.nodelist) assert_equal 3, template.root.nodelist.size end def test_with_custom_tag with_custom_tag('testtag', Block) do - assert Liquid::Template.parse("{% testtag %} {% endtesttag %}") + assert Liquid::Template.parse('{% testtag %} {% endtesttag %}') end end @@ -57,11 +59,11 @@ class BlockUnitTest < Minitest::Test end with_custom_tag('blabla', klass1) do - template = Liquid::Template.parse("{% blabla %} bla {% endblabla %}") + template = Liquid::Template.parse('{% blabla %} bla {% endblabla %}') assert_equal 'hello', template.render - buf = '' + buf = ''.dup output = template.render({}, output: buf) assert_equal 'hello', output assert_equal 'hello', buf @@ -75,11 +77,11 @@ class BlockUnitTest < Minitest::Test end with_custom_tag('blabla', klass2) do - template = Liquid::Template.parse("{% blabla %} foo {% endblabla %}") + template = Liquid::Template.parse('{% blabla %} foo {% endblabla %}') assert_equal 'foohellobar', template.render - buf = '' + buf = ''.dup output = template.render({}, output: buf) assert_equal 'foohellobar', output assert_equal 'foohellobar', buf diff --git a/test/unit/condition_unit_test.rb b/test/unit/condition_unit_test.rb index b3b90e8..a4e376c 100644 --- a/test/unit/condition_unit_test.rb +++ b/test/unit/condition_unit_test.rb @@ -1,3 +1,5 @@ +# frozen_string_literal: true + require 'test_helper' class ConditionUnitTest < Minitest::Test @@ -24,9 +26,9 @@ class ConditionUnitTest < Minitest::Test assert_evaluates_true 1, '<=', 1 # negative numbers assert_evaluates_true 1, '>', -1 - assert_evaluates_true -1, '<', 1 + assert_evaluates_true(-1, '<', 1) assert_evaluates_true 1.0, '>', -1.0 - assert_evaluates_true -1.0, '<', 1.0 + assert_evaluates_true(-1.0, '<', 1.0) end def test_default_operators_evalute_false @@ -68,14 +70,14 @@ class ConditionUnitTest < Minitest::Test assert_nil Condition.new({}, '>', 2).evaluate assert_nil Condition.new(2, '>', {}).evaluate assert_equal false, Condition.new({}, '==', 2).evaluate - assert_equal true, Condition.new({ 'a' => 1 }, '==', { 'a' => 1 }).evaluate + assert_equal true, Condition.new({ 'a' => 1 }, '==', 'a' => 1).evaluate assert_equal true, Condition.new({ 'a' => 2 }, 'contains', 'a').evaluate end def test_contains_works_on_arrays @context = Liquid::Context.new @context['array'] = [1, 2, 3, 4, 5] - array_expr = VariableLookup.new("array") + array_expr = VariableLookup.new('array') assert_evaluates_false array_expr, 'contains', 0 assert_evaluates_true array_expr, 'contains', 1 @@ -84,7 +86,7 @@ class ConditionUnitTest < Minitest::Test assert_evaluates_true array_expr, 'contains', 4 assert_evaluates_true array_expr, 'contains', 5 assert_evaluates_false array_expr, 'contains', 6 - assert_evaluates_false array_expr, 'contains', "1" + assert_evaluates_false array_expr, 'contains', '1' end def test_contains_returns_false_for_nil_operands @@ -107,11 +109,11 @@ class ConditionUnitTest < Minitest::Test 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 @@ -121,41 +123,41 @@ class ConditionUnitTest < Minitest::Test 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 { |_cond, left, right| left =~ /^#{right}/ } assert_evaluates_true 'bob', 'starts_with', 'b' assert_evaluates_false 'bob', 'starts_with', 'o' ensure - Condition.operators.delete 'starts_with' + 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" + @context['one'] = @context['another'] = 'gnomeslab-and-or-liquid' - assert_evaluates_true VariableLookup.new("one"), '==', VariableLookup.new("another") + assert_evaluates_true VariableLookup.new('one'), '==', VariableLookup.new('another') end private def assert_evaluates_true(left, op, right) assert Condition.new(left, op, right).evaluate(@context), - "Evaluated false: #{left} #{op} #{right}" + "Evaluated false: #{left} #{op} #{right}" end def assert_evaluates_false(left, op, right) assert !Condition.new(left, op, right).evaluate(@context), - "Evaluated true: #{left} #{op} #{right}" + "Evaluated true: #{left} #{op} #{right}" end def assert_evaluates_argument_error(left, op, right) diff --git a/test/unit/context_unit_test.rb b/test/unit/context_unit_test.rb index fab19b8..eb7fd12 100644 --- a/test/unit/context_unit_test.rb +++ b/test/unit/context_unit_test.rb @@ -1,3 +1,5 @@ +# frozen_string_literal: true + require 'test_helper' class HundredCentes @@ -49,8 +51,7 @@ class CounterDrop < Liquid::Drop end class ArrayLike - def fetch(index) - end + def fetch(index); end def [](index) @counts ||= [] @@ -83,7 +84,7 @@ class ContextUnitTest < Minitest::Test @context['date'] = Date.today assert_equal Date.today, @context['date'] - now = DateTime.now + now = Time.now @context['datetime'] = now assert_equal now, @context['datetime'] @@ -162,10 +163,10 @@ class ContextUnitTest < Minitest::Test end context = Context.new - assert_equal "Wookie", context.invoke("hi", "Wookie") + assert_equal 'Wookie', context.invoke('hi', 'Wookie') context.add_filters(filter) - assert_equal "Wookie hi!", context.invoke("hi", "Wookie") + assert_equal 'Wookie hi!', context.invoke('hi', 'Wookie') end def test_add_item_in_outer_scope @@ -185,7 +186,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 @@ -201,14 +202,14 @@ class ContextUnitTest < Minitest::Test end def test_strings - assert_equal "hello!", @context['"hello!"'] - assert_equal "hello!", @context["'hello!'"] + assert_equal 'hello!', @context['"hello!"'] + assert_equal 'hello!', @context["'hello!'"] end def test_merge - @context.merge({ "test" => "test" }) + @context.merge('test' => 'test') assert_equal 'test', @context['test'] - @context.merge({ "test" => "newvalue", "foo" => "bar" }) + @context.merge('test' => 'newvalue', 'foo' => 'bar') assert_equal 'newvalue', @context['test'] assert_equal 'bar', @context['foo'] end @@ -235,10 +236,10 @@ class ContextUnitTest < Minitest::Test 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' => %w[003366 336699 6699CC 99CCFF], + 'Green' => %w[003300 336633 669966 99CC99], + 'Yellow' => %w[CC9900 FFCC00 FFFF99 FFFFCC], + 'Red' => %w[660000 993333 CC6666 FF9999], } assert_equal '003366', @context['colors.Blue[0]'] @@ -262,8 +263,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' => %w[deepsnow freestyle] } + @context['product'] = { 'variants' => [{ 'title' => 'draft151cm' }, { 'title' => 'element151cm' }] } assert_equal 5, @context['products["count"]'] assert_equal 'deepsnow', @context['products["tags"][0]'] @@ -285,7 +286,7 @@ class ContextUnitTest < Minitest::Test def test_access_hashes_with_hash_access_variables @context['var'] = 'tags' @context['nested'] = { 'var' => 'tags' } - @context['products'] = { 'count' => 5, 'tags' => ['deepsnow', 'freestyle'] } + @context['products'] = { 'count' => 5, 'tags' => %w[deepsnow freestyle] } assert_equal 'deepsnow', @context['products[var].first'] assert_equal 'freestyle', @context['products[nested.var].last'] @@ -301,7 +302,7 @@ 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'] @@ -310,55 +311,55 @@ class ContextUnitTest < Minitest::Test 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 @@ -391,7 +392,7 @@ class ContextUnitTest < Minitest::Test end def test_nested_lambda_as_variable - @context['dynamic'] = { "lambda" => proc { 'Hello' } } + @context['dynamic'] = { 'lambda' => proc { 'Hello' } } assert_equal 'Hello', @context['dynamic.lambda'] end @@ -403,7 +404,11 @@ class ContextUnitTest < Minitest::Test end def test_lambda_is_called_once - @context['callcount'] = proc { @global ||= 0; @global += 1; @global.to_s } + @context['callcount'] = proc { + @global ||= 0 + @global += 1 + @global.to_s + } assert_equal '1', @context['callcount'] assert_equal '1', @context['callcount'] @@ -413,7 +418,11 @@ class ContextUnitTest < Minitest::Test end def test_nested_lambda_is_called_once - @context['callcount'] = { "lambda" => proc { @global ||= 0; @global += 1; @global.to_s } } + @context['callcount'] = { 'lambda' => proc { + @global ||= 0 + @global += 1 + @global.to_s + } } assert_equal '1', @context['callcount.lambda'] assert_equal '1', @context['callcount.lambda'] @@ -423,7 +432,11 @@ 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]'] @@ -433,15 +446,15 @@ class ContextUnitTest < Minitest::Test end def test_access_to_context_from_proc - @context.registers[:magic] = 345392 + @context.registers[:magic] = 345_392 @context['magic'] = proc { @context.registers[:magic] } - assert_equal 345392, @context['magic'] + assert_equal 345_392, @context['magic'] end def test_to_liquid_and_context_at_first_level - @context['category'] = Category.new("foobar") + @context['category'] = Category.new('foobar') assert_kind_of CategoryDrop, @context['category'] assert_equal @context, @context['category'].context end @@ -453,7 +466,7 @@ class ContextUnitTest < Minitest::Test end def test_context_initialization_with_a_proc_in_environment - contx = Context.new([test: ->(c) { c['poutine'] }], { test: :foo }) + contx = Context.new([test: ->(c) { c['poutine'] }], test: :foo) assert contx assert_nil contx['poutine'] @@ -476,9 +489,7 @@ class ContextUnitTest < Minitest::Test private def assert_no_object_allocations - unless RUBY_ENGINE == 'ruby' - skip "stackprof needed to count object allocations" - end + skip 'stackprof needed to count object allocations' unless RUBY_ENGINE == 'ruby' require 'stackprof' profile = StackProf.run(mode: :object) do diff --git a/test/unit/file_system_unit_test.rb b/test/unit/file_system_unit_test.rb index 2c7250b..9077a5f 100644 --- a/test/unit/file_system_unit_test.rb +++ b/test/unit/file_system_unit_test.rb @@ -1,3 +1,5 @@ +# frozen_string_literal: true + require 'test_helper' class FileSystemUnitTest < Minitest::Test @@ -5,31 +7,31 @@ class FileSystemUnitTest < Minitest::Test def test_default assert_raises(FileSystemError) do - BlankFileSystem.new.read_template_file("dummy") + BlankFileSystem.new.read_template_file('dummy') 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/dir/_mypartial.liquid", file_system.full_path("dir/mypartial") + file_system = Liquid::LocalFileSystem.new('/some/path') + 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 - file_system.full_path("../dir/mypartial") + file_system.full_path('../dir/mypartial') end assert_raises(FileSystemError) do - file_system.full_path("/dir/../../dir/mypartial") + file_system.full_path('/dir/../../dir/mypartial') end assert_raises(FileSystemError) do - file_system.full_path("/etc/passwd") + 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/dir/mypartial.html", file_system.full_path("dir/mypartial") + file_system = Liquid::LocalFileSystem.new('/some/path', '%s.html') + 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 diff --git a/test/unit/i18n_unit_test.rb b/test/unit/i18n_unit_test.rb index b57500e..ba166f1 100644 --- a/test/unit/i18n_unit_test.rb +++ b/test/unit/i18n_unit_test.rb @@ -1,22 +1,24 @@ +# frozen_string_literal: true + require 'test_helper' class I18nUnitTest < Minitest::Test include Liquid def setup - @i18n = I18n.new(fixture("en_locale.yml")) + @i18n = I18n.new(fixture('en_locale.yml')) end def test_simple_translate_string - assert_equal "less is more", @i18n.translate("simple") + assert_equal 'less is more', @i18n.translate('simple') end def test_nested_translate_string - assert_equal "something wasn't right", @i18n.translate("errors.syntax.oops") + assert_equal "something wasn't right", @i18n.translate('errors.syntax.oops') end def test_single_string_interpolation - assert_equal "something different", @i18n.translate("whatever", something: "different") + assert_equal 'something different', @i18n.translate('whatever', something: 'different') end # def test_raises_translation_error_on_undefined_interpolation_key @@ -27,7 +29,7 @@ class I18nUnitTest < Minitest::Test def test_raises_unknown_translation assert_raises I18n::TranslationError do - @i18n.translate("doesnt_exist") + @i18n.translate('doesnt_exist') end end diff --git a/test/unit/lexer_unit_test.rb b/test/unit/lexer_unit_test.rb index 5adcf2b..9c913d9 100644 --- a/test/unit/lexer_unit_test.rb +++ b/test/unit/lexer_unit_test.rb @@ -1,3 +1,5 @@ +# frozen_string_literal: true + require 'test_helper' class LexerUnitTest < Minitest::Test @@ -45,7 +47,7 @@ class LexerUnitTest < Minitest::Test def test_unexpected_character assert_raises(SyntaxError) do - Lexer.new("%").tokenize + Lexer.new('%').tokenize end end end diff --git a/test/unit/parser_unit_test.rb b/test/unit/parser_unit_test.rb index 9f23337..da6e1f5 100644 --- a/test/unit/parser_unit_test.rb +++ b/test/unit/parser_unit_test.rb @@ -1,23 +1,25 @@ +# frozen_string_literal: true + require 'test_helper' class ParserUnitTest < Minitest::Test include Liquid def test_consume - p = Parser.new("wat: 7") + p = Parser.new('wat: 7') assert_equal 'wat', p.consume(:id) assert_equal ':', p.consume(:colon) assert_equal '7', p.consume(:number) end def test_jump - p = Parser.new("wat: 7") + p = Parser.new('wat: 7') p.jump(2) assert_equal '7', p.consume(:number) end def test_consume? - p = Parser.new("wat: 7") + p = Parser.new('wat: 7') assert_equal 'wat', p.consume?(:id) assert_equal false, p.consume?(:dot) assert_equal ':', p.consume(:colon) @@ -25,7 +27,7 @@ class ParserUnitTest < Minitest::Test end def test_id? - p = Parser.new("wat 6 Peter Hegemon") + p = Parser.new('wat 6 Peter Hegemon') assert_equal 'wat', p.id?('wat') assert_equal false, p.id?('endgame') assert_equal '6', p.consume(:number) @@ -34,7 +36,7 @@ class ParserUnitTest < Minitest::Test end def test_look - p = Parser.new("wat 6 Peter Hegemon") + p = Parser.new('wat 6 Peter Hegemon') assert_equal true, p.look(:id) assert_equal 'wat', p.consume(:id) assert_equal false, p.look(:comparison) @@ -44,7 +46,7 @@ class ParserUnitTest < Minitest::Test end def test_expressions - p = Parser.new("hi.there hi?[5].there? hi.there.bob") + p = Parser.new('hi.there hi?[5].there? hi.there.bob') assert_equal 'hi.there', p.expression assert_equal 'hi?[5].there?', p.expression assert_equal 'hi.there.bob', p.expression @@ -57,7 +59,7 @@ class ParserUnitTest < Minitest::Test end def test_ranges - p = Parser.new("(5..7) (1.5..9.6) (young..old) (hi[5].wat..old)") + p = Parser.new('(5..7) (1.5..9.6) (young..old) (hi[5].wat..old)') assert_equal '(5..7)', p.expression assert_equal '(1.5..9.6)', p.expression assert_equal '(young..old)', p.expression @@ -65,7 +67,7 @@ class ParserUnitTest < Minitest::Test end def test_arguments - p = Parser.new("filter: hi.there[5], keyarg: 7") + p = Parser.new('filter: hi.there[5], keyarg: 7') assert_equal 'filter', p.consume(:id) assert_equal ':', p.consume(:colon) assert_equal 'hi.there[5]', p.argument @@ -75,7 +77,7 @@ class ParserUnitTest < Minitest::Test def test_invalid_expression assert_raises(SyntaxError) do - p = Parser.new("==") + p = Parser.new('==') p.expression end end diff --git a/test/unit/regexp_unit_test.rb b/test/unit/regexp_unit_test.rb index 0821229..abb6db4 100644 --- a/test/unit/regexp_unit_test.rb +++ b/test/unit/regexp_unit_test.rb @@ -1,44 +1,46 @@ +# frozen_string_literal: true + require 'test_helper' class RegexpUnitTest < Minitest::Test include Liquid def test_empty - assert_equal [], ''.scan(QuotedFragment) + assert_equal [], ''.scan(QUOTED_FRAGMENT) end def test_quote - assert_equal ['"arg 1"'], '"arg 1"'.scan(QuotedFragment) + assert_equal ['"arg 1"'], '"arg 1"'.scan(QUOTED_FRAGMENT) end def test_words - assert_equal ['arg1', 'arg2'], 'arg1 arg2'.scan(QuotedFragment) + assert_equal %w[arg1 arg2], 'arg1 arg2'.scan(QUOTED_FRAGMENT) end def test_tags - assert_equal ['', ''], ' '.scan(QuotedFragment) - assert_equal [''], ''.scan(QuotedFragment) - assert_equal ['', ''], %().scan(QuotedFragment) + assert_equal ['', ''], ' '.scan(QUOTED_FRAGMENT) + assert_equal [''], ''.scan(QUOTED_FRAGMENT) + assert_equal ['', ''], %().scan(QUOTED_FRAGMENT) end def test_double_quoted_words - assert_equal ['arg1', 'arg2', '"arg 3"'], 'arg1 arg2 "arg 3"'.scan(QuotedFragment) + assert_equal ['arg1', 'arg2', '"arg 3"'], 'arg1 arg2 "arg 3"'.scan(QUOTED_FRAGMENT) end def test_single_quoted_words - assert_equal ['arg1', 'arg2', "'arg 3'"], 'arg1 arg2 \'arg 3\''.scan(QuotedFragment) + assert_equal ['arg1', 'arg2', "'arg 3'"], 'arg1 arg2 \'arg 3\''.scan(QUOTED_FRAGMENT) end def test_quoted_words_in_the_middle - assert_equal ['arg1', 'arg2', '"arg 3"', 'arg4'], 'arg1 arg2 "arg 3" arg4 '.scan(QuotedFragment) + assert_equal ['arg1', 'arg2', '"arg 3"', 'arg4'], 'arg1 arg2 "arg 3" arg4 '.scan(QUOTED_FRAGMENT) end def test_variable_parser - assert_equal ['var'], 'var'.scan(VariableParser) - assert_equal ['var', 'method'], 'var.method'.scan(VariableParser) - assert_equal ['var', '[method]'], 'var[method]'.scan(VariableParser) - assert_equal ['var', '[method]', '[0]'], 'var[method][0]'.scan(VariableParser) - assert_equal ['var', '["method"]', '[0]'], 'var["method"][0]'.scan(VariableParser) - assert_equal ['var', '[method]', '[0]', 'method'], 'var[method][0].method'.scan(VariableParser) + assert_equal ['var'], 'var'.scan(VARIABLE_PARSER) + assert_equal %w[var method], 'var.method'.scan(VARIABLE_PARSER) + assert_equal ['var', '[method]'], 'var[method]'.scan(VARIABLE_PARSER) + assert_equal ['var', '[method]', '[0]'], 'var[method][0]'.scan(VARIABLE_PARSER) + assert_equal ['var', '["method"]', '[0]'], 'var["method"][0]'.scan(VARIABLE_PARSER) + assert_equal ['var', '[method]', '[0]', 'method'], 'var[method][0].method'.scan(VARIABLE_PARSER) end end # RegexpTest diff --git a/test/unit/strainer_unit_test.rb b/test/unit/strainer_unit_test.rb index 5ce2100..67b4528 100644 --- a/test/unit/strainer_unit_test.rb +++ b/test/unit/strainer_unit_test.rb @@ -1,3 +1,5 @@ +# frozen_string_literal: true + require 'test_helper' class StrainerUnitTest < Minitest::Test @@ -5,11 +7,11 @@ class StrainerUnitTest < Minitest::Test module AccessScopeFilters def public_filter - "public" + 'public' end def private_filter - "private" + 'private' end private :private_filter end @@ -19,24 +21,25 @@ class StrainerUnitTest < Minitest::Test def test_strainer strainer = Strainer.create(nil) assert_equal 5, strainer.invoke('size', 'input') - assert_equal "public", strainer.invoke("public_filter") + assert_equal 'public', strainer.invoke('public_filter') end def test_stainer_raises_argument_error strainer = Strainer.create(nil) assert_raises(Liquid::ArgumentError) do - strainer.invoke("public_filter", 1) + strainer.invoke('public_filter', 1) end end def test_stainer_argument_error_contains_backtrace strainer = Strainer.create(nil) begin - strainer.invoke("public_filter", 1) + strainer.invoke('public_filter', 1) rescue Liquid::ArgumentError => e assert_match( /\ALiquid error: wrong number of arguments \((1 for 0|given 1, expected 0)\)\z/, - e.message) + e.message + ) assert_equal e.backtrace[0].split(':')[0], __FILE__ end end @@ -52,20 +55,20 @@ class StrainerUnitTest < Minitest::Test def test_strainer_returns_nil_if_no_filter_method_found strainer = Strainer.create(nil) - assert_nil strainer.invoke("private_filter") - assert_nil strainer.invoke("undef_the_filter") + assert_nil strainer.invoke('private_filter') + assert_nil strainer.invoke('undef_the_filter') end def test_strainer_returns_first_argument_if_no_method_and_arguments_given strainer = Strainer.create(nil) - assert_equal "password", strainer.invoke("undef_the_method", "password") + assert_equal 'password', strainer.invoke('undef_the_method', 'password') end def test_strainer_only_allows_methods_defined_in_filters strainer = Strainer.create(nil) - assert_equal "1 + 1", strainer.invoke("instance_eval", "1 + 1") - assert_equal "puts", strainer.invoke("__send__", "puts", "Hi Mom") - assert_equal "has_method?", strainer.invoke("invoke", "has_method?", "invoke") + assert_equal '1 + 1', strainer.invoke('instance_eval', '1 + 1') + assert_equal 'puts', strainer.invoke('__send__', 'puts', 'Hi Mom') + assert_equal 'has_method?', strainer.invoke('invoke', 'has_method?', 'invoke') end def test_strainer_uses_a_class_cache_to_avoid_method_cache_invalidation @@ -92,7 +95,7 @@ class StrainerUnitTest < Minitest::Test private def public_filter - "overriden as private" + 'overriden as private' end end @@ -109,7 +112,7 @@ class StrainerUnitTest < Minitest::Test protected def public_filter - "overriden as protected" + 'overriden as protected' end end @@ -124,7 +127,7 @@ class StrainerUnitTest < Minitest::Test module PublicMethodOverrideFilter def public_filter - "public" + 'public' end end @@ -135,8 +138,8 @@ class StrainerUnitTest < Minitest::Test end module LateAddedFilter - def late_added_filter(input) - "filtered" + def late_added_filter(_input) + 'filtered' end end @@ -150,7 +153,7 @@ class StrainerUnitTest < Minitest::Test mod = Module.new do class << self attr_accessor :include_count - def included(mod) + def included(_mod) self.include_count += 1 end end diff --git a/test/unit/tag_unit_test.rb b/test/unit/tag_unit_test.rb index a3fb40e..4191118 100644 --- a/test/unit/tag_unit_test.rb +++ b/test/unit/tag_unit_test.rb @@ -1,21 +1,23 @@ +# frozen_string_literal: true + require 'test_helper' class TagUnitTest < Minitest::Test include Liquid def test_tag - tag = Tag.parse('tag', "", Tokenizer.new(""), ParseContext.new) + tag = Tag.parse('tag', '', Tokenizer.new(''), ParseContext.new) assert_equal 'liquid::tag', tag.name assert_equal '', tag.render(Context.new) end def test_return_raw_text_of_tag - tag = Tag.parse("long_tag", "param1, param2, param3", Tokenizer.new(""), ParseContext.new) - assert_equal("long_tag param1, param2, param3", tag.raw) + tag = Tag.parse('long_tag', 'param1, param2, param3', Tokenizer.new(''), ParseContext.new) + assert_equal('long_tag param1, param2, param3', tag.raw) end def test_tag_name_should_return_name_of_the_tag - tag = Tag.parse("some_tag", "", Tokenizer.new(""), ParseContext.new) + tag = Tag.parse('some_tag', '', Tokenizer.new(''), ParseContext.new) assert_equal 'some_tag', tag.tag_name end @@ -27,11 +29,11 @@ class TagUnitTest < Minitest::Test end with_custom_tag('blabla', klass1) do - template = Liquid::Template.parse("{% blabla %}") + template = Liquid::Template.parse('{% blabla %}') assert_equal 'hello', template.render - buf = '' + buf = ''.dup output = template.render({}, output: buf) assert_equal 'hello', output assert_equal 'hello', buf @@ -45,11 +47,11 @@ class TagUnitTest < Minitest::Test end with_custom_tag('blabla', klass2) do - template = Liquid::Template.parse("{% blabla %}") + template = Liquid::Template.parse('{% blabla %}') assert_equal 'foohellobar', template.render - buf = '' + buf = ''.dup output = template.render({}, output: buf) assert_equal 'foohellobar', output assert_equal 'foohellobar', buf diff --git a/test/unit/tags/case_tag_unit_test.rb b/test/unit/tags/case_tag_unit_test.rb index 7110308..a8bdfef 100644 --- a/test/unit/tags/case_tag_unit_test.rb +++ b/test/unit/tags/case_tag_unit_test.rb @@ -1,3 +1,5 @@ +# frozen_string_literal: true + require 'test_helper' class CaseTagUnitTest < Minitest::Test @@ -5,6 +7,6 @@ class CaseTagUnitTest < Minitest::Test def test_case_nodelist template = Liquid::Template.parse('{% case var %}{% when true %}WHEN{% else %}ELSE{% endcase %}') - assert_equal ['WHEN', 'ELSE'], template.root.nodelist[0].nodelist.map(&:nodelist).flatten + assert_equal %w[WHEN ELSE], template.root.nodelist[0].nodelist.map(&:nodelist).flatten end end diff --git a/test/unit/tags/for_tag_unit_test.rb b/test/unit/tags/for_tag_unit_test.rb index b8fc520..4205541 100644 --- a/test/unit/tags/for_tag_unit_test.rb +++ b/test/unit/tags/for_tag_unit_test.rb @@ -1,3 +1,5 @@ +# frozen_string_literal: true + require 'test_helper' class ForTagUnitTest < Minitest::Test @@ -8,6 +10,6 @@ class ForTagUnitTest < Minitest::Test def test_for_else_nodelist template = Liquid::Template.parse('{% for item in items %}FOR{% else %}ELSE{% endfor %}') - assert_equal ['FOR', 'ELSE'], template.root.nodelist[0].nodelist.map(&:nodelist).flatten + assert_equal %w[FOR ELSE], template.root.nodelist[0].nodelist.map(&:nodelist).flatten end end diff --git a/test/unit/tags/if_tag_unit_test.rb b/test/unit/tags/if_tag_unit_test.rb index 7ecfc40..39eb13a 100644 --- a/test/unit/tags/if_tag_unit_test.rb +++ b/test/unit/tags/if_tag_unit_test.rb @@ -1,8 +1,10 @@ +# frozen_string_literal: true + require 'test_helper' class IfTagUnitTest < Minitest::Test def test_if_nodelist template = Liquid::Template.parse('{% if true %}IF{% else %}ELSE{% endif %}') - assert_equal ['IF', 'ELSE'], template.root.nodelist[0].nodelist.map(&:nodelist).flatten + assert_equal(%w[IF ELSE], template.root.nodelist[0].nodelist.map(&:nodelist).flatten) end end diff --git a/test/unit/template_unit_test.rb b/test/unit/template_unit_test.rb index 6328be5..94ccef0 100644 --- a/test/unit/template_unit_test.rb +++ b/test/unit/template_unit_test.rb @@ -1,3 +1,5 @@ +# frozen_string_literal: true + require 'test_helper' class TemplateUnitTest < Minitest::Test @@ -11,11 +13,11 @@ class TemplateUnitTest < Minitest::Test def test_sets_default_localization_in_context_with_quick_initialization t = Template.new - t.parse('{%comment%}{%endcomment%}', locale: I18n.new(fixture("en_locale.yml"))) + t.parse('{%comment%}{%endcomment%}', locale: I18n.new(fixture('en_locale.yml'))) locale = t.root.nodelist[0].options[:locale] assert_instance_of I18n, locale - assert_equal fixture("en_locale.yml"), locale.path + assert_equal fixture('en_locale.yml'), locale.path end def test_with_cache_classes_tags_returns_the_same_class @@ -71,7 +73,7 @@ class TemplateUnitTest < Minitest::Test def test_tags_can_be_looped_over Template.register_tag('fake', FakeTag) result = Template.tags.map { |name, klass| [name, klass] } - assert result.include?(["fake", "TemplateUnitTest::FakeTag"]) + assert result.include?(['fake', 'TemplateUnitTest::FakeTag']) ensure Template.tags.delete('fake') end diff --git a/test/unit/tokenizer_unit_test.rb b/test/unit/tokenizer_unit_test.rb index de84c1f..77452fd 100644 --- a/test/unit/tokenizer_unit_test.rb +++ b/test/unit/tokenizer_unit_test.rb @@ -1,3 +1,5 @@ +# frozen_string_literal: true + require 'test_helper' class TokenizerTest < Minitest::Test @@ -18,12 +20,12 @@ class TokenizerTest < Minitest::Test assert_equal [' ', '{%comment%}', ' '], tokenize(' {%comment%} ') assert_equal [' ', '{%comment%}', ' ', '{%endcomment%}', ' '], tokenize(' {%comment%} {%endcomment%} ') - assert_equal [' ', '{% comment %}', ' ', '{% endcomment %}', ' '], tokenize(" {% comment %} {% endcomment %} ") + assert_equal [' ', '{% comment %}', ' ', '{% endcomment %}', ' '], tokenize(' {% comment %} {% endcomment %} ') end def test_calculate_line_numbers_per_token_with_profiling - assert_equal [1], tokenize_line_numbers("{{funk}}") - assert_equal [1, 1, 1], tokenize_line_numbers(" {{funk}} ") + assert_equal [1], tokenize_line_numbers('{{funk}}') + assert_equal [1, 1, 1], tokenize_line_numbers(' {{funk}} ') assert_equal [1, 2, 2], tokenize_line_numbers("\n{{funk}}\n") assert_equal [1, 1, 3], tokenize_line_numbers(" {{\n funk \n}} ") end @@ -33,7 +35,7 @@ class TokenizerTest < Minitest::Test def tokenize(source) tokenizer = Liquid::Tokenizer.new(source) tokens = [] - while t = tokenizer.shift + while (t = tokenizer.shift) tokens << t end tokens diff --git a/test/unit/variable_unit_test.rb b/test/unit/variable_unit_test.rb index 5a21ace..0bf4942 100644 --- a/test/unit/variable_unit_test.rb +++ b/test/unit/variable_unit_test.rb @@ -1,3 +1,5 @@ +# frozen_string_literal: true + require 'test_helper' class VariableUnitTest < Minitest::Test @@ -67,7 +69,7 @@ class VariableUnitTest < Minitest::Test var = create_variable("hello|replace:'foo','bar'|textileze") assert_equal VariableLookup.new('hello'), var.name - assert_equal [['replace', ['foo', 'bar']], ['textileze', []]], var.filters + assert_equal [['replace', %w[foo bar]], ['textileze', []]], var.filters end def test_symbol @@ -132,7 +134,7 @@ class VariableUnitTest < Minitest::Test def test_lax_filter_argument_parsing var = create_variable(%( number_of_comments | pluralize: 'comment': 'comments' ), error_mode: :lax) assert_equal VariableLookup.new('number_of_comments'), var.name - assert_equal [['pluralize', ['comment', 'comments']]], var.filters + assert_equal [['pluralize', %w[comment comments]]], var.filters end def test_strict_filter_argument_parsing @@ -145,13 +147,13 @@ class VariableUnitTest < Minitest::Test def test_output_raw_source_of_variable var = create_variable(%( name_of_variable | upcase )) - assert_equal " name_of_variable | upcase ", var.raw + assert_equal ' name_of_variable | upcase ', var.raw end def test_variable_lookup_interface lookup = VariableLookup.new('a.b.c') assert_equal 'a', lookup.name - assert_equal ['b', 'c'], lookup.lookups + assert_equal %w[b c], lookup.lookups end private