dottie 0.0.1 → 0.0.3

checksums.yaml

@@ -1,7 +1,7 @@
 ---
-SHA1:
-  metadata.gz: a050415bffe078f5aa5be713416cfb686a9ec913
-  data.tar.gz: 6f9af95ef6a28fbd9a07ae1fdc3b519c9c4a77d9
+SHA256:
+  metadata.gz: 56422c24e86966e8928fdd65ae47c56527a1ac72c75d0d6ff7674fa6c467088b
+  data.tar.gz: 815ece0b81778ef2ab9a66dbe8e467fffc1500a73ca7f30e2d13957d51ad83fe
 SHA512:
-  metadata.gz: 46a17f46eb85e0757d222f1e1c2e81ab6e1cccc4657d5e6f723a091edf69013c6553b0b3cfe8e37409bd0c43a46eef739a8f85a7ce4c3f5a2241dea843e9b744
-  data.tar.gz: 06f2654c46e34627a7de943f59c9f2209413a5f3306733a4e34ebdfdbfc7322f89e780610a34ee890893770c23652cc4697cb5390f0be58536eb9f18025b8ff2
+  metadata.gz: '0878011a1e5a80b62a8aedcc81b48da2777768d5d2011829e4669db535c2999e6c2b41ab668bbfe7d209d35e123bcd669ee434c377c3344924ff462c6d349eca'
+  data.tar.gz: f371ca692a797e919b6f4ad89cd205365d4e06e8f1d422ce753221d151524ee9a4637c7ef9e63e77d5562618307b71cc31ed891b3ab82e1f4341fee59b08c20b

data/README.md

@@ -115,6 +115,21 @@ complex.hash # => {"a"=>[{"b"=>"x"}, {"d"=>"e"}]}
 # add another array element
 complex['a[2]'] = 'y'
 complex.hash # => {"a"=>[{"b"=>"x"}, {"d"=>"e"}, "y"]}
