liquid4-blocks 0.7.0

checksums.yaml

@@ -0,0 +1,7 @@
+---
+SHA1:
+  metadata.gz: 498631587a1fba29be74ba965e6d7910c6bb0e2a
+  data.tar.gz: 16c041c4ed0fa461a371adb5d6a9fac7911f8b36
+SHA512:
+  metadata.gz: 3348e6ddfc376816f3c06652e946bccf176b2f849787f2bea2a0a9c525504779669291f4e4fed1b8a18da48548dc9c2f19bc6a8fca9c9a7dcc49b679eef6caf6
+  data.tar.gz: 3fefad0d6bee58a0e627543cc680fafc22bb0c52c274af4295fab6f75c97421c6051110d42fe491ddcc243c6df42ece89e3123fcfb2b599bc6fbeb36f1e57ea4

data/LICENSE

@@ -0,0 +1,22 @@
+Copyright (c) 2009 Dan Webb
+
+Permission is hereby granted, free of charge, to any person
+obtaining a copy of this software and associated documentation
+files (the "Software"), to deal in the Software without
+restriction, including without limitation the rights to use,
+copy, modify, merge, publish, distribute, sublicense, and/or sell
+copies of the Software, and to permit persons to whom the
+Software is furnished to do so, subject to the following
+conditions:
+
+The above copyright notice and this permission notice shall be
+included in all copies or substantial portions of the Software.
+
+THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND,
+EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES
+OF MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND
+NONINFRINGEMENT. IN NO EVENT SHALL THE AUTHORS OR COPYRIGHT
+HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER LIABILITY,
+WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING
+FROM, OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR
+OTHER DEALINGS IN THE SOFTWARE.

data/lib/liquid_blocks.rb

@@ -0,0 +1,9 @@
+require 'liquid'
+
+module LiquidBlocks
+  autoload :Extends, 'liquid_blocks/extends'
+  autoload :Block, 'liquid_blocks/block'
+end
+
+Liquid::Template.register_tag(:extends, LiquidBlocks::Extends)
+Liquid::Template.register_tag(:block, LiquidBlocks::Block)

data/lib/liquid_blocks/block.rb

@@ -0,0 +1,63 @@
+module LiquidBlocks
+
+  class BlockDrop < ::Liquid::Drop
+    def initialize(block)
+      @block = block
+    end
+
+    def super
+      @block.call_super(@context)
+    end
+  end
+
+  class Block < ::Liquid::Block
+    SYNTAX = /([\w!]+)/
+
+    attr_accessor :parent
+    attr_reader :name
+
+    def initialize(tag_name, markup, tokens)
+      @parent = nil
+
+      if markup =~ SYNTAX
+        @name = $1
+      else
+        raise Liquid::SyntaxError.new("Syntax Error in 'block' - Valid syntax: block [name]")
+      end
+
+      super if tokens
+    end
+
+    def render(context)
+      context.stack do
+        context['block'] = BlockDrop.new(self)
+
+        super
+      end
+    end
+
+    def add_parent(nodelist)
+      if @parent != nil
+        @parent.add_parent(nodelist)
+      else
+        @parent = Block.parse(@tag_name, @name, Liquid::Tokenizer.new(@name + '{% end' + @tag_name + '%}'), @parse_context)
+        @parent.nodelist.clear
+        nodelist.each {|item| @parent.nodelist << item}
+      end
+    end
+
+    def blank?
+      false
+    end
+
+    def call_super(context)
+      if @parent
+        @parent.render(context)
+      else
+        ''
+      end
+    end
+
+  end
+
+end

data/lib/liquid_blocks/extends.rb

