dynamini 2.1.2 → 2.2.0

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA1:
-  metadata.gz: f7b0c9b660d05e9791a38a79ee09b2847d9dff48
-  data.tar.gz: 5262cf9c63c4a2152a1182c2037712855e35ffda
+  metadata.gz: bc4e5ccebe6f491cae52d735aa59d15b307e93ab
+  data.tar.gz: fc6340c78b0597b67c870e4aa75837c38e2d7c2f
 SHA512:
-  metadata.gz: ad4de22dd7dce271017ee4badda3ce8babc3bb3b97592f88bb03c2485af77fc74a621e0bea47c7f9c610d7e39c2b7ac939fdbdf4b67672bccc5cabe20a769952
-  data.tar.gz: 06646d44a9ae44ae92560f4800ce3a5c6421405b915ab3dbcce0e721d246f3b1eaab59ac7122307025ee2b09246ee27050dea5ea9f2961eb09645f9daaf54e88
+  metadata.gz: f75b4504629a2dbcd718c0fb5c150a7c9911cbd255046fbc180704c13f7350d409beb2567939f4c1ace8d808692ed1ac7d835e615c09f8719f3657a81159ecdc
+  data.tar.gz: dd4b0336585dfb376f51f4a142a278aaaa8814713aa5c363b50928c70b4ee20ee85d9ec14e6c48ec62581e30789b9e78c54b664b7f4bca1f5b2554943f76fe53

data/Gemfile.lock

@@ -1,7 +1,7 @@
 PATH
   remote: .
   specs:
-    dynamini (2.1.2)
+    dynamini (2.2.0)
       activemodel (>= 3, < 5.0)
       aws-sdk (~> 2)
 
@@ -99,3 +99,6 @@ DEPENDENCIES
   guard-shell
   pry (~> 0)
   rspec (~> 3)
+
+BUNDLED WITH
+   1.11.2

data/dynamini.gemspec

@@ -1,6 +1,6 @@
 Gem::Specification.new do |s|
   s.name = 'dynamini'
-  s.version = '2.1.2'
+  s.version = '2.2.0'
   s.summary = 'DynamoDB interface'
   s.description = 'Lightweight DynamoDB interface gem designed as
                    a drop-in replacement for ActiveRecord.

data/lib/dynamini/base.rb

@@ -30,7 +30,7 @@ module Dynamini
 
     class << self
 
-      attr_reader :range_key
+      attr_reader :range_key, :secondary_index
 
       def table_name
         @table_name ||= name.demodulize.tableize
@@ -48,6 +48,11 @@ module Dynamini
         @range_key = key
       end
 
+      def set_secondary_index(index_name, args)
+        @secondary_index ||= {}
+        @secondary_index[index_name.to_s] = {hash_key_name: args[:hash_key] || hash_key, range_key_name: args[:range_key]}
+      end
+
       def hash_key
         @hash_key || :id
       end

data/lib/dynamini/querying.rb

@@ -51,14 +51,14 @@ module Dynamini
     def dynamo_query(args)
       expression_attribute_values = build_expression_attribute_values(args)
       key_condition_expression = build_key_condition_expression(args)
-
-      client.query(set_extra_parameters(
-                     {
-                       table_name: table_name,
-                       key_condition_expression: key_condition_expression,
-                       expression_attribute_values: expression_attribute_values
-                     },
-                     args))
+      query = set_extra_parameters(
+          {
+              table_name: table_name,
+          key_condition_expression: key_condition_expression,
+          expression_attribute_values: expression_attribute_values
+      },
+          args)
+      client.query(query)
     end
 
     def build_expression_attribute_values(args)
@@ -70,19 +70,28 @@ module Dynamini
     end
 
     def build_key_condition_expression(args)
-      expression = "#{hash_key} = :h"
+      expression = "#{current_index_hash_key(args)} = :h"
       if args[:start] && args[:end]
-        expression += " AND #{range_key} BETWEEN :s AND :e"
+        expression += " AND #{current_index_range_key(args)} BETWEEN :s AND :e"
       elsif args[:start]
-        expression += " AND #{range_key} >= :s"
+        expression += " AND #{current_index_range_key(args)} >= :s"
       elsif args[:end]
-        expression += " AND #{range_key} <= :e"
+        expression += " AND #{current_index_range_key(args)} <= :e"
       end
       expression
     end
 
