shopify_liquid_test_helper 0.1.0

checksums.yaml

@@ -0,0 +1,7 @@
+---
+SHA256:
+  metadata.gz: 78ab883c518d4cb5d8e2bee3c6cb8c4f65781724f3d5e7e093f55b5e108e041c
+  data.tar.gz: 1d1d92e1d5e717b655152a320bcbb69cc72eebc111756d0e4f969af1a97c5e45
+SHA512:
+  metadata.gz: 6559b4229c6fa3ef893499b7bc4d397d9dc270d840b1b33e9871004b84549857e1e646d272f0c2a9719d0db71f324d5b4eb06940702b126f49f8f9bf1992b3c3
+  data.tar.gz: a1aa6a1ed00f58fc7648aec4e625417ad59f2fe9fefd64f93c05535cda798af44d1eeb599439f7cc98ab27d2b89eaa8c2216f04811f4ced877e922aec4101053

data/README.md

@@ -0,0 +1,215 @@
+# ShopifyLiquidTestHelper
+
+ShopifyLiquidTestHelper is a Ruby gem designed to assist in testing Shopify Liquid templates. It provides custom Liquid tags and helper methods that simulate Shopify-specific functionality, making it easier to test your Liquid templates in isolation.
+
+## Installation
+
+Add this line to your application's Gemfile:
+
+```ruby
+gem 'shopify_liquid_test_helper'
+```
+
+And then execute:
+
+```
+$ bundle install
+```
+
+Or install it yourself as:
+
+```
+$ gem install shopify_liquid_test_helper
+```
+
+## Usage with RSpec
+
+### Setup
+
+In your `spec_helper.rb` or at the beginning of your test file, require and configure the helper:
+
+```ruby
+require 'shopify_liquid_test_helper'
+
+RSpec.configure do |config|
+  config.before(:each) do
+    ShopifyLiquidTestHelper.register_custom_tags
+  end
+end
+```
+
+### Testing Liquid Templates
+
+Here are some examples of how you can use ShopifyLiquidTestHelper in your RSpec tests:
+
+1. Testing a simple render tag:
+
+```ruby
+RSpec.describe "Product template" do
+  before do
+    ShopifyLiquidTestHelper.register_snippet('product_title', '<h1>{{ product.title }}</h1>')
+  end
+
+  it "renders the product title" do
+    template = "{% render 'product_title' %}"
+    assigns = { 'product' => { 'title' => 'Awesome T-Shirt' } }
+    result = ShopifyLiquidTestHelper.render_template(Liquid::Template.parse(template), assigns)
+    expect(result).to eq '<h1>Awesome T-Shirt</h1>'
+  end
+end
+```
+
+2. Testing a for loop in a render tag:
+
+```ruby
+RSpec.describe "Collection template" do
+  before do
+    ShopifyLiquidTestHelper.register_snippet('product_list', '{% for product in products %}{{ product.title }}{% endfor %}')
+  end
+
+  it "renders a list of product titles" do
+    template = "{% render 'product_list' for products %}"
+    assigns = { 'products' => [{ 'title' => 'Shirt' }, { 'title' => 'Pants' }] }
+    result = ShopifyLiquidTestHelper.render_template(Liquid::Template.parse(template), assigns)
+    expect(result).to eq 'ShirtPants'
+  end
+end
+```
+
+3. Testing the capture tag:
+
+```ruby
+RSpec.describe "Capture tag" do
+  it "captures content into a variable" do
+    template = "{% capture my_variable %}Hello, {{ name }}!{% endcapture %}{{ my_variable }}"
+    assigns = { 'name' => 'World' }
+    result = ShopifyLiquidTestHelper.render_template(Liquid::Template.parse(template), assigns)
+    expect(result).to eq 'Hello, World!'
+  end
+end
+```
+
+### Loading Snippets from Directory
+
+ShopifyLiquidTestHelper can load snippets from a specific directory. By default, it looks for snippets in a `snippets` directory relative to your current working directory. You can use this feature as follows:
+
+1. Create a `snippets` directory in your project:
+
+```
+mkdir snippets
+```
+
+2. Add your Liquid snippet files to this directory. For example, create a file named `product_card.liquid`:
+
+```liquid
+<!-- snippets/product_card.liquid -->
+<div class="product-card">
+  <h2>{{ product.title }}</h2>
+  <p>Price: {{ product.price | money }}</p>
+</div>
+```
+
+3. In your tests, you can now render this snippet:
+
+```ruby
+RSpec.describe "Product listing" do
+  it "renders a product card" do
+    template = "{% render 'product_card' %}"
+    assigns = {
+      'product' => {
+        'title' => 'Awesome T-Shirt',
+        'price' => 1999
+      }
+    }
+    result = ShopifyLiquidTestHelper.render_template(Liquid::Template.parse(template), assigns)
+    expect(result).to include('Awesome T-Shirt')
+    expect(result).to include('Price: $19.99')
+  end
+end
+```
+
+ShopifyLiquidTestHelper will automatically load the `product_card` snippet from the `snippets` directory when you use the `render` tag in your Liquid template.
+
+### Customizing the Snippets Directory
+
+If your snippets are located in a different directory, you can specify the path when initializing ShopifyLiquidTestHelper:
+
+```ruby
+ShopifyLiquidTestHelper.snippets_dir = 'path/to/your/snippets'
+```
+
+This allows you to organize your snippets in a way that best fits your project structure.
+
+### Combining Registered and File-based Snippets
+
+You can use both registered snippets (using `ShopifyLiquidTestHelper.register_snippet`) and file-based snippets in the same test suite. ShopifyLiquidTestHelper will first check for registered snippets, and if not found, it will look for a matching file in the snippets directory.
+
+```ruby
+RSpec.describe "Mixed snippet sources" do
+  before do
+    ShopifyLiquidTestHelper.register_snippet('inline_snippet', 'This is an inline snippet')
+  end
+
+  it "renders both registered and file-based snippets" do
+    template = """
+      {% render 'inline_snippet' %}
+      {% render 'product_card' %}
+    """
+    assigns = {
+      'product' => {
+        'title' => 'Cool Product',
+        'price' => 2499
+      }
+    }
+    result = ShopifyLiquidTestHelper.render_template(Liquid::Template.parse(template), assigns)
+    expect(result).to include('This is an inline snippet')
+    expect(result).to include('Cool Product')
+    expect(result).to include('Price: $24.99')
+  end
+end
+```
+
+### Advanced Usage
+
+For more complex scenarios, you can create helper methods in your specs to simplify template rendering:
+
+```ruby
+def render_template(template, assigns = {})
+  Liquid::Template.parse(template).render(assigns)
+end
+
+RSpec.describe "Complex template" do
+  it "renders a complex structure" do
+    template = """
+      {% render 'header' %}
+      {% for product in collection.products %}
+        {% render 'product_card' %}
+      {% endfor %}
+      {% render 'footer' %}
+    """
+    assigns = {
+      'collection' => {
+        'products' => [
+          { 'title' => 'Product 1', 'price' => 19.99 },
+          { 'title' => 'Product 2', 'price' => 24.99 }
+        ]
+      }
+    }
+    result = render_template(template, assigns)
+    expect(result).to include('Product 1')
+    expect(result).to include('Product 2')
+    expect(result).to include('19.99')
+    expect(result).to include('24.99')
+  end
+end
+```
+
+This gem allows you to test your Shopify Liquid templates thoroughly, ensuring they render correctly with various inputs and scenarios.
+
+## Contributing
+
+Bug reports and pull requests are welcome on GitHub at https://github.com/yourusername/shopify_liquid_test_helper.
+
+## License
+
+The gem is available as open source under the terms of the [MIT License](https://opensource.org/licenses/MIT).

data/Rakefile

@@ -0,0 +1,6 @@
+require 'bundler/gem_tasks'
+require 'rspec/core/rake_task'
+
+RSpec::Core::RakeTask.new(:spec)
+
+task default: :spec

data/lib/shopify_liquid_test_helper/capture_tag.rb

@@ -0,0 +1,14 @@
+module ShopifyLiquidTestHelper
+  class CaptureTag < Liquid::Block
+    def initialize(tag_name, markup, tokens)
+      super
+      @variable_name = markup.strip
+    end
+
+    def render(context)
+      result = super
+      context.scopes.last[@variable_name] = result
+      ''
+    end
+  end
+end

data/lib/shopify_liquid_test_helper/render_tag.rb

@@ -0,0 +1,107 @@
+module ShopifyLiquidTestHelper
+  class RenderTag < Liquid::Tag
+    SYNTAX = /(#{Liquid::QuotedFragment}+)(\s+(?:with|for)\s+(#{Liquid::QuotedFragment}+))?(\s+as\s+(#{Liquid::QuotedFragment}+))?/o
+
+    def initialize(tag_name, markup, tokens)
+      super
+      parse_markup(markup)
+      @params = extract_params(markup)
+    end
+
+    def render(context)
+      snippet_name = resolve_snippet_name(context)
+      snippet = fetch_snippet(snippet_name)
+
+      temp_context = create_isolated_context(context)
+      variable = resolve_variable(context)
+
+      if @for_loop
+        render_for_loop(snippet, variable, temp_context)
+      else
+        render_with_variable(snippet, variable, temp_context)
+      end
+    end
+
+    private
+
+    def parse_markup(markup)
+      unless markup =~ SYNTAX
+        raise Liquid::SyntaxError,
+              "Syntax Error in 'render' - Valid syntax: render 'snippet' [with object|for array] [as alias]"
+      end
+
+      @snippet_name = ::Regexp.last_match(1)
+      @variable_name = ::Regexp.last_match(3)
+      @alias = ::Regexp.last_match(5)
+      @for_loop = ::Regexp.last_match(2) =~ /\s+for\s+/
+    end
+
+    def extract_params(markup)
+      params = {}
+      markup.scan(Liquid::TagAttributes) { |key, value| params[key] = value }
+      params
+    end
+
+    def resolve_snippet_name(context)
+      snippet_name = context[@snippet_name] || @snippet_name
+      snippet_name.gsub(/['"]/, '')
+    end
+
+    def fetch_snippet(snippet_name)
+      snippet = ShopifyLiquidTestHelper.get_snippet(snippet_name)
+      raise Liquid::SyntaxError, "Unknown snippet '#{snippet_name}'" unless snippet
+
+      snippet
+    end
+
+    def resolve_variable(context)
+      @variable_name ? context[@variable_name] : nil
+    end
+
+    def render_for_loop(snippet, array, context)
+      return unless array.respond_to?(:each)
+
+      array.each_with_index.map do |item, index|
+        item_context = create_item_context(context, item, index, array.size)
+        Liquid::Template.parse(snippet).render(item_context)
+      end.join
+    end
+
+    def create_item_context(context, item, index, array_size)
+      item_context = context.new_isolated_subcontext
+      item_context[@alias || 'item'] = item
+
+      item_context['forloop'] = {
+        'first' => index.zero?,
+        'index' => index + 1,
+        'index0' => index,
+        'last' => index == array_size - 1,
+        'length' => array_size,
+        'rindex' => array_size - index,
+        'rindex0' => array_size - index - 1
+      }
+
+      @params.each do |key, value|
+        item_context[key] = context[value] || context.evaluate(value) || value
+      end
+
+      item_context
+    end
+
+    def render_with_variable(snippet, variable, context)
+      context[@alias || 'object'] = variable if @variable_name
+
+      @params.each do |key, value|
+        context[key] = context[value] || context.evaluate(value) || value
+      end
+
+      Liquid::Template.parse(snippet).render(context)
+    end
+
+    def create_isolated_context(context)
+      new_context = context.new_isolated_subcontext
+      @params.each { |key, value| new_context[key] = context[value] || context.evaluate(value) || value }
+      new_context
+    end
+  end
+end

data/lib/shopify_liquid_test_helper.rb

@@ -0,0 +1,50 @@
+require 'liquid'
+require 'shopify_liquid_test_helper/render_tag'
+require 'shopify_liquid_test_helper/capture_tag'
+
+module ShopifyLiquidTestHelper
+  class << self
+    attr_accessor :snippets_dir
+
+    def parse_template(template_name)
+      Liquid::Template.parse(File.read(template_name))
+    end
+
+    def render_template(template, assigns)
+      template.render(assigns).strip
+    end
+
+    def register_custom_tags
+      Liquid::Template.register_tag('render', RenderTag)
+      Liquid::Template.register_tag('capture', CaptureTag)
+    end
+
+    def register_snippet(name, content)
+      snippets[name] = content
+    end
+
+    def get_snippet(name)
+      snippets[name] || load_snippet(name)
+    end
+
+    private
+
+    def snippets
+      @snippets ||= {}
+    end
+
+    def load_snippet(name)
+      snippet_path = File.join(snippets_dir || 'snippets', "#{name}.liquid")
+      if File.exist?(snippet_path)
+        snippet = File.read(snippet_path)
+        snippets[name] = snippet
+      else
+        puts "Snippet not found: #{snippet_path}"
+        nil
+      end
+    end
+  end
+
+  # デフォルトのsnippetsディレクトリを設定
+  @snippets_dir = 'snippets'
+end

data/spec/shopify_liquid_test_helper_spec.rb

@@ -0,0 +1,75 @@
+require 'spec_helper'
+
+RSpec.describe ShopifyLiquidTestHelper do
+  before(:all) do
+    ShopifyLiquidTestHelper.register_custom_tags
+    ShopifyLiquidTestHelper.register_snippet('simple', 'Hello, {{ name }}!')
+    ShopifyLiquidTestHelper.register_snippet('for_loop', 'Item: {{ item }}')
+    ShopifyLiquidTestHelper.register_snippet('with_object', 'Name: {{ object.name }}')
+  end
+
+  def render(template, assigns = {})
+    Liquid::Template.parse(template).render(assigns)
+  end
+
+  describe 'render tag' do
+    it 'renders a simple snippet' do
+      template = "{% render 'simple', name: 'World' %}"
+      expect(render(template)).to eq 'Hello, World!'
+    end
+
+    it 'renders a snippet with a for loop' do
+      template = "{% render 'for_loop' for items as item %}"
+      assigns = { 'items' => %w[A B C] }
+      expect(render(template, assigns)).to eq 'Item: AItem: BItem: C'
+    end
+
+    it 'renders a snippet with an object' do
+      template = "{% render 'with_object' with user as object %}"
+      assigns = { 'user' => { 'name' => 'John' } }
+      expect(render(template, assigns)).to eq 'Name: John'
+    end
+
+    it 'does not allow access to variables outside the snippet' do
+      ShopifyLiquidTestHelper.register_snippet('isolated', '{{ outside_var }}')
+      template = "{% assign outside_var = 'Outside' %}{% render 'isolated' %}"
+      expect(render(template)).to eq ''
+    end
+
+    it 'provides all forloop variables in for loop rendering' do
+      ShopifyLiquidTestHelper.register_snippet('forloop_vars',
+                                        '{{ forloop.index }},{{ forloop.index0 }},{{ forloop.first }},{{ forloop.last }},{{ forloop.length }},{{ forloop.rindex }},{{ forloop.rindex0 }}|')
+      template = "{% render 'forloop_vars' for items as item %}"
+      assigns = { 'items' => %w[A B C] }
+      expect(render(template, assigns)).to eq '1,0,true,false,3,3,2|2,1,false,false,3,2,1|3,2,false,true,3,1,0|'
+    end
+
+    it 'allows using an alias for the rendered variable' do
+      template = "{% render 'simple' with 'Alias' as name %}"
+      expect(render(template)).to eq 'Hello, Alias!'
+    end
+
+    it 'does not pollute the outer scope' do
+      template = "{% render 'simple' with 'Inner' as name %}{{ name }}"
+      assigns = { 'name' => 'Outer' }
+      expect(render(template, assigns)).to eq 'Hello, Inner!Outer'
+    end
+  end
+
+  describe 'capture tag' do
+    it 'captures content into a variable' do
+      template = "{% capture my_variable %}Hello, Capture!{% endcapture %}{{ my_variable }}"
+      expect(render(template)).to eq 'Hello, Capture!'
+    end
+
+    it 'captures complex content with Liquid logic' do
+      template = "{% capture complex %}{% for i in (1..3) %}{{ i }}{% endfor %}{% endcapture %}{{ complex }}"
+      expect(render(template)).to eq '123'
+    end
+
+    it 'overwrites previously captured variables' do
+      template = "{% capture var %}First{% endcapture %}{% capture var %}Second{% endcapture %}{{ var }}"
+      expect(render(template)).to eq 'Second'
+    end
+  end
+end

data/spec/spec_helper.rb

@@ -0,0 +1,7 @@
+require 'shopify_liquid_test_helper'
+
+RSpec.configure do |config|
+  config.before(:all) do
+    ShopifyLiquidTestHelper.register_custom_tags
+  end
+end

metadata

@@ -0,0 +1,93 @@
+--- !ruby/object:Gem::Specification
+name: shopify_liquid_test_helper
+version: !ruby/object:Gem::Version
+  version: 0.1.0
+platform: ruby
+authors:
+- Ken Takagiwa
+autorequire: 
+bindir: bin
+cert_chain: []
+date: 2024-08-23 00:00:00.000000000 Z
+dependencies:
+- !ruby/object:Gem::Dependency
+  name: liquid
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: '5.0'
+  type: :runtime
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: '5.0'
+- !ruby/object:Gem::Dependency
+  name: rspec
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: '3.0'
+  type: :development
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: '3.0'
+- !ruby/object:Gem::Dependency
+  name: rake
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: '13.0'
+  type: :development
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: '13.0'
+description: This gem provides helper methods and custom tags for testing Shopify
+  Liquid templates
+email:
+- ugw.gi.world@gmail.com
+executables: []
+extensions: []
+extra_rdoc_files: []
+files:
+- README.md
+- Rakefile
+- lib/shopify_liquid_test_helper.rb
+- lib/shopify_liquid_test_helper/capture_tag.rb
+- lib/shopify_liquid_test_helper/render_tag.rb
+- spec/shopify_liquid_test_helper_spec.rb
+- spec/spec_helper.rb
+homepage: https://github.com/yourusername/shopify_liquid_test_helper
+licenses:
+- MIT
+metadata: {}
+post_install_message: 
+rdoc_options: []
+require_paths:
+- lib
+required_ruby_version: !ruby/object:Gem::Requirement
+  requirements:
+  - - ">="
+    - !ruby/object:Gem::Version
+      version: '0'
+required_rubygems_version: !ruby/object:Gem::Requirement
+  requirements:
+  - - ">="
+    - !ruby/object:Gem::Version
+      version: '0'
+requirements: []
+rubygems_version: 3.3.7
+signing_key: 
+specification_version: 4
+summary: A helper for testing Shopify Liquid templates
+test_files: []