@@ -0,0 +1,159 @@
+module LiquidBlocks
+
+  class Extends < ::Liquid::Block
+    SYNTAX = /(#{Liquid::QuotedFragment}+)/
+
+    attr_reader :template_name
+
+    def initialize(tag_name, markup, tokens)
+      if markup =~ SYNTAX
+        @template_name = $1[1..-2]
+      else
+        raise Liquid::SyntaxError.new("Syntax Error in 'extends' - Valid syntax: extends [template]")
+      end
+      super
+    end
+
+    def parse(tokens)
+      @body = Liquid::BlockBody.new
+      parse_all(tokens)
+    end
+
+    def render(context)
+      origin = populate_nodelist(self, context)
+      @body.nodelist.clear
+      origin.root.nodelist.each {|item| @body.nodelist << item}
+      super
+    end
+
+    def nodelist
+      @body.nodelist
+    end
+
+    def blank?
+      false
+    end
+
+    # Load the template that is being extended by the current tag.
+    #
+    # @param template_name [String] the context to use when loading the template
+    # @return [Liquid::Document] the parsed template
+    def load_template(template_name)
+      source = Liquid::Template.file_system.read_template_file(template_name)
+      Liquid::Template.parse(source)
+    end
+
+    private
+
+    def create_variable(token, parse_context)
+      token.scan(Liquid::BlockBody::ContentOfVariable) do |content|
+        markup = content.first
+        return Liquid::Variable.new(markup, parse_context)
+      end
+      raise Liquid::SyntaxError.new(parse_context.locale.t("errors.syntax.variable_termination".freeze, token: token, tag_end: VariableEnd.inspect))
+    end
+
+    def parse_all(tokens)
+      @body.nodelist.clear
+
+      while token = tokens.shift
+        case token
+          when /^#{Liquid::TagStart}/
+            if token =~ /^#{Liquid::TagStart}\s*(\w+)\s*(.*)?#{Liquid::TagEnd}$/
+              # fetch the tag from registered blocks
+              if tag = Liquid::Template.tags[$1]
+                @body.nodelist << tag.parse($1, $2, tokens, @parse_context)
+              else
+                # this tag is not registered with the system
+                # pass it to the current block for special handling or error reporting
+                unknown_tag($1, $2, tokens)
+              end
+            else
+              raise Liquid::SyntaxError, "Tag '#{token}' was not properly terminated with regexp: #{Liquid::TagEnd.inspect}"
+            end
+          when /^#{Liquid::VariableStart}/
+            @body.nodelist << create_variable(token, @parse_context)
+          when ''
+            # pass
+          else
+            @body.nodelist << token
+        end
+      end
+    end
+
+    # Find all +block+ tags defined as children of the given node.
+    #
+    # The returned hash will have keys that are the names of the declared
+    # blocks, with values of +LiquidBlocks::Block+ instances.
+    #
+    # @param node [Liquid::Tag] a possible +block+ tag
+    # @param blocks [Hash] a set of existing blocks to build on
+    # @return [Hash] all blocks provided by the given node
+    def find_blocks(node, blocks={})
+      if node.respond_to?(:nodelist) && !node.nodelist.nil?
+        node.nodelist.inject(blocks) do |b, node|
+          if node.is_a?(LiquidBlocks::Block)
+            b[node.name] = node
+          end
+          find_blocks(node, b)
+
+          b
+        end
+      end
+
+      blocks
+    end
+
+    # Get the first +extends+ tag in the given template, falling back to
+    # +nil+ if the template does not contain an +extends+ tag.
+    #
+    # @param template [Liquid::Document] a template in which to search for an +extends+ tag
+    # @return [LiquidBlocks::Extends] the first +extends+ tag, or +nil+
+    def get_extends_tag_for_template(template)
+      template.root.nodelist.select { |node| node.is_a?(Extends) }.first
+    end
+
+    # Populate the nodelist for the highest-level template being extended with
+    # the contents of its child +block+ tags.
+    #
+    # @param tag [Liquid::Tag] an instance of an +extends+ tag
+    # @param context [Liquid::Context] the context to use when loading the template
+    # @return [Liquid::Document] the top-level template with a modified nodelist
+    def populate_nodelist(tag, context)
+
+      # Get the template being extended by the tag and get an appropriate root
+      # node for it based on whether or not it extends another template
+      parent = tag.load_template(@template_name)
+      parent_blocks = find_blocks(parent.root)
+      extends = get_extends_tag_for_template(parent)
+      parent_node = extends || parent.root
+
+      # Examine every block in the current tag, replacing a matching block in
+      # its parent or adding it to its parent's nodelist, provided that the
+      # parent is not the top-level template
+      find_blocks(tag).each do |name, block|
+        parent_block = parent_blocks[name]
+        if parent_block
+          parent_block.parent = block.parent
+          parent_block.add_parent(parent_block.nodelist)
+          parent_block.nodelist.clear
+          block.nodelist.each {|item| parent_block.nodelist << item}
+        elsif extends
+          parent_node.nodelist << block
+        end
+      end
+
+      # Pass likely context variables on to parent templates
+      included_templates = (context.registers[:cached_partials] || {}).keys
+      included_templates.each do |included_template|
+        if context.key?(included_template)
+          context[tag.template_name] ||= context[included_template]
+        end
+      end
+
+      parent
+    end
+
+  end
+
+end

data/lib/liquid_blocks/version.rb

@@ -0,0 +1,3 @@
+module LiquidBlocks
+  VERSION = '0.7.0'
+end

data/test/test_liquid_blocks.rb

@@ -0,0 +1,315 @@
+require 'test/unit'
+require 'liquid_blocks'
+
+class TestFileSystem
+  def read_template_file(path)
+    if path == 'simple'
+      'test'
+    elsif path == 'complex'
+      %{
+        beginning
+
+        {% block thing %}
+        rarrgh
+        {% endblock %}
+
+        {% block another %}
+        bum
+        {% endblock %}
+
+      end
+      }
+    elsif path == 'nested'
+      %{
+        {% extends 'complex' %}
+
+        {% block thing %}
+        from nested
+        {% endblock %}
+
+        {% block another %}
+        from nested (another)
+        {% endblock %}
+      }
+    elsif path == 'nested_more'
+      %{
+        {% extends 'complex' %}
+
+        {% block thing %}
+        thing
+        {% endblock %}
+      }
+    elsif path == 'similar'
+      %{
+        {% block aralia %}
+        aralia
+        {% endblock %}
+
+        {% block azalea %}
+        azalea
+        {% endblock %}
+      }
+    elsif path == 'deep'
+      %{
+        {% block one %}
+          one
+          {% block two %}
+            two
+            {% block three %}three{% endblock %}
+            {% block four %}four{% endblock %}
+          {% endblock %}
+        {% endblock %}
+      }
+    elsif path == 'nested_deep'
+      %{
+        {% extends 'deep' %}
+      }
+    elsif path == 'ruby'
+      %{
+        {% block test %}{% endblock %}
+        {% block test! %}{% endblock %}
+      }
+    elsif path == 'context_variable'
+      %{
+        {% block body %}{{ context_variable }}{% endblock %}
+      }
+    elsif path == 'context_variable_extended'
+      %{
+        {% extends 'context_variable' %}
+        {% block body %}
+          1{{ block.super }}
+          2{{ context_variable_extended }}
+        {% endblock %}
+      }
+    end
+  end
+end
+
+Liquid::Template.file_system = TestFileSystem.new
+
+class LiquidBlocksTest < Test::Unit::TestCase
+  def test_output_the_contents_of_the_extended_template
+    template = Liquid::Template.parse %{
+      {% extends 'simple' %}
+
+      {% block thing %}
+      yeah
+      {% endblock %}
+    }
+
+    assert_match /test/, template.render
+  end
+
+  def test_render_original_content_of_block_if_no_child_block_given
+    template = Liquid::Template.parse %{
+      {% extends 'complex' %}
+    }
+
+    assert_match /rarrgh/, template.render
+    assert_match /bum/, template.render
+  end
+
+  def test_render_child_content_of_block_if_child_block_given
+    template = Liquid::Template.parse %{
+      {% extends 'complex' %}
+
+      {% block thing %}
+      booyeah
+      {% endblock %}
+    }
+
+    assert_match /booyeah/, template.render
+    assert_match /bum/, template.render
+  end
+
+  def test_render_child_content_of_blocks_if_multiple_child_blocks_given
+    template = Liquid::Template.parse %{
+      {% extends 'complex' %}
+
+      {% block thing %}
+      booyeah
+      {% endblock %}
+
+      {% block another %}
+      blurb
+      {% endblock %}
+    }
+
+    assert_match /booyeah/, template.render
+    assert_match /blurb/, template.render
+  end
+
+  def test_remember_context_of_child_template
+    template = Liquid::Template.parse %{
+      {% extends 'complex' %}
+
+      {% block thing %}
+      booyeah
+      {% endblock %}
+
+      {% block another %}
+      {{ a }}
+      {% endblock %}
+    }
+
+    res = template.render 'a' => 1234
+
+    assert_match /booyeah/, res
+    assert_match /1234/, res
+  end
+
+  def test_work_with_nested_templates
+    template = Liquid::Template.parse %{
+      {% extends 'nested' %}
+
+      {% block thing %}
+      booyeah
+      {% endblock %}
+    }
+
+    res = template.render 'a' => 1234
+
+    assert_match /booyeah/, res
+    assert_match /from nested/, res
+  end
+
+  def test_work_with_nested_templates_if_middle_template_skips_a_block
+    template = Liquid::Template.parse %{
+      {% extends 'nested_more' %}
+
+      {% block another %}
+      win
+      {% endblock %}
+    }
+
+    res = template.render
+
+    assert_match /win/, res
+    assert_no_match /bum/, res
+  end
+
+  def test_render_parent_for_block_super
+    template = Liquid::Template.parse %{
+      {% extends 'complex' %}
+
+      {% block thing %}
+      {{ block.super }}
+      {% endblock %}
+    }
+
+    res = template.render 'a' => 1234
+
+    assert_match /rarrgh/, res
+  end
+
+  def test_render_separate_block_content_for_blocks_with_identical_first_or_last_letters
+    template = Liquid::Template.parse %{
+      {% extends 'similar' %}
+
+      {% block aralia %}
+      spikenard
+      {% endblock %}
+
+      {% block azalea %}
+      tsutsuji
+      {% endblock %}
+    }
+
+    res = template.render
+
+    assert_match /spikenard/, res
+    assert_match /tsutsuji/, res
+  end
+
+  def test_render_deep_blocks
+    template = Liquid::Template.parse %{
+      {% extends 'deep' %}
+    }
+
+    res = template.render
+
+    assert_match /three/, res
+  end
+
+  def test_render_deep_blocks_override_inner_blocks
+    template = Liquid::Template.parse %{
+      {% extends 'deep' %}
+
+      {% block two %}extra {{ block.super }}{% endblock %}
+      {% block three %}override{% endblock %}
+    }
+
+    res = template.render
+
+    assert_match /one/, res
+    assert_match /two/, res
+    assert_match /extra/, res
+    assert_match /override/, res
+    assert_no_match /three/, res
+  end
+
+  def test_render_deep_blocks_hide_child_blocks_if_parent_empty
+    template = Liquid::Template.parse %{
+      {% extends 'nested_deep' %}
+
+      {% block two %}{% endblock %}
+      {% block three %}hidden{% endblock %}
+    }
+
+    res = template.render
+
+    assert_no_match /two/, res
+    assert_no_match /hidden/, res
+    assert_no_match /four/, res
+  end
+
+  def test_render_blocks_ruby_name
+    template = Liquid::Template.parse %{
+      {% extends 'ruby' %}
+
+      {% block test %}quiet{% endblock %}
+      {% block test! %}loud{% endblock %}
+    }
+
+    res = template.render
+
+    assert_match /quiet/, res
+    assert_match /loud/, res
+  end
+
+  def test_render_context_variable
+    template = Liquid::Template.parse %{
+      {% assign var = "context" %}
+      {% include 'context_variable' with var %}
+    }
+
+    res = template.render
+
+    assert_match /context/, res
+  end
+
+  def test_render_context_variable_extended
+    template = Liquid::Template.parse %{
+      {% assign var = "context" %}
+      {% include 'context_variable_extended' with var %}
+    }
+
+    res = template.render
+
+    assert_match /1context/, res
+    assert_match /2context/, res
+  end
+
+  def test_render_context_variable_extended_preserve_existing
+    template = Liquid::Template.parse %{
+      {% assign context_variable = "preserve" %}
+      {% assign var = "pass" %}
+      {% include 'context_variable_extended' with var %}
+    }
+
+    res = template.render
+
+    assert_match /1preserve/, res
+    assert_match /2pass/, res
+  end
+end

metadata

@@ -0,0 +1,109 @@
+--- !ruby/object:Gem::Specification
+name: liquid4-blocks
+version: !ruby/object:Gem::Version
+  version: 0.7.0
+platform: ruby
+authors:
+- Dan Webb
+- Silas Sewell
+- Justin Locsei
+- Rafał Mikołajun
+autorequire: 
+bindir: bin
+cert_chain: []
+date: 2016-04-18 00:00:00.000000000 Z
+dependencies:
+- !ruby/object:Gem::Dependency
+  name: liquid
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: 4.0.0.rc2
+  type: :runtime
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: 4.0.0.rc2
+- !ruby/object:Gem::Dependency
+  name: bundler
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - ">="
+      - !ruby/object:Gem::Version
+        version: 1.0.0
+  type: :development
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - ">="
+      - !ruby/object:Gem::Version
+        version: 1.0.0
+- !ruby/object:Gem::Dependency
+  name: rake
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - ">="
+      - !ruby/object:Gem::Version
+        version: '0'
+  type: :development
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - ">="
+      - !ruby/object:Gem::Version
+        version: '0'
+- !ruby/object:Gem::Dependency
+  name: test-unit
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - ">="
+      - !ruby/object:Gem::Version
+        version: '0'
+  type: :development
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - ">="
+      - !ruby/object:Gem::Version
+        version: '0'
+description: Django-style template inheritance for Liquid
+email: 
+executables: []
+extensions: []
+extra_rdoc_files: []
+files:
+- LICENSE
+- lib/liquid_blocks.rb
+- lib/liquid_blocks/block.rb
+- lib/liquid_blocks/extends.rb
+- lib/liquid_blocks/version.rb
+- test/test_liquid_blocks.rb
+homepage: https://github.com/mikoweb/liquid4-blocks
+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: 1.3.6
+requirements: []
+rubyforge_project: 
+rubygems_version: 2.4.5.1
+signing_key: 
+specification_version: 4
+summary: Liquid Blocks
+test_files:
+- test/test_liquid_blocks.rb