liquid-arrays 1.0.0 → 1.1.0

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA256:
-  metadata.gz: f1e0a5c016d3c2b814dcb7bbcfd5af5293d5934fc44dd1215f66f49bcb4ce8af
-  data.tar.gz: 32eeef65c1531dc56b43cc882f617a64d6ac6d75a89d9b5b517bc1f032bdd6bf
+  metadata.gz: c728ff12a57cc91aae46e78cf74b5b3953beb670b55f33f65729c1b2d32eeeb8
+  data.tar.gz: 58979b0fa0b641ceb3e4358478de213ba29b331c90c05ac19df5aa9b9bcafa79
 SHA512:
-  metadata.gz: 82e191d6a4cd14ca988325acce0c5fc3a38f9762f69426aed8aaa8e47a7e75407cd7716788b1b6a4aba91c4db52bf5adacfb3b978f9e7c884317fb95fcba1b22
-  data.tar.gz: b33d268477da626b9eecb4870000282188076a82f246a98c66091ca89f094845a75f3fc136461dc2ac9c5fc327fee56192545ccf7d946b6733bcc832c88b0fa3
+  metadata.gz: 62e0a5c5d1dce765b25d5b446b3aafbbeeb4d4f71937f1f4948fb738fdf0b9f6ace6d3de0f7b75f60b3ca649ee0f384a5f231cfa37a62bef774052c343b72f61
+  data.tar.gz: 4264d2f758a4b1f978fe8e37582b5a584652997b98f21ad9d7ac9ac855e8fdfed9eb90414cdf94c3311f87c1b691efce7bc73121f6d153946d2fa780f34b8c01

data/CHANGELOG.md

@@ -0,0 +1,13 @@
+## 1.1.0
+
+### Features
+
+* Added `array_create` and `hash_create` tags
+* Arrays and hashes can now be defined inline to be used as attributes
+* Improved error handling to now use Liquid's `error_mode`
+
+### Bug Fixes
+
+* Arrays and hashes will be created in the proper scope instead of the outer-most scope
+* Fixed issue when using default attributes that use special characters, like array elements
+* Added check to ensure a variable is an array or hash before modifying it to avoid errors

data/README.md

@@ -24,6 +24,12 @@ Or install it yourself as:
 Ensure any other requirements the software you're using might have for loading 
 plugins are met.
 
