liquid_tag_with_params 0.0.1

checksums.yaml

@@ -0,0 +1,7 @@
+---
+SHA1:
+  metadata.gz: 86c51173d39d8405318c75ee215ce6ae3259627b
+  data.tar.gz: 776e631917a9f5459c397c2dc5fb161e7a253072
+SHA512:
+  metadata.gz: 06e4b41cd6c835f5391bb43edacba9d1a11793c30ad72be8686f032b7d45a9da0cd50bfede6bbdb27a01ed9e0c947c120e202a3b667fce4e146ed44bbb5b4785
+  data.tar.gz: 7b79a805b189812e96083f233b4ef208e94eed8ff32b1d26ef0d677339eb772bab1a92412ab8b8dcd9dbfae91183241b66e251e540836addd55a4d3130c0bca0

data/Gemfile

@@ -0,0 +1,8 @@
+source 'http://rubygems.org'
+
+gemspec
+
+group :test do
+  gem 'minitest'
+  gem 'rake'
+end

data/Gemfile.lock

@@ -0,0 +1,23 @@
+PATH
+  remote: .
+  specs:
+    liquid_tag_with_params (0.0.1)
+      liquid (>= 4.0.0)
+
+GEM
+  remote: http://rubygems.org/
+  specs:
+    liquid (4.0.0)
+    minitest (5.10.3)
+    rake (12.1.0)
+
+PLATFORMS
+  ruby
+
+DEPENDENCIES
+  liquid_tag_with_params!
+  minitest
+  rake
+
+BUNDLED WITH
+   1.14.6

data/LICENSE

@@ -0,0 +1,20 @@
+Copyright (c) 2017 Oleg Khabarov
+
+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/README.md