+    def current_index_hash_key(args)
+      args[:index_name] ? secondary_index[args[:index_name].to_s][:hash_key_name] : hash_key
+    end
+
+    def current_index_range_key(args)
+      args[:index_name] ? secondary_index[args[:index_name].to_s][:range_key_name] : range_key
+    end
+
     def set_extra_parameters(hash, args)
       extras = args.select { |k, v| OPTIONAL_QUERY_PARAMS.include? k }
+      extras[:index_name] = args[:index_name].to_s if args[:index_name]
       hash.merge!(extras)
     end
 

data/lib/dynamini/test_client.rb

@@ -4,12 +4,13 @@ module Dynamini
   # In-memory database client for test purposes.
   class TestClient
 
-    attr_reader :hash_key_attr, :data, :range_key_attr
+    attr_reader :hash_key_attr, :data, :range_key_attr, :secondary_index
 
-    def initialize(hash_key_attr, range_key_attr = nil)
+    def initialize(hash_key_attr, range_key_attr = nil, secondary_index=nil)
       @data = {}
       @hash_key_attr = hash_key_attr
       @range_key_attr = range_key_attr
+      @secondary_index = secondary_index
     end
 
     def get_table(table_name)
@@ -28,27 +29,34 @@ module Dynamini
           hash_key_attr => hash_key_value
       )
 
-      if hash_key_value
-        if range_key_value
-          updates.merge!(range_key_attr => range_key_value)
-          if table[hash_key_value] && table[hash_key_value][range_key_value]
-            table[hash_key_value][range_key_value].merge! updates
-          else
-            table[hash_key_value] ||= {}
-            table[hash_key_value][range_key_value] = updates
-          end
+      primary_index_insertion(hash_key_value, range_key_value, updates, table) if hash_key_value
 
-        else
-          if table[hash_key_value]
-            table[hash_key_value].merge!(updates)
-          else
-            table[hash_key_value] = updates
-          end
-        end
+    end
+
+    def primary_index_insertion(hash_key_value, range_key_value, updates, table)
+      if range_key_value
+        primary_with_range_insertion(hash_key_value, range_key_value, updates, table)
+      else
+        primary_only_hash_insertion(hash_key_value, updates, table)
+      end
+    end
+
+    def primary_with_range_insertion(hash_key_value, range_key_value, updates, table)
+      updates.merge!(range_key_attr => range_key_value)
+      if table[hash_key_value] && table[hash_key_value][range_key_value]
+        table[hash_key_value][range_key_value].merge! updates
+      else
+        table[hash_key_value] ||= {}
+        table[hash_key_value][range_key_value] = updates
       end
+    end
 
+    def primary_only_hash_insertion(hash_key_value, updates, table)
+      table[hash_key_value] ? table[hash_key_value].merge!(updates) : table[hash_key_value] = updates
     end
 
+
+
     def get_item(args = {})
       table = get_table(args[:table_name])
 
@@ -103,39 +111,85 @@ module Dynamini
       end
 
       tokens = args[:key_condition_expression].split(/\s+/)
-      hash_key = args[:expression_attribute_values][":h"].is_a?(Integer) ? tokens[2].to_i : tokens[2]
+      start_val, end_val = range_key_limits(tokens)
+
+      if args[:index_name]
+        secondary_index_query(args)
+      else
+        hash_key = hash_key_value(args).is_a?(Integer) ? tokens[2].to_i : tokens[2]
+
+        parent = get_table(args[:table_name])[hash_key]
+        return OpenStruct.new(items: []) unless parent
+        selected = apply_filter_options(parent, args, start_val, end_val)
+
+        OpenStruct.new(items: selected)
+      end
+    end
+
+    def range_key_limits(tokens)
       case tokens[5]
-        when ">="
-          start_val = tokens[6]
-          end_val = nil
-        when "<="
-          start_val = nil
-          end_val = tokens[6]
-        when "BETWEEN"
-          start_val = tokens[6]
-          end_val = tokens[8]
-        else
-          start_val = nil
-          end_val = nil
+        when ">=" then [tokens[6], nil]
+        when "<=" then [nil, tokens[6]]
+        when "BETWEEN" then [tokens[6], tokens[8]]
+        else [nil, nil]
       end
-      parent = get_table(args[:table_name])[hash_key]
-      return OpenStruct.new(items:[]) unless parent
+    end
 
-      selected = parent.values
-      selected = selected.select{ |item| item[@range_key_attr] >= start_val.to_f } if start_val
-      selected = selected.select{ |item| item[@range_key_attr] <= end_val.to_f } if end_val
-      selected = selected.sort! { |a,b| b[@range_key_attr] <=> a[@range_key_attr] } if args[:scan_index_forward] == false
-      selected = selected[0...args[:limit]] if args[:limit]
+    def apply_filter_options(parent, args, start_val, end_val)
+      records = parent.values
+      records = records.select { |record| record[@range_key_attr] >= start_val.to_f } if start_val
+      records = records.select { |record| record[@range_key_attr] <= end_val.to_f } if end_val
+      records = records.sort! { |a, b| b[@range_key_attr] <=> a[@range_key_attr] } if args[:scan_index_forward] == false
+      records = records[0...args[:limit]] if args[:limit]
+      records
+    end
 
+
+    def secondary_index_query(args = {})
+      index = secondary_index[args[:index_name]]
+      table = get_table(args[:table_name])
+
+      tokens = args[:key_condition_expression].split(/\s+/)
+      start_val, end_val = range_key_limits(tokens)
+
+      records = @range_key_attr ? get_values(table) : table.values
+      selected = sort_records(records, index, args, start_val, end_val)
       OpenStruct.new(items: selected)
     end
 
+    def sort_records(records, index, args, start_val, end_val)
+      records = records.select { |record| record[get_secondary_hash_key(index)] == hash_key_value(args) }
+      records = records.select { |record| record[get_secondary_range_key(index)] >= start_val.to_f } if start_val
+      records = records.select { |record| record[get_secondary_range_key(index)] <= end_val.to_f } if end_val
+      records = records.sort { |a, b| a[get_secondary_range_key(index)] <=> b[get_secondary_range_key(index)] }
+      records = records.reverse if args[:scan_index_forward] == false
+      records = records[0...args[:limit]] if args[:limit]
+      records
+    end
+
+    def get_secondary_hash_key(index)
+      index[:hash_key_name] == @hash_key_attr ? index[:hash_key_name] : index[:hash_key_name].to_s
+    end
+
+    def get_secondary_range_key(index)
+      index[:range_key_name] == @range_key_attr ? index[:range_key_name] : index[:range_key_name].to_s
+    end
+
     def reset
       @data = {}
     end
 
     private
 
+    def hash_key_value(args)
+      args[:expression_attribute_values][":h"]
+    end
+
+    def get_values(table, records=[])
+      table.values.each { |value| records += value.values }
+      records
+    end
+
     def flatten_attribute_updates(args = {})
       attribute_hash = {}
 

data/lib/dynamini/testing.rb

@@ -4,7 +4,7 @@ module Dynamini
   module ClientInterface
     module ClassMethods
       def client
-        @client ||= Dynamini::TestClient.new(hash_key, range_key)
+        @client ||= Dynamini::TestClient.new(hash_key, range_key, secondary_index)
       end
     end
   end

data/spec/dynamini/base_spec.rb

@@ -481,6 +481,28 @@ describe Dynamini::Base do
         end
       end
     end
+
+    describe '#set_secondary_index' do
+      it 'should return an hash containing only the hash_key and range_key name and value when setting a global secondary index' do
+        class TestClass < Dynamini::Base
+          set_hash_key :foo
+          set_range_key :bar
+          set_secondary_index :git_baz, hash_key: :git, range_key: :baz
+        end
+
+        expect(TestClass.secondary_index['git_baz']).to eq(hash_key_name: :git, range_key_name: :baz)
+      end
+
+      it 'should return an hash containing only the hash_key and range_key name and value when setting a local secondary index' do
+        class TestClass < Dynamini::Base
+          set_hash_key :foo
+          set_range_key :bar
+          set_secondary_index :foo_baz, range_key: :baz
+        end
+
+        expect(TestClass.secondary_index['foo_baz']).to eq(hash_key_name: :foo, range_key_name: :baz)
+      end
+    end
   end
 end
 

data/spec/dynamini/querying_spec.rb

@@ -16,7 +16,9 @@ describe Dynamini::Querying do
   class TestClassWithRange < Dynamini::Base
     set_hash_key :foo
     set_range_key :bar
+    set_secondary_index :secondary_index, hash_key: :secondary_hash_key, range_key: :secondary_range_key
     handle :bar, :integer
+    handle :secondary_range_key, :integer
   end
 
   describe '.find' do
@@ -53,8 +55,10 @@ describe Dynamini::Querying do
   describe '.query' do
     before do
       4.times do |i|
-        TestClassWithRange.create(foo: 'foo', bar: i + 1)
+        TestClassWithRange.create(foo: 'foo', bar: i + 1, secondary_hash_key: 'secondary_hash_key', secondary_range_key: 10 - i)
       end
+      TestClassWithRange.create(foo: 'foo2', bar: 5, secondary_hash_key: 'secondary_hash_key', secondary_range_key: 6)
+
     end
     context 'start value provided' do
       it 'should return records with a range key greater than or equal to the start value' do
@@ -129,6 +133,55 @@ describe Dynamini::Querying do
         expect(records.last.bar).to eq 1
       end
     end
+
+    context 'using secondary index' do
+      it 'should be able to query using the secondary index' do
+        records = TestClassWithRange.query(hash_key: 'secondary_hash_key', index_name: :secondary_index)
+        expect(records.length).to eq(5)
+        expect(records.first.secondary_range_key).to eq(6)
+        expect(records.last.secondary_range_key).to eq(10)
+      end
+
+      it 'should be able to sort backwards' do
+        records = TestClassWithRange.query(hash_key: 'secondary_hash_key', index_name: :secondary_index, scan_index_forward: false)
+        expect(records.length).to eq(5)
+        expect(records.first.secondary_range_key).to eq(10)
+        expect(records.last.secondary_range_key).to eq(6)
+      end
+
+      it 'should be able to limit number of results' do
+        records = TestClassWithRange.query(hash_key: 'secondary_hash_key', index_name: :secondary_index, limit: 3)
+        expect(records.length).to eq(3)
+        expect(records.first.secondary_range_key).to eq(6)
+        expect(records.last.secondary_range_key).to eq(8)
+      end
+
+      it 'should be able to give a minimum value for the range key' do
+        records = TestClassWithRange.query(hash_key: 'secondary_hash_key', index_name: :secondary_index, start: 8)
+        expect(records.length).to eq(3)
+        expect(records.first.secondary_range_key).to eq(8)
+        expect(records.last.secondary_range_key).to eq(10)
+      end
+
+      it 'should be able to give a maximum for the range key' do
+        records = TestClassWithRange.query(hash_key: 'secondary_hash_key', index_name: :secondary_index, end: 8)
+        expect(records.length).to eq(3)
+        expect(records.first.secondary_range_key).to eq(6)
+        expect(records.last.secondary_range_key).to eq(8)
+      end
+
+      it 'should be able to give a maximum for the range key' do
+        records = TestClassWithRange.query(hash_key: 'secondary_hash_key', index_name: :secondary_index, start: 7, end: 9)
+        expect(records.length).to eq(3)
+        expect(records.first.secondary_range_key).to eq(7)
+        expect(records.last.secondary_range_key).to eq(9)
+      end
+
+      it 'should return no results if none are found with the secondary index' do
+        expect(TestClassWithRange.query(hash_key: 'non-existent key', index_name: :secondary_index)).to eq([])
+      end
+
+    end
   end
 
   describe '.exists?' do

data/spec/dynamini/test_client_spec.rb

@@ -99,11 +99,11 @@ describe Dynamini::TestClient do
 
   describe '#query' do
 
-    let(:test_client) { Dynamini::TestClient.new(:hash_key_field, :range_key_field) }
+    let(:test_client) { Dynamini::TestClient.new(:hash_key_field, :range_key_field, {'secondary_index' => {hash_key_name: 'abc', range_key_name: :secondary_range_key }})}
 
     before do
       4.times do |i|
-        test_client.update_item(table_name: table_name, key: {hash_key_field: 'foo', range_key_field: i + 1}, attribute_updates: {abc: {value: 'abc', action: 'PUT'}})
+        test_client.update_item(table_name: table_name, key: {hash_key_field: 'foo', range_key_field: i + 1}, attribute_updates: {'abc' => {value: 'abc', action: 'PUT'}, 'secondary_range_key' => {value: 10 - i, action: 'PUT'}})
       end
     end
 
@@ -126,63 +126,146 @@ describe Dynamini::TestClient do
     context 'with LE operator' do
       it 'should return all items with range key less than or equal to the provided value' do
         response = test_client.query(
-            table_name: table_name,
-            key_condition_expression: "hash_key_field = :h AND user_id <= :e",
-            expression_attribute_values: {
-                ":h" => 'foo',
-                ":e" => 2
-            }
+          table_name: table_name,
+          key_condition_expression: "hash_key_field = :h AND user_id <= :e",
+          expression_attribute_values: {
+            ":h" => 'foo',
+            ":e" => 2
+          }
         )
         expect(response.items.length).to eq(2)
         expect(response.items.first[:range_key_field]).to eq(1)
         expect(response.items.last[:range_key_field]).to eq(2)
       end
     end
+
     context 'with GE operator' do
       it 'should return all items with range key greater than or equal to the provided value' do
         response = test_client.query(
-            table_name: table_name,
-            key_condition_expression: "hash_key_field = :h AND user_id >= :s",
-            expression_attribute_values: {
-                ":h" => 'foo',
-                ":s" => 2
-            }
+          table_name: table_name,
+          key_condition_expression: "hash_key_field = :h AND user_id >= :s",
+          expression_attribute_values: {
+            ":h" => 'foo',
+            ":s" => 2
+          }
         )
         expect(response.items.length).to eq(3)
         expect(response.items.first[:range_key_field]).to eq(2)
         expect(response.items.last[:range_key_field]).to eq(4)
       end
     end
+
     context 'with BETWEEN operator' do
       it 'should return all items with range key between the provided values' do
         response = test_client.query(
-            table_name: table_name,
-            key_condition_expression: "hash_key_field = :h AND user_id BETWEEN :s AND :e",
-            expression_attribute_values: {
-                ":h" => 'foo',
-                ":s" => 2,
-                ":e" => 3
-            }
+          table_name: table_name,
+          key_condition_expression: "hash_key_field = :h AND user_id BETWEEN :s AND :e",
+          expression_attribute_values: {
+            ":h" => 'foo',
+            ":s" => 2,
+            ":e" => 3
+          }
         )
         expect(response.items.length).to eq(2)
         expect(response.items.first[:range_key_field]).to eq(2)
         expect(response.items.last[:range_key_field]).to eq(3)
       end
     end
+
     context 'with no operator' do
       it 'should return all items with range key between the provided values' do
         response = test_client.query(
-            table_name: table_name,
-            key_condition_expression: "hash_key_field = :h",
-            expression_attribute_values: {
-                ":h" => 'foo'
-            }
+          table_name: table_name,
+          key_condition_expression: "hash_key_field = :h",
+          expression_attribute_values: {
+            ":h" => 'foo'
+          }
         )
         expect(response.items.length).to eq(4)
         expect(response.items.first[:range_key_field]).to eq(1)
         expect(response.items.last[:range_key_field]).to eq(4)
       end
     end
+
+    context 'with secondary index' do
+      before do
+        test_client.update_item(table_name: table_name,
+            key: {hash_key_field: 'bar', range_key_field: 10},
+            attribute_updates: {'abc' => {value: 'abc', action: 'PUT'},
+            'secondary_range_key' => {value: 11, action: 'PUT'}})
+      end
+
+      context 'with LE operator' do
+        it 'should return all items with secondary range key less than or equal to the provided value' do
+          response = test_client.query(
+              table_name: table_name,
+              key_condition_expression: "abc = :h AND secondary_range_key <= :e",
+              expression_attribute_values: {
+                ":h" => 'abc',
+                ":e" => 8
+              },
+              index_name: 'secondary_index'
+          )
+          expect(response.items.length).to eq(2)
+          expect(response.items.first['secondary_range_key']).to eq(7)
+          expect(response.items.last['secondary_range_key']).to eq(8)
+        end
+      end
+
+      context 'with GE operator' do
+        it 'should return all items with secondary range key greater than or equal to the provided value' do
+          response = test_client.query(
+              table_name: table_name,
+              key_condition_expression: "abc = :h AND secondary_range_key >= :s",
+              expression_attribute_values: {
+                ":h" => 'abc',
+                ":s" => 8
+              },
+              index_name: 'secondary_index'
+          )
+          expect(response.items.length).to eq(4)
+          expect(response.items.first['secondary_range_key']).to eq(8)
+          expect(response.items.last['secondary_range_key']).to eq(11)
+        end
+      end
+
+      context 'with BETWEEN operator' do
+        it 'should return all items with secondary range key between the provided values' do
+          response = test_client.query(
+              table_name: table_name,
+              key_condition_expression: "abc = :h AND secondary_range_key BETWEEN :s AND :e",
+              expression_attribute_values: {
+                ":h" => 'abc',
+                ":s" => 8,
+                ":e" => 9
+              },
+              index_name: 'secondary_index'
+          )
+          expect(response.items.length).to eq(2)
+          expect(response.items.first['secondary_range_key']).to eq(8)
+          expect(response.items.last['secondary_range_key']).to eq(9)
+        end
+      end
+
+      context 'with no operator' do
+        it 'should return all items sorted by their secondary index' do
+          response = test_client.query(
+              table_name: table_name,
+              key_condition_expression: "abc = :h",
+              expression_attribute_values: {
+                ":h" => 'abc'
+              },
+              index_name: 'secondary_index'
+          )
+
+          expect(response.items.length).to eq(5)
+          expect(response.items.first['secondary_range_key']).to eq(7)
+          expect(response.items.last['secondary_range_key']).to eq(11)
+        end
+      end
+
+    end
+
   end
 
   describe '#batch_write_item' do

metadata

@@ -1,7 +1,7 @@
 --- !ruby/object:Gem::Specification
 name: dynamini
 version: !ruby/object:Gem::Version
-  version: 2.1.2
+  version: 2.2.0
 platform: ruby
 authors:
 - Greg Ward
@@ -15,110 +15,110 @@ authors:
 autorequire: 
 bindir: bin
 cert_chain: []
-date: 2016-03-03 00:00:00.000000000 Z
+date: 2016-03-08 00:00:00.000000000 Z
 dependencies:
 - !ruby/object:Gem::Dependency
   name: activemodel
   requirement: !ruby/object:Gem::Requirement
     requirements:
-    - - '>='
+    - - ">="
       - !ruby/object:Gem::Version
         version: '3'
-    - - <
+    - - "<"
       - !ruby/object:Gem::Version
         version: '5.0'
   type: :runtime
   prerelease: false
   version_requirements: !ruby/object:Gem::Requirement
     requirements:
-    - - '>='
+    - - ">="
       - !ruby/object:Gem::Version
         version: '3'
-    - - <
+    - - "<"
       - !ruby/object:Gem::Version
         version: '5.0'
 - !ruby/object:Gem::Dependency
   name: aws-sdk
   requirement: !ruby/object:Gem::Requirement
     requirements:
-    - - ~>
+    - - "~>"
       - !ruby/object:Gem::Version
         version: '2'
   type: :runtime
   prerelease: false
   version_requirements: !ruby/object:Gem::Requirement
     requirements:
-    - - ~>
+    - - "~>"
       - !ruby/object:Gem::Version
         version: '2'
 - !ruby/object:Gem::Dependency
   name: rspec
   requirement: !ruby/object:Gem::Requirement
     requirements:
-    - - ~>
+    - - "~>"
       - !ruby/object:Gem::Version
         version: '3'
   type: :development
   prerelease: false
   version_requirements: !ruby/object:Gem::Requirement
     requirements:
-    - - ~>
+    - - "~>"
       - !ruby/object:Gem::Version
         version: '3'
 - !ruby/object:Gem::Dependency
   name: pry
   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: fuubar
   requirement: !ruby/object:Gem::Requirement
     requirements:
-    - - ~>
+    - - "~>"
       - !ruby/object:Gem::Version
         version: '2'
   type: :development
   prerelease: false
   version_requirements: !ruby/object:Gem::Requirement
     requirements:
-    - - ~>
+    - - "~>"
       - !ruby/object:Gem::Version
         version: '2'
 - !ruby/object:Gem::Dependency
   name: guard-rspec
   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: guard-shell
   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: |-
@@ -130,9 +130,9 @@ executables: []
 extensions: []
 extra_rdoc_files: []
 files:
-- .gitignore
-- .rspec
-- .travis.yml
+- ".gitignore"
+- ".rspec"
+- ".travis.yml"
 - Gemfile
 - Gemfile.lock
 - Guardfile
@@ -170,17 +170,17 @@ 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.2.2
+rubygems_version: 2.4.6
 signing_key: 
 specification_version: 4
 summary: DynamoDB interface