+## Error Handling
+
+Error handling uses Liquid's error modes to determine how to handle errors. 
+Please see [Liquid - Error Modes](https://github.com/Shopify/liquid#error-modes) 
+for more information.
+
 ## Usage
 
 There are several tags that will modify arrays and hashes in various ways. 
@@ -41,6 +47,42 @@ attribute needs specified, like so:
 {% tag_name value %}
 ```
 
+### Types
+
+Aside from the standard Liquid types, inline arrays and hashes may also be 
+defined and used for appropriate attributes. The syntax for each is as follows:
+
+```liquid
+{% tag_name array:value1,value2,value3 %}
+{% tag_name hash:key1>value1,key2>value2 %}
+```
+
+**Note**: If an array is defined with a single variable and that variable contains 
+an array, that array will be used instead of being the first element.
+
+### array_create tag
+
+Creates an array with opinional initial items. If the variable is already 
+defined it will reassign it.
+
+| Attribute | Required      | Type     | Description         |
+| --------- | ------------- | -------- | ------------------- |
+| array     | Yes (default) | Variable | The array to create |
+| items     | No            | Array    | The initial items   |
+
+
+#### Example
+
+```liquid
+{% array_create values1 %}
+{% array_create array:values2 items:"value1",2 %}
+```
+
+```ruby
+values1 => []
+values2 => ["value1", 2]
+```
+
 ### array_add tag
 
 Adds a value to the end of an array. If the array doesn't exist, it will 
@@ -166,6 +208,29 @@ for every operation. If the array doesn't exist, it will create an empty array.
 values => ["a", "z", "b"]
 ```
 
+### hash_create tag
+
+Creates a hash with opinional initial entries. If the variable is already 
+defined it will reassign it.
+
+| Attribute | Required      | Type     | Description         |
+| --------- | ------------- | -------- | ------------------- |
+| hash      | Yes (default) | Variable | The hash to create  |
+| entries   | No            | Hash     | The initial entries |
+
+
+#### Example
+
+```liquid
+{% hash_create values1 %}
+{% hash_create hash:values2 entries:"key1">"a","key2",3 %}
+```
+
+```ruby
+values1 => {}
+values2 => {"key1" => "a", "key2" => 3}
+```
+
 ### hash_set tag
 
 Sets a key-value mapping in a hash, either adding it if it doesn't already 
@@ -181,13 +246,13 @@ exist, it will create it first.
 #### Example
 
 ```liquid
-{% hash_set hash:values key:"value1" value:"a" %}
-{% hash_set hash:values key:"value2" value:3 %}
-{% hash_set hash:values key:"value3" value:false %}
+{% hash_set hash:values key:"key1" value:"a" %}
+{% hash_set hash:values key:"key2" value:3 %}
+{% hash_set hash:values key:"key3" value:false %}
 ```
 
 ```ruby
-values => {"value1" => "a", "value2" => 3, "value3" => false}
+values => {"key1" => "a", "key2" => 3, "key3" => false}
 ```
 
 ### hash_delete tag
@@ -202,16 +267,16 @@ Deletes a key-value mapping from a hash for a key.
 #### Example
 
 ```ruby
-values => {"value1" => "a", "value2" => 3, "value3" => false}
+values => {"key1" => "a", "key2" => 3, "key3" => false}
 ```
 
 ```liquid
-{% hash_delete hash:values key:"value1" %}
-{% hash_delete hash:values key:"value2" %}
+{% hash_delete hash:values key:"key1" %}
+{% hash_delete hash:values key:"key2" %}
 ```
 
 ```ruby
-values => {"value3" => false}
+values => {"key3" => false}
 ```
 
 ### hash block tag
@@ -227,15 +292,15 @@ every operation. If the hash doesn't exist, it will create an empty hash.
 
 ```liquid
 {% hash values %}
-  {% hash_set key:"value1" value:"a" %}
-  {% hash_set key:"value2" value:"b" %}
-  {% hash_set key:"value3" value:"c" %}
-  {% hash_delete "value2" %}
+  {% hash_set key:"key1" value:"a" %}
+  {% hash_set key:"key2" value:"b" %}
+  {% hash_set key:"key3" value:"c" %}
+  {% hash_delete "key2" %}
 {% endhash %}
 ```
 
 ```ruby
-values => {"value1" => "a", "value3" => "c"}
+values => {"key1" => "a", "key3" => "c"}
 ```
 
 ## License

data/lib/liquid-arrays/array_add_tag.rb

@@ -1,18 +1,20 @@
 module Arrays
-  class ArrayAddTag < ArrayTag
+  class ArrayAddTag < Liquid::Tag
+    include ErrorHandler
+    
     def parse(tokens)
       super
-      parser = AttributeParser.new(@parse_context, 'value', @markup)
-      @array_name = parser.consume_attribute('array', :id)
-      @value = parser.consume_required_attribute('value')
-      parser.finish
+      catch do
+        parser = AttributeParser.new(@parse_context, 'value', @markup)
+        @array_name = parser.consume_attribute('array', :id)
+        @value = parser.consume_required_attribute('value')
+        parser.finish
+      end
     end
 
     def render(context)
-      array = get_array(context, true)
-      unless array.nil?
-        array.push(@value.render(context))
-      end
+      array = ArrayHelper.get_array(context, @array_name, true)
+      array.push(@value.render(context)) unless array.nil?
       ''
     end
   end

data/lib/liquid-arrays/array_block.rb

@@ -1,15 +1,22 @@
 module Arrays
   class ArrayBlock < Liquid::Block
+    include ErrorHandler
+
     def parse(tokens)
       super
-      parser = AttributeParser.new(@parse_context, 'array', @markup)
-      @array_name = parser.consume_required_attribute('array', :id)
-      parser.finish
+      catch do
+        parser = AttributeParser.new(@parse_context, 'array', @markup)
+        @array_name = parser.consume_required_attribute('array', :id)
+        parser.finish
+      end
     end
 
     def render(context)
-      @array = context[@array_name] ||= []
-      context.scopes.last[@array_name] = @array
+      if context.key?(@array_name)
+        @array = context[@array_name]
+      else
+        context.scopes.last[@array_name] = @array = []
+      end
       context.stack do
         context['block_array'] = @array
         @output = super

data/lib/liquid-arrays/array_create_tag.rb

@@ -0,0 +1,23 @@
+module Arrays
+  class ArrayCreateTag < Liquid::Tag
+    include ErrorHandler
+
+    def parse(tokens)
+      super
+      catch do
+        parser = AttributeParser.new(@parse_context, 'array', @markup)
+        @array_name = parser.consume_required_attribute('array', :id)
+        @items = parser.consume_attribute('items', :array)
+        parser.finish
+      end
+    end
+
+    def render(context)
+      context.scopes.last[@array_name] = @items.nil? ?
+        [] : @items.render(context)
+      ''
+    end
+  end
+
+  Liquid::Template.register_tag('array_create', ArrayCreateTag)
+end

data/lib/liquid-arrays/array_delete_tag.rb

@@ -1,27 +1,33 @@
 module Arrays
-  class ArrayDeleteTag < ArrayTag
+  class ArrayDeleteTag < Liquid::Tag
+    include ErrorHandler
+    
     def parse(tokens)
       super
-      parser = AttributeParser.new(@parse_context, @markup)
-      @array_name = parser.consume_attribute('array', :id)
-      @value = parser.consume_attribute('value')
-      @index = parser.consume_attribute('index', :integer)
-      parser.finish
-      if @value.nil? && @index.nil?
-        raise Liquid::ArgumentError, 'no value or index specified'
-      elsif !@value.nil? && !@index.nil?
-        raise Liquid::ArgumentError, 'only value or index can be specified'
-      end
+      catch do
+        parser = AttributeParser.new(@parse_context, @markup)
+        @array_name = parser.consume_attribute('array', :id)
+        @value = parser.consume_attribute('value')
+        @index = parser.consume_attribute('index', :integer)
+        parser.finish
+        if @value.nil? && @index.nil?
+          raise Liquid::SyntaxError, 'no value or index specified'
+        elsif !@value.nil? && !@index.nil?
+          raise Liquid::SyntaxError, 'only value or index can be specified'
+        end
+      end   
     end
 
     def render(context)
-      array = get_array(context, false)
+      array = ArrayHelper.get_array(context, @array_name, false)
       unless array.nil?
         if @index.nil?
           array.delete(@value.render(context))
         else
           index = @index.render(context)
-          array.delete_at(index) if index.is_a?(Integer) && !out_of_bounds?(array, index)
+          if index.is_a?(Integer) && index >= 0 && index < array.length
+            array.delete_at(index)
+          end
         end
       end
       ''

data/lib/liquid-arrays/array_helper.rb

@@ -0,0 +1,18 @@
+module Arrays
+  class ArrayHelper
+    def self.get_array(context, array_name, create)
+      unless array_name.nil?
+        if context.key?(array_name)
+          array = context[array_name]
+        elsif create
+          array = context.scopes.last[array_name] ||= []
+        end
+      else
+        if context.key?('block_array')
+          array = context['block_array']
+        end
+      end
+      array.is_a?(Array) ? array : nil
+    end
+  end
+end

data/lib/liquid-arrays/array_insert_tag.rb

@@ -1,16 +1,20 @@
 module Arrays
-  class ArrayInsertTag < ArrayTag
+  class ArrayInsertTag < Liquid::Tag
+    include ErrorHandler
+    
     def parse(tokens)
       super
-      parser = AttributeParser.new(@parse_context, @markup)
-      @array_name = parser.consume_attribute('array', :id)
-      @index = parser.consume_required_attribute('index', :integer)
-      @value = parser.consume_required_attribute('value')
-      parser.finish
+      catch do
+        parser = AttributeParser.new(@parse_context, @markup)
+        @array_name = parser.consume_attribute('array', :id)
+        @index = parser.consume_required_attribute('index', :integer)
+        @value = parser.consume_required_attribute('value')
+        parser.finish
+      end
     end
 
     def render(context)
-      array = get_array(context, false)
+      array = ArrayHelper.get_array(context, @array_name, false)
       index = @index.render(context)
       if !array.nil? && index.is_a?(Integer) && index >= 0 && index <= array.length
         array.insert(index, @value.render(context))

data/lib/liquid-arrays/array_replace_tag.rb

@@ -1,18 +1,22 @@
 module Arrays
-  class ArrayReplaceTag < ArrayTag
+  class ArrayReplaceTag < Liquid::Tag
+    include ErrorHandler
+    
     def parse(tokens)
       super
-      parser = AttributeParser.new(@parse_context, @markup)
-      @array_name = parser.consume_attribute('array', :id)
-      @index = parser.consume_required_attribute('index', :integer)
-      @value = parser.consume_required_attribute('value')
-      parser.finish
+      catch do
+        parser = AttributeParser.new(@parse_context, @markup)
+        @array_name = parser.consume_attribute('array', :id)
+        @index = parser.consume_required_attribute('index', :integer)
+        @value = parser.consume_required_attribute('value')
+        parser.finish
+      end
     end
 
     def render(context)
-      array = get_array(context, false)
+      array = ArrayHelper.get_array(context, @array_name, false)
       index = @index.render(context)
-      unless array.nil? || !index.is_a?(Integer) || out_of_bounds?(array, index)
+      unless array.nil? || !index.is_a?(Integer) || index < 0 || index >= array.length
         array[index] = @value.render(context)
       end
       ''

data/lib/liquid-arrays/array_variable.rb

@@ -0,0 +1,12 @@
+module Arrays
+  class ArrayVariable
+    def initialize(array)
+      @array = array
+    end
+
+    def render(context)
+      array = @array.map { |v| v.render(context) }
+      return array.length == 1 && array[0].is_a?(Array) ? array[0] : array
+    end
+  end
+end

data/lib/liquid-arrays/attribute_parser.rb

@@ -3,48 +3,80 @@ module Arrays
     def initialize(parse_context, default_key = nil, markup)
       super(markup)
       @parse_context = parse_context
-      @attributes = {}
-      if @tokens.length == 2 && look(:end_of_string, 1)
-        raise Liquid::SyntaxError, 'attributes must be named' if default_key.nil?
-        @attributes[default_key] = get_current_value
-      elsif @tokens.length > 2
-        while look(:id) && look(:colon, 1)
-          key = consume
-          consume
-          @attributes[key] = get_current_value
-        end
-        unless look(:end_of_string)
-          raise Liquid::SyntaxError, 'attributes need to have the format key:value'
-        end
-      end
+      parse(default_key, markup)
     end
 
     def consume_attribute(key, type = nil)
       return nil unless @attributes.key?(key)
-      attribute = @attributes.delete(key)
+      value = @attributes.delete(key)
       if type == :id
-        return attribute[0] == :id ? attribute[1] : nil
+        return value[0] == :id ? value[1].raw : nil
+      elsif type == :array && value[0] != :array
+        return ArrayVariable.new([value[1]])
       end
-      attribute[0] == :id || type.nil? || attribute[0] == type ?
-        Liquid::Variable.new(attribute[1], @parse_context) :
-        nil
+      return type.nil? || value[0] == type || value[0] == :id ? value[1] : nil
     end
 
     def consume_required_attribute(key, type = nil)
       attribute = consume_attribute(key, type)
-      raise Liquid::ArgumentError, "#{key} not specified" if attribute == nil
+      raise Liquid::SyntaxError, "#{key} not specified" if attribute == nil
       attribute
     end
 
     def finish
       unless @attributes.empty?
-        raise Liquid::ArgumentError, "invalid arguments #{@attributes.keys.join(',')}"
+        raise Liquid::SyntaxError, "invalid arguments #{@attributes.keys.join(',')}"
       end
     end
 
     private
 
-    def get_current_value
+    def parse(default_key, markup)
+      @attributes = {}
+      unless look(:end_of_string)
+        if look(:id) && look(:colon, 1)
+          while look(:id) && look(:colon, 1)
+            key = consume
+            consume
+            @attributes[key] = parse_value
+          end
+          unless look(:end_of_string)
+            raise Liquid::SyntaxError, 'attributes need to have the format key:value'
+          end
+        else
+          raise Liquid::SyntaxError, 'attributes must be named' if default_key.nil?
+          @attributes[default_key] = parse_value
+          unless look(:end_of_string)
+            raise Liquid::SyntaxError, ''
+          end
+        end
+      end
+    end
+
+    def parse_value
+      expression = parse_expression
+      if look(:comma)
+        array = [expression[1]]
+        while look(:comma)
+          consume
+          array.push(parse_expression[1])
+        end
+        return [:array, ArrayVariable.new(array)]
+      elsif look(:comparison)
+        raise Liquid::SyntaxError, '' unless consume.eql?('>')
+        hash = {expression[1] => parse_expression[1]}
+        while look(:comma) && look(:comparison, 2)
+          consume
+          key = parse_expression[1]
+          raise Liquid::SyntaxError, '' unless consume.eql?('>')
+          hash[key] = parse_expression[1]
+        end
+        return [:hash, HashVariable.new(hash)]
+      end
+      expression
+    end
+
+    def parse_expression
       token = @tokens[@p]
       type = token[0]
       value = expression
@@ -53,7 +85,7 @@ module Arrays
       elsif type == :id && value.eql?('true') || value.eql?('false')
         type = :boolean
       end
-      [type, value]
+      [type, Liquid::Variable.new(value, @parse_context)]
     end
   end
 end

data/lib/liquid-arrays/error_handler.rb

@@ -0,0 +1,23 @@
+module Arrays
+  module ErrorHandler
+    def handle(error)
+      error.line_number = line_number
+      error.markup_context = "in \"#{@markup.strip}\""
+      
+      case @parse_context.error_mode
+      when :strict
+        raise error
+      when :warn
+        @parse_context.warnings << error
+      end
+    end
+
+    def catch
+      begin
+        yield
+      rescue => e
+        handle(e)
+      end
+    end
+  end
+end

data/lib/liquid-arrays/hash_block.rb

@@ -8,8 +8,11 @@ module Arrays
     end
 
     def render(context)
-      @hash = context[@hash_name] ||= {}
-      context.scopes.last[@hash_name] = @hash
+      if context.key?(@hash_name)
+        @hash = context[@hash_name]
+      else
+        context.scopes.last[@hash_name] = @hash = {}
+      end
       context.stack do
         context['block_hash'] = @hash
         @output = super

data/lib/liquid-arrays/hash_create_tag.rb

@@ -0,0 +1,23 @@
+module Arrays
+  class HashCreateTag < Liquid::Tag
+    include ErrorHandler
+
+    def parse(tokens)
+      super
+      catch do
+        parser = AttributeParser.new(@parse_context, 'hash', @markup)
+        @hash_name = parser.consume_required_attribute('hash', :id)
+        @entries = parser.consume_attribute('entries', :hash)
+        parser.finish
+      end
+    end
+
+    def render(context)
+      context.scopes.last[@hash_name] = @entries.nil? ?
+        {} : @entries.render(context)
+      ''
+    end
+  end
+
+  Liquid::Template.register_tag('hash_create', HashCreateTag)
+end

data/lib/liquid-arrays/hash_delete_tag.rb

@@ -1,15 +1,19 @@
 module Arrays
-  class HashDeleteTag < HashTag
+  class HashDeleteTag < Liquid::Tag
+    include ErrorHandler
+    
     def parse(tokens)
       super
-      parser = AttributeParser.new(@parse_context, 'key', @markup)
-      @hash_name = parser.consume_attribute('hash', :id)
-      @key = parser.consume_required_attribute('key')
-      parser.finish
+      catch do
+        parser = AttributeParser.new(@parse_context, 'key', @markup)
+        @hash_name = parser.consume_attribute('hash', :id)
+        @key = parser.consume_required_attribute('key')
+        parser.finish
+      end
     end
 
     def render(context)
-      hash = get_hash(context, false)
+      hash = HashHelper.get_hash(context, @hash_name, false)
       unless hash.nil?
         hash.delete(@key.render(context))
       end

data/lib/liquid-arrays/hash_helper.rb

@@ -0,0 +1,18 @@
+module Arrays
+  class HashHelper
+    def self.get_hash(context, hash_name, create)
+      unless hash_name.nil?
+        if context.key?(hash_name)
+          hash = context[hash_name]
+        elsif create
+          hash = context.scopes.last[hash_name] ||= {}
+        end
+      else
+        if context.key?('block_hash')
+          hash = context['block_hash']
+        end
+      end
+      hash.is_a?(Hash) ? hash : nil
+    end
+  end
+end

data/lib/liquid-arrays/hash_set_tag.rb

@@ -1,16 +1,20 @@
 module Arrays
-  class HashSetTag < HashTag
+  class HashSetTag < Liquid::Tag
+    include ErrorHandler
+    
     def parse(tokens)
       super
-      parser = AttributeParser.new(@parse_context, @markup)
-      @hash_name = parser.consume_attribute('hash', :id)
-      @key = parser.consume_required_attribute('key')
-      @value = parser.consume_required_attribute('value')
-      parser.finish
+      catch do
+        parser = AttributeParser.new(@parse_context, @markup)
+        @hash_name = parser.consume_attribute('hash', :id)
+        @key = parser.consume_required_attribute('key')
+        @value = parser.consume_required_attribute('value')
+        parser.finish
+      end
     end
 
     def render(context)
-      hash = get_hash(context, true)
+      hash = HashHelper.get_hash(context, @hash_name, true)
       unless hash.nil?
         hash[@key.render(context)] = @value.render(context)
       end

data/lib/liquid-arrays/hash_variable.rb

@@ -0,0 +1,11 @@
+module Arrays
+  class HashVariable
+    def initialize(hash)
+      @hash = hash
+    end
+
+    def render(context)
+      @hash.map { |k,v| [k.render(context), v.render(context)] }.to_h
+    end
+  end
+end

data/lib/liquid-arrays/version.rb

@@ -1,3 +1,3 @@
 module Arrays
-  VERSION = '1.0.0'
+  VERSION = '1.1.0'
 end

data/lib/liquid-arrays.rb

@@ -1,12 +1,17 @@
-require 'liquid-arrays/array_tag'
+require 'liquid-arrays/error_handler'
+require 'liquid-arrays/array_helper'
+require 'liquid-arrays/array_create_tag'
 require 'liquid-arrays/array_add_tag'
 require 'liquid-arrays/array_replace_tag'
 require 'liquid-arrays/array_insert_tag'
 require 'liquid-arrays/array_delete_tag'
 require 'liquid-arrays/array_block'
-require 'liquid-arrays/hash_tag'
+require 'liquid-arrays/hash_helper'
+require 'liquid-arrays/hash_create_tag'
 require 'liquid-arrays/hash_set_tag'
 require 'liquid-arrays/hash_delete_tag'
 require 'liquid-arrays/hash_block'
 require 'liquid-arrays/attribute_parser'
+require 'liquid-arrays/array_variable'
+require 'liquid-arrays/hash_variable'
 require 'liquid-arrays/version'

metadata

@@ -1,14 +1,14 @@
 --- !ruby/object:Gem::Specification
 name: liquid-arrays
 version: !ruby/object:Gem::Version
-  version: 1.0.0
+  version: 1.1.0
 platform: ruby
 authors:
 - Frostphyr
 autorequire:
 bindir: bin
 cert_chain: []
-date: 2021-07-15 00:00:00.000000000 Z
+date: 2021-09-10 00:00:00.000000000 Z
 dependencies:
 - !ruby/object:Gem::Dependency
   name: liquid
@@ -65,6 +65,7 @@ executables: []
 extensions: []
 extra_rdoc_files: []
 files:
+- CHANGELOG.md
 - Gemfile
 - LICENSE
 - README.md
@@ -72,15 +73,20 @@ files:
 - lib/liquid-arrays.rb
 - lib/liquid-arrays/array_add_tag.rb
 - lib/liquid-arrays/array_block.rb
+- lib/liquid-arrays/array_create_tag.rb
 - lib/liquid-arrays/array_delete_tag.rb
+- lib/liquid-arrays/array_helper.rb
 - lib/liquid-arrays/array_insert_tag.rb
 - lib/liquid-arrays/array_replace_tag.rb
-- lib/liquid-arrays/array_tag.rb
+- lib/liquid-arrays/array_variable.rb
 - lib/liquid-arrays/attribute_parser.rb
+- lib/liquid-arrays/error_handler.rb
 - lib/liquid-arrays/hash_block.rb
+- lib/liquid-arrays/hash_create_tag.rb
 - lib/liquid-arrays/hash_delete_tag.rb
+- lib/liquid-arrays/hash_helper.rb
 - lib/liquid-arrays/hash_set_tag.rb
-- lib/liquid-arrays/hash_tag.rb
+- lib/liquid-arrays/hash_variable.rb
 - lib/liquid-arrays/version.rb
 homepage: https://github.com/Frostphyr/liquid-arrays
 licenses:

data/lib/liquid-arrays/array_tag.rb

@@ -1,22 +0,0 @@
-module Arrays
-  class ArrayTag < Liquid::Tag
-    def get_array(context, create)
-      unless @array_name.nil?
-        if context.key?(@array_name)
-          array = context[@array_name]
-        elsif create
-          array = context[@array_name] ||= []
-        end
-      else
-        if context.key?('block_array')
-          array = context['block_array']
-        end
-      end
-      array
-    end
-
-    def out_of_bounds?(array, index)
-      index < 0 || index >= array.length
-    end
-  end
-end

data/lib/liquid-arrays/hash_tag.rb

@@ -1,18 +0,0 @@
-module Arrays
-  class HashTag < Liquid::Tag
-    def get_hash(context, create)
-      unless @hash_name.nil?
-        if context.key?(@hash_name)
-          hash = context[@hash_name]
-        elsif create
-          hash = context[@hash_name] ||= {}
-        end
-      else
-        if context.key?('block_hash')
-          hash = context['block_hash']
-        end
-      end
-      hash
-    end
-  end
-end