@@ -0,0 +1,53 @@
+# Liquid Tag With Params
+[![Gem Version](https://img.shields.io/gem/v/liquid_tag_with_params.svg?style=flat)](http://rubygems.org/gems/liquid_tag_with_params) [![Gem Downloads](https://img.shields.io/gem/dt/liquid_tag_with_params.svg?style=flat)](http://rubygems.org/gems/liquid_tag_with_params) [![Build Status](https://img.shields.io/travis/comfy/liquid_tag_with_params.svg?style=flat)](https://travis-ci.org/comfy/liquid_tag_with_params)
+
+This is a `Liquid::TagWithParams` that extends `Liquid::Tag` by adding support for, you guessed it, params.
+
+## Install
+
+Add gem to your Gemfile:
+
+```ruby
+gem 'liquid_tag_with_params', '~> 0.0.1'
+```
+
+## Usage
+
+This gem is primarily for extending Liquid [by creating your own tags](https://github.com/Shopify/liquid/wiki/Liquid-for-Programmers#create-your-own-tags). Out of the box `Liquid::Tag`
+accepts a string and that's about it. `Liquid::TagWithParams` will take that
+string and will make parameters out of it so you can use them during rendering.
+
+Here's an example of such tag:
+
+```ruby
+class ShuffleTag < Liquid::TagWithParams
+  def initialize(tag_name, params, tokens)
+     super
+  end
+
+  def render(context)
+    # assuming that last params were of key: value format
+    options = @params.extract_options!
+
+    # note: keys and values are always strings
+    times = options["times"] || 1
+
+    # shuffle really hard
+    times.to_i.times do
+      @params.shuffle!
+    end
+
+    @params.join(', ')
+  end
+end
+
+Liquid::Template.register_tag('shuffle', ShuffleTag)
+```
+
+```ruby
+@template = Liquid::Template.parse("{% shuffle 1, 2, 3, 4, times: 5 %}")
+@template.render    # => "2, 1, 3, 4"
+```
+
+---
+Copyright 2017, Oleg Khabarov

data/Rakefile

@@ -0,0 +1,11 @@
+require 'rubygems'
+require 'rake/testtask'
+require 'bundler/setup'
+
+Rake::TestTask.new(:test) do |test|
+  test.libs << 'lib' << 'test'
+  test.pattern = 'test/**/*_test.rb'
+  test.verbose = true
+end
+
+task default: :test

data/lib/liquid/tag_with_params.rb

@@ -0,0 +1,16 @@
+require 'liquid'
+require_relative 'tag_with_params/parser'
+
+class Liquid::TagWithParams < Liquid::Tag
+
+  attr_reader :params
+
+  def initialize(tag_name, markup, parse_context)
+    super
+    @params = LiquidTagWithParams::Parser.parse(markup)
+  end
+
+  def render(_context)
+    ""
+  end
+end

data/lib/liquid/tag_with_params/parser.rb

@@ -0,0 +1,78 @@
+module LiquidTagWithParams::Parser
+
+  SINGLE_STRING_LITERAL = /'[^\']*'/
+  DOUBLE_STRING_LITERAL = /"[^\"]*"/
+  IDENTIFIER            = /[a-z][\w-]*/i
+  COLUMN                = /\:/
+  COMMA                 = /\,/
+
+  def self.parse(text)
+    parameterize(slice(tokenize(text)))
+  end
+
+  def self.parameterize(token_groups)
+    params = [ ]
+    token_groups.each do |tokens|
+      case
+      when tokens.count == 1
+        collect_param_for_string!(params, tokens[0])
+      when tokens.count == 3
+        collect_param_for_hash!(params, tokens)
+      else
+        raise "Unexpected tokens found: #{tokens}"
+      end
+    end
+    params
+  end
+
+  def self.collect_param_for_string!(params, token)
+    type, value = token
+    raise "Unexpected token: #{token}" unless type == :string
+    params << value
+  end
+
+  def self.collect_param_for_hash!(params, tokens)
+    key, col, val = tokens
+    key_type, key_value = key
+    col_type, col_value = col
+    val_type, val_value = val
+
+    unless key_type == :string && col_type == :column && val_type == :string
+      raise "Unexpected tokens: #{tokens}"
+    end
+
+    hash = params.last.is_a?(Hash) ? params.pop : {}
+    hash[key_value] = val_value
+    params << hash
+  end
+
+  # grouping tokens based on the comma and also removing comma tokens
+  def self.slice(tokens)
+    tokens.slice_after do |token|
+      token[0] == :comma
+    end.map do |expression|
+      expression.reject{|t| t[0] == :comma}
+    end
+  end
+
+  # tokenizing input string into a list of touples
+  def self.tokenize(args_string)
+    tokens = []
+    ss = StringScanner.new(args_string)
+    until ss.eos?
+      ss.skip(/\s*/)
+      break if ss.eos?
+      token = case
+        when t = ss.scan(SINGLE_STRING_LITERAL) then [:string, t]
+        when t = ss.scan(DOUBLE_STRING_LITERAL) then [:string, t]
+        when t = ss.scan(IDENTIFIER)            then [:string, t]
+        when t = ss.scan(COLUMN)                then [:column, t]
+        when t = ss.scan(COMMA)                 then [:comma, t]
+        else
+          raise Error, "Unexpected char: #{ss.getch}"
+      end
+      tokens << token
+    end
+    tokens
+  end
+end

data/lib/liquid/tag_with_params/version.rb

@@ -0,0 +1,3 @@
+module LiquidTagWithParams
+  VERSION = "0.0.1"
+end

data/liquid_tag_with_params.gemspec

@@ -0,0 +1,18 @@
+$:.unshift File.expand_path('../lib', __FILE__)
+require 'liquid/tag_with_params/version'
+
+Gem::Specification.new do |s|
+  s.name          = "liquid_tag_with_params"
+  s.version       = LiquidTagWithParams::VERSION
+  s.authors       = ["Oleg Khabarov"]
+  s.email         = ["oleg@khabarov.ca"]
+  s.homepage      = "http://github.com/comfy/liquid_tag_with_params"
+  s.summary       = "Liquid::TagWithParams"
+  s.description   = "Tag class for Liquid markup that supports extra params"
+
+  s.files         = `git ls-files`.split("\n")
+  s.platform      = Gem::Platform::RUBY
+  s.require_paths = ['lib']
+
+  s.add_dependency 'liquid', ">= 4.0.0"
+end

data/test/liquid/tag_with_params/parser_test.rb

@@ -0,0 +1,108 @@
+require_relative '../../test_helper'
+
+class Liquid::TagWithParams::ParserTest < MiniTest::Test
+
+  def test_tokenizer
+    tokens = LiquidTagWithParams::Parser.tokenize("param")
+    assert_equal [[:string, "param"]], tokens
+  end
+
+  def test_tokenizer_with_commas
+    tokens = LiquidTagWithParams::Parser.tokenize("param_a, param_b")
+    assert_equal [[:string, "param_a"], [:comma, ","], [:string, "param_b"]], tokens
+  end
+
+  def test_tokenizer_with_columns
+    tokens = LiquidTagWithParams::Parser.tokenize("key: value")
+    assert_equal [[:string, "key"], [:column, ":"], [:string, "value"]], tokens
+  end
+
+  def test_tokenizer_with_quoted_value
+    tokens = LiquidTagWithParams::Parser.tokenize("key: 'v1, v2: v3'")
+    assert_equal [[:string, "key"], [:column, ":"], [:string, "'v1, v2: v3'"]], tokens
+
+    tokens = LiquidTagWithParams::Parser.tokenize('key: "v1, v2: v3"')
+    assert_equal [[:string, "key"], [:column, ":"], [:string, '"v1, v2: v3"']], tokens
+  end
+
+  def test_tokenizer_with_bad_input
+    assert_exception_raised do
+      LiquidTagWithParams::Parser.tokenize("%")
+    end
+  end
+
+  def test_slice
+    tokens = [[:string, "a"], [:comma, ","], [:string, "b"]]
+    token_groups = LiquidTagWithParams::Parser.slice(tokens)
+    assert_equal [[[:string, "a"]], [[:string, "b"]]], token_groups
+  end
+
+  def test_parameterize
+    token_groups = [[[:string, "a"]]]
+    params = LiquidTagWithParams::Parser.parameterize(token_groups)
+    assert_equal ["a"], params
+
+    token_groups = [[[:string, "a"], [:column, ":"], [:string, "b"]]]
+    params = LiquidTagWithParams::Parser.parameterize(token_groups)
+    assert_equal [{"a" => "b"}], params
+  end
+
+  def test_parameterize_with_bad_input
+    token_groups = [[[:string, "a"], [:string, "b"]]]
+    assert_exception_raised do
+      LiquidTagWithParams::Parser.parameterize(token_groups)
+    end
+  end
+
+  def test_collect_param_for_string!
+    params = []
+    LiquidTagWithParams::Parser.collect_param_for_string!(params, [:string, "a"])
+    assert_equal ["a"], params
+  end
+
+  def test_collect_param_for_string_with_bad_input
+    assert_exception_raised do
+      LiquidTagWithParams::Parser.collect_param_for_string!([], [:invalid, "a"])
+    end
+  end
+
+  def test_collect_param_for_hash!
+    params = []
+    tokens = [[:string, "a"], [:column, ":"], [:string, "b"]]
+    LiquidTagWithParams::Parser.collect_param_for_hash!(params, tokens)
+    assert_equal [{"a" => "b"}], params
+  end
+
+  def test_collect_param_for_hash_with_trailing_hash
+    params = ["x", {"y" => "z"}]
+    tokens = [[:string, "a"], [:column, ":"], [:string, "b"]]
+    LiquidTagWithParams::Parser.collect_param_for_hash!(params, tokens)
+    assert_equal ["x", {"y" => "z", "a" => "b"}], params
+  end
+
+  def test_collect_param_for_hash_with_trailing_param
+    params = ["x", {"y" => "z"}, "k"]
+    tokens = [[:string, "a"], [:column, ":"], [:string, "b"]]
+    LiquidTagWithParams::Parser.collect_param_for_hash!(params, tokens)
+    assert_equal ["x", {"y" => "z"}, "k", {"a" => "b"}], params
+  end
+
+  def test_collect_param_for_hash_with_bad_input
+    assert_exception_raised do
+      tokens = [[:string, "a"], [:invalid, ":"], [:string, "b"]]
+      LiquidTagWithParams::Parser.collect_param_for_hash!([], tokens)
+    end
+  end
+
+  def test_parse
+    text = "param_a, param_b, key_a: val_a, key_b: val_b, param_c, key_c: val_c"
+    params = LiquidTagWithParams::Parser.parse(text)
+    assert_equal [
+      "param_a",
+      "param_b",
+      {"key_a" => "val_a", "key_b" => "val_b"},
+      "param_c",
+      {"key_c" => "val_c"}
+    ], params
+  end
+end

data/test/liquid/tag_with_params_test.rb

@@ -0,0 +1,15 @@
+require_relative '../test_helper'
+
+class Liquid::TagWithParamsTest < MiniTest::Test
+  include Liquid
+
+  def test_initialization
+    params = "param_1, param_2, key_1: val_1, key_2: val_2"
+    tag = Liquid::TagWithParams.send(:new, 'test_tag', params, ParseContext.new)
+
+    assert_equal 'test_tag', tag.tag_name
+    assert_equal params, tag.instance_variable_get("@markup")
+    assert_equal ['param_1', 'param_2', {'key_1' => 'val_1', 'key_2' => 'val_2'}],
+      tag.params
+  end
+end

data/test/test_helper.rb

@@ -0,0 +1,29 @@
+require 'bundler/setup'
+require 'minitest/autorun'
+require 'liquid'
+require 'liquid/tag_with_params'
+
+class MiniTest::Test
+
+  # Example usage:
+  #   assert_exception_raised                                 do ... end
+  #   assert_exception_raised ActiveRecord::RecordInvalid     do ... end
+  #   assert_exception_raised Plugin::Error, 'error_message'  do ... end
+  def assert_exception_raised(exception_class = nil, error_message = nil, &block)
+    exception_raised = nil
+    yield
+  rescue => exception_raised
+  ensure
+    if exception_raised
+      if exception_class
+        assert_equal exception_class, exception_raised.class, exception_raised.to_s
+      else
+        assert true
+      end
+      assert_equal error_message, exception_raised.to_s if error_message
+    else
+      flunk 'Exception was not raised'
+    end
+  end
+
+end

metadata

@@ -0,0 +1,69 @@
+--- !ruby/object:Gem::Specification
+name: liquid_tag_with_params
+version: !ruby/object:Gem::Version
+  version: 0.0.1
+platform: ruby
+authors:
+- Oleg Khabarov
+autorequire: 
+bindir: bin
+cert_chain: []
+date: 2017-09-14 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
+  type: :runtime
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - ">="
+      - !ruby/object:Gem::Version
+        version: 4.0.0
+description: Tag class for Liquid markup that supports extra params
+email:
+- oleg@khabarov.ca
+executables: []
+extensions: []
+extra_rdoc_files: []
+files:
+- Gemfile
+- Gemfile.lock
+- LICENSE
+- README.md
+- Rakefile
+- lib/liquid/tag_with_params.rb
+- lib/liquid/tag_with_params/parser.rb
+- lib/liquid/tag_with_params/version.rb
+- liquid_tag_with_params.gemspec
+- test/liquid/tag_with_params/parser_test.rb
+- test/liquid/tag_with_params_test.rb
+- test/test_helper.rb
+homepage: http://github.com/comfy/liquid_tag_with_params
+licenses: []
+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: []
+rubyforge_project: 
+rubygems_version: 2.6.11
+signing_key: 
+specification_version: 4
+summary: Liquid::TagWithParams
+test_files: []