+
+# elements can also be prepended and appended to arrays
+complex['a[+]'] = 'z' # can also use 'a[<<]' and 'a[append]'
+complex.hash # => {"a"=>[{"b"=>"x"}, {"d"=>"e"}, "y", "z"]}
+
+complex['a[-]'] = 'p' # can also use 'a[>>]' and 'a[prepend]'
+complex.hash # => {"a"=>["p", {"b"=>"x"}, {"d"=>"e"}, "y", "z"]}
+
+# use delete as you would on a Hash
+complex.delete('a[1].b') # => "x"
+complex.hash # => {"a"=>["p", {}, {"d"=>"e"}, "y", "z"]}
+
+# delete an element at an array index
+complex.delete('a[1]') # => {}
+complex.hash # => {"a"=>["p", {"d"=>"e"}, "y", "z"]}
 ```
 
 ### Dottie Usage Options

data/Rakefile

@@ -2,7 +2,7 @@ require 'rspec/core/rake_task'
 require 'bundler/gem_tasks'
 
 RSpec::Core::RakeTask.new(:spec) do |task|
-  task.rspec_opts = ['--color', '--format', 'nested']
+  task.rspec_opts = ['--color', '--format', 'progress']
 end
 
 task default: :spec

data/dottie.gemspec

@@ -20,7 +20,7 @@ Gem::Specification.new do |spec|
   spec.test_files    = spec.files.grep(%r{^(test|spec|features)/})
   spec.require_paths = ["lib"]
 
-  spec.add_development_dependency "bundler", "~> 1.5"
+  spec.add_development_dependency "bundler", ">= 2.2.33"
   spec.add_development_dependency "rake"
   spec.add_development_dependency "rspec"
 end

data/lib/dottie/freckle.rb

@@ -6,7 +6,12 @@ module Dottie
     # Creates a new Freckle to wrap the supplied object.
     
     def initialize(obj)
-      @_wrapped_object = obj
+      case obj
+      when Hash, Array
+        @_wrapped_object = obj
+      else
+        raise TypeError, 'must be a Hash or Array'
+      end
     end
     
     ##

data/lib/dottie/methods.rb

@@ -56,6 +56,31 @@ module Dottie
       end
     end
     
+    ##
+    # Deletes the value at the specified key and returns it.
+    
+    def delete(key)
+      if Dottie.dottie_key?(key)
+        Dottie.delete(wrapped_object_or_self, key)
+      else
+        super
+      end
+    end
+    
+    ##
+    # 
+    
+    def dottie_flatten
+      Dottie.flatten(wrapped_object_or_self)
+    end
+    
+    ##
+    # 
+    
+    def dottie_keys(intermediate = false)
+      Dottie.keys(wrapped_object_or_self, intermediate: intermediate)
+    end
+    
     private
       
       ##

data/lib/dottie/version.rb

@@ -1,3 +1,3 @@
 module Dottie
-  VERSION = '0.0.1'
+  VERSION = '0.0.3'
 end

data/lib/dottie.rb

@@ -10,7 +10,11 @@ module Dottie
   # Creates a new Dottie::Freckle from a standard Ruby Hash or Array.
   
   def self.[](obj)
-    Dottie::Freckle.new(obj)
+    if obj.is_a?(Dottie::Freckle)
+      obj
+    else
+      Dottie::Freckle.new(obj)
+    end
   end
   
   ##
@@ -21,6 +25,8 @@ module Dottie
     Dottie.key_parts(key).each do |k|
       obj = case obj
       when Hash, Array
+        # use an array index if it appears that's what was intended
+        k = k.to_i if obj.is_a?(Array) && k.to_i.to_s == k
         obj[k]
       else
         nil
@@ -39,8 +45,17 @@ module Dottie
       # set the value if this is the last key part
       if i == key_parts.size - 1
         case obj
-        when Hash, Array
+        when Hash
           obj[k] = value
+        when Array
+          case k
+          when '-', 'prepend', '>>'
+            obj.unshift(value)
+          when '+', 'append', '<<'
+            obj << value
+          else
+            obj[k] = value
+          end
         else
           raise TypeError.new("expected Hash or Array but got #{obj.class.name}")
         end
@@ -49,7 +64,8 @@ module Dottie
         obj = case obj
         when Hash, Array
           # look ahead at the next key to see if an array should be created
-          if key_parts[i + 1].is_a?(Integer)
+          if key_parts[i + 1].is_a?(Integer) ||
+             key_parts[i + 1] =~ /\A(-|\+|prepend|append|>>|<<)\z/
             obj[k] ||= []
           else
             obj[k] ||= {}
@@ -57,7 +73,7 @@ module Dottie
         when nil
           # look at the key to see if an array should be created
           case k
-          when Integer
+          when Integer, '-', '+', 'prepend', 'append', '>>', '<<'
             obj[k] = []
           else
             obj[k] = {}
@@ -113,6 +129,71 @@ module Dottie
     end
   end
   
+  ##
+  # Deletes the value at the specified key and returns it.
+  
+  def self.delete(obj, key)
+    if Dottie.has_key?(obj, key)
+      key_parts = Dottie.key_parts(key)
+      if key_parts.size > 1
+        key = Dottie.build_key(key_parts[0..-2])
+        obj = Dottie.get(obj, key)
+      end
+      if obj.is_a?(Array) && key_parts.last.is_a?(Integer)
+        obj.delete_at(key_parts.last)
+      else
+        obj.delete(key_parts.last)
+      end
+    else
+      nil
+    end
+  end
+  
+  ##
+  # Flattens a Hash or Array to a single-depth Hash with Dottie-style keys.
+  
+  def self.flatten(obj, options = {}, path = nil, flat = nil)
+    path ||= []
+    flat ||= {}
+    case obj
+    when Hash
+      obj.each do |k, v|
+        this_path = path + [k]
+        case v
+        when Hash, Array
+          flat[this_path.join('.')] = options[:keys_only] ? nil : v if options[:intermediate]
+          Dottie.flatten(v, options, this_path, flat)
+        else
+          flat[this_path.join('.')] = options[:keys_only] ? nil : v
+        end
+      end
+    when Array
+      obj.each_with_index do |v, i|
+        this_path = path.dup
+        if this_path.any?
+          this_path[-1] = this_path[-1].to_s + "[#{i}]"
+        else
+          this_path = ["[#{i}]"]
+        end
+        case v
+        when Hash, Array
+          flat[this_path.join('.')] = options[:keys_only] ? nil : v if options[:intermediate]
+          Dottie.flatten(v, options, this_path, flat)
+        else
+          flat[this_path.join('.')] = options[:keys_only] ? nil : v
+        end
+      end
+    end
+    flat
+  end
+  
+  ##
+  # Gets an array of the Dottie-style keys that exist in a Hash or Array.
+  
+  def self.keys(obj, options = {})
+    Dottie.flatten(obj, { keys_only: true }.merge(options)).keys
+  end
+  
   ##
   # Checks whether a key looks like a key Dottie understands.
   
@@ -150,4 +231,21 @@ module Dottie
     end
   end
   
+  ##
+  # Builds a Dottie key from an Array of strings and integers.
+  
+  def self.build_key(parts)
+    key = ''
+    parts.each_with_index do |part, i|
+      case part
+      when String
+        key << '.' unless i == 0
+        key << part
+      when Integer
+        key << "[#{part}]"
+      end
+    end
+    key
+  end
+  
 end

data/spec/dottie_spec.rb

@@ -20,6 +20,30 @@ describe Dottie do
       arr = ['a', 'b', 'c']
       expect(Dottie(arr)).to be_a Dottie::Freckle
     end
+    it 'returns a Dottie::Freckle<Hash> instead of rewrapping it using Dottie[]' do
+      dottie = Dottie[{ 'a' => 'b' }]
+      expect(Dottie[dottie]).to eq dottie
+    end
+    it 'returns a Dottie::Freckle<Array> instead of rewrapping it using Dottie[]' do
+      dottie = Dottie[['a', 'b', 'c']]
+      expect(Dottie[dottie]).to eq dottie
+    end
+    it 'returns a Dottie::Freckle<Hash> instead of rewrapping it using Dottie()' do
+      dottie = Dottie({ 'a' => 'b' })
+      expect(Dottie(dottie)).to eq dottie
+    end
+    it 'returns a Dottie::Freckle<Array> instead of rewrapping it using Dottie()' do
+      dottie = Dottie(['a', 'b', 'c'])
+      expect(Dottie(dottie)).to eq dottie
+    end
+    ['a', nil, 1].each do |val|
+      it "fails to create a Dottie::Freckle from an invalid type (#{val.class}) using Dottie[]" do
+        expect{ Dottie[val] }.to raise_error(TypeError)
+      end
+      it "fails to create a Dottie::Freckle from an invalid type (#{val.class}) using Dottie()" do
+        expect{ Dottie(val) }.to raise_error(TypeError)
+      end
+    end
     
   end
   
@@ -120,34 +144,48 @@ describe Dottie do
       end
     end
     
+    context 'lax keys' do
+      let(:hash) {{ 'a' => 'b', 'c' => [{ 'd' => 'e', '0' => 1 }, { 'f' => 'g' }] }}
+      
+      it 'reads a targeted array index number as an integer' do
+        expect(Dottie.get(hash, 'c.0.d')).to eq 'e'
+      end
+      it 'reads a targeted hash key number as a string' do
+        expect(Dottie.get(hash, 'c.0.0')).to eq 1
+      end
+      it 'reads an targeted hash key integer as an integer' do
+        expect(Dottie.get(hash, 'c.0[0]')).to be_nil
+      end
+    end
+    
   end
   
   describe 'key existence' do
     let(:hash) {{ 'a' => 'b', 'c' => { 'd' => ['e', 'f', 'g'] } }}
     
     it "finds a standard key" do
-      expect(Dottie.has_key?(hash, 'a')).to be_true
+      expect(Dottie.has_key?(hash, 'a')).to be true
     end
     it "does not find a missing standard key" do
-      expect(Dottie.has_key?(hash, 'x')).to be_false
+      expect(Dottie.has_key?(hash, 'x')).to be false
     end
     it "finds a Dottie key (Hash value)" do
-      expect(Dottie.has_key?(hash, 'c.d')).to be_true
+      expect(Dottie.has_key?(hash, 'c.d')).to be true
     end
     it "finds a Dottie key (Array element)" do
-      expect(Dottie.has_key?(hash, 'c.d[0]')).to be_true
+      expect(Dottie.has_key?(hash, 'c.d[0]')).to be true
     end
     it "does not find a missing Dottie key (first part is a String)" do
-      expect(Dottie.has_key?(hash, 'a.b')).to be_false
+      expect(Dottie.has_key?(hash, 'a.b')).to be false
     end
     it "does not find a missing Dottie key (first part exists)" do
-      expect(Dottie.has_key?(hash, 'c.x')).to be_false
+      expect(Dottie.has_key?(hash, 'c.x')).to be false
     end
     it "does not find a missing Dottie key (outside Array bounds)" do
-      expect(Dottie.has_key?(hash, 'c.d[4]')).to be_false
+      expect(Dottie.has_key?(hash, 'c.d[4]')).to be false
     end
     it "does not find a missing Dottie key (no part exists)" do
-      expect(Dottie.has_key?(hash, 'x.y')).to be_false
+      expect(Dottie.has_key?(hash, 'x.y')).to be false
     end
   end
   
@@ -255,6 +293,31 @@ describe Dottie do
       end
     end
     
+    context 'array prepend/append' do
+      before :each do
+        @hash = { 'a' => 'b', 'c' => ['g', 'h', 'i'] }
+      end
+      
+      %w( - prepend >> ).each do |key|
+        it "prepends an array element with [#{key}]" do
+          Dottie.set(@hash, "c[#{key}]", 'f')
+          expect(@hash).to eq({ 'a' => 'b', 'c' => ['f', 'g', 'h', 'i'] })
+        end
+      end
+      %w( + append << ).each do |key|
+        it "appends an array element with [#{key}]" do
+          Dottie.set(@hash, "c[#{key}]", 'j')
+          expect(@hash).to eq({ 'a' => 'b', 'c' => ['g', 'h', 'i', 'j'] })
+        end
+      end
+      %w( - + prepend append  >> << ).each do |key|
+        it "creates an array at a non-existent key with [#{key}]" do
+          Dottie.set(@hash, "r[#{key}]", 's')
+          expect(@hash).to eq({ 'a' => 'b', 'c' => ['g', 'h', 'i'], 'r' => ['s'] })
+        end
+      end
+    end
+    
     context 'invalid' do
       before :each do
         @hash = { 'a' => 'b', 'c' => { 'd' => 'e' }, 'f' => ['g', 'h'] }
@@ -277,26 +340,130 @@ describe Dottie do
     
   end
   
+  describe 'deleting' do
+    
+    context 'simple' do
+      before :each do
+        @hash = { 'a' => 'b', 'c' => { 'd' => 'e' } }
+      end
+      
+      it 'deletes a standard key' do
+        ret = Dottie.delete(@hash, 'c')
+        expect(ret).to eq({ 'd' => 'e' })
+        expect(@hash).to eq({ 'a' => 'b' })
+      end
+      it 'deletes a dotted key' do
+        ret = Dottie.delete(@hash, 'c.d')
+        expect(ret).to eq 'e'
+        expect(@hash).to eq({ 'a' => 'b', 'c' => {} })
+      end
+      it 'returns nil when attempting to delete a non-existent standard key' do
+        ret = Dottie.delete(@hash, 'x')
+        expect(ret).to be_nil
+        expect(@hash).to eq({ 'a' => 'b', 'c' => { 'd' => 'e' } })
+      end
+      it 'returns nil when attempting to delete a non-existent dotted key' do
+        ret = Dottie.delete(@hash, 'x.y')
+        expect(ret).to be_nil
+        expect(@hash).to eq({ 'a' => 'b', 'c' => { 'd' => 'e' } })
+      end
+    end
+    
+    context 'array indexes' do
+      before :each do
+        @hash = { 'a' => 'b', 'c' => [{ 'd' => 'e', 'f' => 'g' }, { 'h' => 'i' }] }
+      end
+      
+      it 'deletes an element from an array (positive index)' do
+        ret = Dottie.delete(@hash, 'c[0]')
+        expect(ret).to eq({ 'd' => 'e', 'f' => 'g' })
+        expect(@hash).to eq({ 'a' => 'b', 'c' => [{ 'h' => 'i' }] })
+      end
+      it 'deletes an element from an array (negative index)' do
+        ret = Dottie.delete(@hash, 'c[-1]')
+        expect(ret).to eq({ 'h' => 'i' })
+        expect(@hash).to eq({ 'a' => 'b', 'c' => [{ 'd' => 'e', 'f' => 'g' }] })
+      end
+      it 'deletes an element from an array (first)' do
+        ret = Dottie.delete(@hash, 'c[first]')
+        expect(ret).to eq({ 'd' => 'e', 'f' => 'g' })
+        expect(@hash).to eq({ 'a' => 'b', 'c' => [{ 'h' => 'i' }] })
+      end
+      it 'deletes an element from an array (last)' do
+        ret = Dottie.delete(@hash, 'c[last]')
+        expect(ret).to eq({ 'h' => 'i' })
+        expect(@hash).to eq({ 'a' => 'b', 'c' => [{ 'd' => 'e', 'f' => 'g' }] })
+      end
+      it 'deletes an element from a nested structure' do
+        ret = Dottie.delete(@hash, 'c[0].d')
+        expect(ret).to eq('e')
+        expect(@hash).to eq({ 'a' => 'b', 'c' => [{ 'f' => 'g' }, { 'h' => 'i' }] })
+      end
+      it 'returns nil when attempting to delete a non-existent array index' do
+        ret = Dottie.delete(@hash, 'c[3]')
+        expect(ret).to be_nil
+        expect(@hash).to eq({ 'a' => 'b', 'c' => [{ 'd' => 'e', 'f' => 'g' }, { 'h' => 'i' }] })
+      end
+    end
+    
+  end
+  
+  describe 'flattening' do
+    
+    context 'hash' do
+      let(:hash) {{ 'a' => 'b', 'c' => { 'd' => ['e', 'f', 'g'] } }}
+      
+      it 'flattens a hash' do
+        expect(Dottie.flatten(hash)).to eq({ 'a' => 'b', 'c.d[0]' => 'e', 'c.d[1]' => 'f', 'c.d[2]' => 'g' })
+      end
+      it 'gets flattened hash keys' do
+        expect(Dottie.keys(hash)).to eq ['a', 'c.d[0]', 'c.d[1]', 'c.d[2]']
+      end
+      it 'gets all flattened hash keys' do
+        expect(Dottie.keys(hash, intermediate: true)).to eq ['a', 'c', 'c.d', 'c.d[0]', 'c.d[1]', 'c.d[2]']
+      end
+    end
+    
+    context 'array' do
+      let(:arr) { ['x', { 'a' => 'b', 'c' => { 'd' => ['e', 'f', 'g'] } }, 'y'] }
+      
+      it 'flattens an array' do
+        expect(Dottie.flatten(arr)).to eq({
+          '[0]' => 'x',
+          '[1].a' => 'b', '[1].c.d[0]' => 'e', '[1].c.d[1]' => 'f', '[1].c.d[2]' => 'g',
+          '[2]' => 'y' })
+      end
+      it 'gets flattened array keys' do
+        expect(Dottie.keys(arr)).to eq ['[0]', '[1].a', '[1].c.d[0]', '[1].c.d[1]', '[1].c.d[2]', '[2]']
+      end
+      it 'gets all flattened array keys' do
+        expect(Dottie.keys(arr, intermediate: true)).to eq [
+          '[0]', '[1]', '[1].a', '[1].c', '[1].c.d', '[1].c.d[0]', '[1].c.d[1]', '[1].c.d[2]', '[2]']
+      end
+    end
+    
+  end
+  
   describe 'key identification' do
     
     it 'recognizes a dotted key' do
       key = 'a.b.c'
-      expect(Dottie.dottie_key?(key)).to be_true
+      expect(Dottie.dottie_key?(key)).to be true
     end
     
     it 'recognizes a bracketed key' do
       key = 'a[0]b'
-      expect(Dottie.dottie_key?(key)).to be_true
+      expect(Dottie.dottie_key?(key)).to be true
     end
     
     it 'recognizes an array as a Dottie key' do
       key = ['a', 'b', 'c']
-      expect(Dottie.dottie_key?(key)).to be_true
+      expect(Dottie.dottie_key?(key)).to be true
     end
     
     it 'does not recognize a normal key' do
       key = 'a_b_c'
-      expect(Dottie.dottie_key?(key)).to be_false
+      expect(Dottie.dottie_key?(key)).to be false
     end
     
   end
@@ -400,6 +567,34 @@ describe Dottie do
     
   end
   
+  describe 'key building' do
+    
+    it 'builds a single-element key' do
+      expect(Dottie.build_key(['a'])).to eq 'a'
+    end
+    
+    it 'builds a dotted key' do
+      expect(Dottie.build_key(['a', 'b', 'c'])).to eq 'a.b.c'
+    end
+    
+    it 'builds a dotted key a number' do
+      expect(Dottie.build_key(['a', '0', '1', 'b'])).to eq 'a.0.1.b'
+    end
+    
+    it 'builds a complex key with a positive integer' do
+      expect(Dottie.build_key(['a', 0, 'b'])).to eq 'a[0].b'
+    end
+    
+    it 'builds a complex key with a negative integer' do
+      expect(Dottie.build_key(['a', -1, 'b'])).to eq 'a[-1].b'
+    end
+    
+    it 'builds a complex key with consecutive integers' do
+      expect(Dottie.build_key(['a', 0, 1, 'b'])).to eq 'a[0][1].b'
+    end
+    
+  end
+  
   describe 'key format variants' do
     let(:arr) { ['a', 0, 'b', 1, 'c', -2, 'd', -1, 'e'] }
     

data/spec/freckle_spec.rb

@@ -2,6 +2,22 @@ require 'spec_helper'
 
 describe Dottie::Freckle do
   
+  describe 'instantiation' do
+    
+    it 'creates a Dottie::Freckle from a Hash' do
+      expect(Dottie::Freckle.new({ 'a' => 'b' })).to be_a Dottie::Freckle
+    end
+    it 'creates a Dottie::Freckle from an Array' do
+      expect(Dottie::Freckle.new(['a', 'b', 'c'])).to be_a Dottie::Freckle
+    end
+    ['a', nil, 1].each do |val|
+      it "fails to create a Dottie::Freckle from an invalid type (#{val.class})" do
+        expect{ Dottie::Freckle.new(val) }.to raise_error(TypeError)
+      end
+    end
+    
+  end
+  
   describe 'general' do
     
     context 'Hash' do
@@ -131,28 +147,28 @@ describe Dottie::Freckle do
     let(:freckle) { Dottie::Freckle.new({ 'a' => 'b', 'c' => { 'd' => ['e', 'f', 'g'] } }) }
     
     it "finds a standard key" do
-      expect(freckle.has_key?('a')).to be_true
+      expect(freckle.has_key?('a')).to be true
     end
     it "does not find a missing standard key" do
-      expect(freckle.has_key?('x')).to be_false
+      expect(freckle.has_key?('x')).to be false
     end
     it "finds a Dottie key (Hash value)" do
-      expect(freckle.has_key?('c.d')).to be_true
+      expect(freckle.has_key?('c.d')).to be true
     end
     it "finds a Dottie key (Array element)" do
-      expect(freckle.has_key?('c.d[0]')).to be_true
+      expect(freckle.has_key?('c.d[0]')).to be true
     end
     it "does not find a missing Dottie key (first part is a String)" do
-      expect(freckle.has_key?('a.b')).to be_false
+      expect(freckle.has_key?('a.b')).to be false
     end
     it "does not find a missing Dottie key (first part exists)" do
-      expect(freckle.has_key?('c.x')).to be_false
+      expect(freckle.has_key?('c.x')).to be false
     end
     it "does not find a missing Dottie key (outside Array bounds)" do
-      expect(freckle.has_key?('c.d[4]')).to be_false
+      expect(freckle.has_key?('c.d[4]')).to be false
     end
     it "does not find a missing Dottie key (no part exists)" do
-      expect(freckle.has_key?('x.y')).to be_false
+      expect(freckle.has_key?('x.y')).to be false
     end
   end
   
@@ -271,4 +287,40 @@ describe Dottie::Freckle do
     
   end
   
+  describe 'flattening' do
+    
+    context 'hash' do
+      let(:freckle) { Dottie::Freckle.new({ 'a' => 'b', 'c' => { 'd' => ['e', 'f', 'g'] } }) }
+      
+      it 'flattens a hash' do
+        expect(freckle.dottie_flatten).to eq({ 'a' => 'b', 'c.d[0]' => 'e', 'c.d[1]' => 'f', 'c.d[2]' => 'g' })
+      end
+      it 'gets flattened hash keys' do
+        expect(freckle.dottie_keys).to eq ['a', 'c.d[0]', 'c.d[1]', 'c.d[2]']
+      end
+      it 'gets all flattened hash keys' do
+        expect(freckle.dottie_keys(true)).to eq ['a', 'c', 'c.d', 'c.d[0]', 'c.d[1]', 'c.d[2]']
+      end
+    end
+    
+    context 'array' do
+      let(:freckle) { Dottie::Freckle.new(['x', { 'a' => 'b', 'c' => { 'd' => ['e', 'f', 'g'] } }, 'y']) }
+      
+      it 'flattens an array' do
+        expect(freckle.dottie_flatten).to eq({
+          '[0]' => 'x',
+          '[1].a' => 'b', '[1].c.d[0]' => 'e', '[1].c.d[1]' => 'f', '[1].c.d[2]' => 'g',
+          '[2]' => 'y' })
+      end
+      it 'gets flattened array keys' do
+        expect(freckle.dottie_keys).to eq ['[0]', '[1].a', '[1].c.d[0]', '[1].c.d[1]', '[1].c.d[2]', '[2]']
+      end
+      it 'gets all flattened array keys' do
+        expect(freckle.dottie_keys(true)).to eq [
+          '[0]', '[1]', '[1].a', '[1].c', '[1].c.d', '[1].c.d[0]', '[1].c.d[1]', '[1].c.d[2]', '[2]']
+      end
+    end
+    
+  end
+  
 end

metadata

@@ -1,29 +1,29 @@
 --- !ruby/object:Gem::Specification
 name: dottie
 version: !ruby/object:Gem::Version
-  version: 0.0.1
+  version: 0.0.3
 platform: ruby
 authors:
 - Nick Pearson
-autorequire: 
+autorequire:
 bindir: bin
 cert_chain: []
-date: 2014-05-08 00:00:00.000000000 Z
+date: 2024-03-21 00:00:00.000000000 Z
 dependencies:
 - !ruby/object:Gem::Dependency
   name: bundler
   requirement: !ruby/object:Gem::Requirement
     requirements:
-    - - "~>"
+    - - ">="
       - !ruby/object:Gem::Version
-        version: '1.5'
+        version: 2.2.33
   type: :development
   prerelease: false
   version_requirements: !ruby/object:Gem::Requirement
     requirements:
-    - - "~>"
+    - - ">="
       - !ruby/object:Gem::Version
-        version: '1.5'
+        version: 2.2.33
 - !ruby/object:Gem::Dependency
   name: rake
   requirement: !ruby/object:Gem::Requirement
@@ -85,7 +85,7 @@ homepage: https://github.com/nickpearson/dottie
 licenses:
 - MIT
 metadata: {}
-post_install_message: 
+post_install_message:
 rdoc_options: []
 require_paths:
 - lib
@@ -100,9 +100,8 @@ required_rubygems_version: !ruby/object:Gem::Requirement
     - !ruby/object:Gem::Version
       version: '0'
 requirements: []
-rubyforge_project: 
-rubygems_version: 2.2.2
-signing_key: 
+rubygems_version: 3.2.33
+signing_key:
 specification_version: 4
 summary: Deep Hash and Array access with dotted keys
 test_files:
@@ -111,4 +110,3 @@ test_files:
 - spec/freckle_spec.rb
 - spec/hash_spec.rb
 - spec/spec_helper.rb
-has_rdoc: