dynamini 1.10.1 → 1.10.2

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA1:
-  metadata.gz: 7ac958908500fd7c64b8c6476a6bac8e20c09966
-  data.tar.gz: 48552250242ac4617aae6f21151a90fb2baa5382
+  metadata.gz: 8248aff788be3cda0502be12ccc3768cdf4fc3d4
+  data.tar.gz: 860898330266f91bce5a52d1a4193edce7f64e07
 SHA512:
-  metadata.gz: ac7bd1db86987a5555a33d4958988635e20c005fd9d04e8e8480838b4b90ce6b6fdea4212321b6b83b467be2c970f8db305a9697d5f59d5b2e47eda890a3d141
-  data.tar.gz: 50a9a0a883421c0fc8903eba5f377c71cc4757556acf4af7e3d7e03b10d346b67c2a59962b30e2de22f7cbe072f43107cdeb2665184a87c29a65ec7ca6f66573
+  metadata.gz: 9dc5d37aefc854902b172a271a2b80b5ab22310f507ad2f5c234a60bb81d00b5a2f0a69bdd2ef8fe6c426830fe06d9f985f67d51db62b83a98d4eb8d6a956bee
+  data.tar.gz: 9efb1fd623f05c5eba81660ea04e46873d222634b5aca361b69205e75eccb1ad2c1fef2d53cf44555514eb5eae68aa559aec1ddebdc2a03dd53a49219a6c86ad

data/Gemfile.lock

@@ -1,17 +1,17 @@
 PATH
   remote: .
   specs:
-    dynamini (1.10.1)
+    dynamini (1.10.2)
       activemodel (>= 3, < 5.0)
       aws-sdk (~> 2)
 
 GEM
   remote: https://rubygems.org/
   specs:
-    activemodel (4.2.4)
-      activesupport (= 4.2.4)
+    activemodel (4.2.5)
+      activesupport (= 4.2.5)
       builder (~> 3.1)
-    activesupport (4.2.4)
+    activesupport (4.2.5)
       i18n (~> 0.7)
       json (~> 1.7, >= 1.7.7)
       minitest (~> 5.1)
@@ -56,7 +56,7 @@ GEM
       rb-inotify (>= 0.9)
     lumberjack (1.0.9)
     method_source (0.8.2)
-    minitest (5.8.2)
+    minitest (5.8.3)
     nenv (0.2.0)
     notiffany (0.0.8)
       nenv (~> 0.1)

data/dynamini.gemspec

@@ -1,6 +1,6 @@
 Gem::Specification.new do |s|
   s.name = 'dynamini'
-  s.version = '1.10.1'
+  s.version = '1.10.2'
   s.date = '2015-01-07'
   s.summary = 'DynamoDB interface'
   s.description = 'Lightweight DynamoDB interface gem designed as

data/lib/dynamini/base.rb

@@ -1,10 +1,12 @@
 require_relative 'batch_operations'
+require_relative 'querying'
 
 module Dynamini
   # Core db interface class.
   class Base
     include ActiveModel::Validations
     extend Dynamini::BatchOperations
+    extend Dynamini::Querying
 
     attr_reader :attributes
 
@@ -91,45 +93,6 @@ module Dynamini
         model = new(attributes, true)
         model if model.save!(options)
       end
-
-      def find(hash_value, range_value = nil)
-        fail 'Range key cannot be blank.' if range_key && range_value.nil?
-        response = client.get_item(table_name: table_name, key: create_key_hash(hash_value, range_value))
-        raise 'Item not found.' unless response.item
-        new(response.item.symbolize_keys, false)
-      end
-
-      def exists?(hash_value, range_value = nil)
-        fail 'Range key cannot be blank.' if range_key && range_value.nil?
-
-        r = client.get_item(table_name: table_name, key: create_key_hash(hash_value, range_value))
-        r.item.present?
-      end
-
-      def find_or_new(hash_value, range_value = nil)
-        fail 'Key cannot be blank.' if (hash_value.nil? || hash_value == '')
-        fail 'Range key cannot be blank.' if range_key && range_value.nil?
-
-        r = client.get_item(table_name: table_name, key: create_key_hash(hash_value, range_value))
-        if r.item
-          new(r.item.symbolize_keys, false)
-        else
-          range_key ? new(hash_key => hash_value, range_key => range_value) : new(hash_key => hash_value)
-        end
-      end
-
-      def query(args = {})
-        fail ArgumentError, 'You must provide a :hash_key.' unless args[:hash_key]
-        fail TypeError, 'Your range key must be handled as an integer, float, date, or time.' unless self.range_is_numeric?
-
-        response = self.dynamo_query(args)
-        objects = []
-        response.items.each do |item|
-          objects << new(item.symbolize_keys, false)
-        end
-        objects
-      end
-
     end
 
     #### Instance Methods
@@ -273,37 +236,6 @@ module Dynamini
       )
     end
 
-    def self.dynamo_query(args)
-      expression_attribute_values = self.build_expression_attribute_values(args)
-      key_condition_expression = self.build_key_condition_expression(args)
-
-      client.query(
-          table_name: table_name,
-          key_condition_expression: key_condition_expression,
-          expression_attribute_values: expression_attribute_values
-      )
-    end
-
-    def self.build_expression_attribute_values(args)
-      expression_values = {}
-      expression_values[':h'] = args[:hash_key]
-      expression_values[':s'] = args[:start] if args[:start]
-      expression_values[':e'] = args[:end] if args[:end]
-      expression_values
-    end
-
-    def self.build_key_condition_expression(args)
-      expression = "#{hash_key} = :h"
-      if args[:start] && args[:end]
-        expression += " AND #{range_key} BETWEEN :s AND :e"
-      elsif args[:start]
-        expression += " AND #{range_key} >= :s"
-      elsif args[:end]
-        expression += " AND #{range_key} <= :e"
-      end
-      expression
-    end
-
     def key
       key_hash = { self.class.hash_key => @attributes[self.class.hash_key] }
       key_hash[self.class.range_key] = @attributes[self.class.range_key] if self.class.range_key
@@ -316,30 +248,6 @@ module Dynamini
       key_hash
     end
 
-    def self.build_range_expression(start_value, end_value)
-      operator = (
-        if start_value && end_value
-          'BETWEEN'
-        elsif start_value
-          'GE'
-        elsif end_value
-          'LE'
-        end
-      )
-      attribute_value_list = []
-
-      if handle = handles[range_key.to_sym]
-        attribute_value_list << attribute_callback(SETTER_PROCS, handle, start_value) if start_value
-        attribute_value_list << attribute_callback(SETTER_PROCS, handle, end_value) if end_value
-      else
-        attribute_value_list << start_value if start_value
-        attribute_value_list << end_value if end_value
-      end
-
-      {attribute_value_list: attribute_value_list, comparison_operator: operator}
-    end
-
-
     def attribute_updates
       changes.reduce({}) do |updates, (key, value)|
         current_value = value[1]

data/lib/dynamini/querying.rb

@@ -0,0 +1,101 @@
+module Dynamini
+  module Querying
+
+    def find(hash_value, range_value = nil)
+      fail 'Range key cannot be blank.' if range_key && range_value.nil?
+      response = client.get_item(table_name: table_name, key: create_key_hash(hash_value, range_value))
+      raise 'Item not found.' unless response.item
+      new(response.item.symbolize_keys, false)
+    end
+
+    def exists?(hash_value, range_value = nil)
+      fail 'Range key cannot be blank.' if range_key && range_value.nil?
+
+      r = client.get_item(table_name: table_name, key: create_key_hash(hash_value, range_value))
+      r.item.present?
+    end
+
+    def find_or_new(hash_value, range_value = nil)
+      fail 'Key cannot be blank.' if (hash_value.nil? || hash_value == '')
+      fail 'Range key cannot be blank.' if range_key && range_value.nil?
+
+      r = client.get_item(table_name: table_name, key: create_key_hash(hash_value, range_value))
+      if r.item
+        new(r.item.symbolize_keys, false)
+      else
+        range_key ? new(hash_key => hash_value, range_key => range_value) : new(hash_key => hash_value)
+      end
+    end
+
+    def query(args = {})
+      fail ArgumentError, 'You must provide a :hash_key.' unless args[:hash_key]
+      fail TypeError, 'Your range key must be handled as an integer, float, date, or time.' unless self.range_is_numeric?
+
+      response = dynamo_query(args)
+      objects = []
+      response.items.each do |item|
+        objects << new(item.symbolize_keys, false)
+      end
+      objects
+    end
+
+    private
+
+    def dynamo_query(args)
+      expression_attribute_values = build_expression_attribute_values(args)
+      key_condition_expression = build_key_condition_expression(args)
+
+      client.query(
+          table_name: table_name,
+          key_condition_expression: key_condition_expression,
+          expression_attribute_values: expression_attribute_values
+      )
+    end
+
+    def build_expression_attribute_values(args)
+      expression_values = {}
+      expression_values[':h'] = args[:hash_key]
+      expression_values[':s'] = args[:start] if args[:start]
+      expression_values[':e'] = args[:end] if args[:end]
+      expression_values
+    end
+
+    def build_key_condition_expression(args)
+      expression = "#{hash_key} = :h"
+      if args[:start] && args[:end]
+        expression += " AND #{range_key} BETWEEN :s AND :e"
+      elsif args[:start]
+        expression += " AND #{range_key} >= :s"
+      elsif args[:end]
+        expression += " AND #{range_key} <= :e"
+      end
+      expression
+    end
+
+    #FIXME unused method
+    def build_range_expression(start_value, end_value)
+      operator = (
+      if start_value && end_value
+        'BETWEEN'
+      elsif start_value
+        'GE'
+      elsif end_value
+        'LE'
+      end
+      )
+      attribute_value_list = []
+
+      if handle = handles[range_key.to_sym]
+        attribute_value_list << attribute_callback(SETTER_PROCS, handle, start_value) if start_value
+        attribute_value_list << attribute_callback(SETTER_PROCS, handle, end_value) if end_value
+      else
+        attribute_value_list << start_value if start_value
+        attribute_value_list << end_value if end_value
+      end
+
+      {attribute_value_list: attribute_value_list, comparison_operator: operator}
+    end
+
+
+  end
+end

data/lib/dynamini/test_client.rb

@@ -65,11 +65,11 @@ module Dynamini
     def batch_get_item(args = {})
       responses = {}
 
-      args[:request_items].each do |k, v|
-        responses[k] = []
-        v[:keys].each do |key_hash|
-          item = @data[k][key_hash.values.first]
-          responses[k] << item unless item.nil?
+      args[:request_items].each do |table_name, get_request|
+        responses[table_name] = []
+        get_request[:keys].each do |key_hash|
+          item = get_table(table_name)[key_hash.values.first]
+          responses[table_name] << item unless item.nil?
         end
       end
 
@@ -78,18 +78,17 @@ module Dynamini
 
     #FIXME Add range key support
     def batch_write_item(request_options)
-      request_options[:request_items].each do |k, v|
-        @data[k] ||= {}
-        v.each do |request_hash|
+      request_options[:request_items].each do |table_name, put_requests|
+        put_requests.each do |request_hash|
           item = request_hash[:put_request][:item]
           key = item[hash_key_attr.to_s]
-          @data[k][key] = item
+          get_table(table_name)[key] = item
         end
       end
     end
 
     def delete_item(args = {})
-      @data[args[:table_name]].delete(args[:key][hash_key_attr])
+      get_table(args[:table_name]).delete(args[:key][hash_key_attr])
     end
 
     def query(args = {})
@@ -119,7 +118,7 @@ module Dynamini
           start_val = nil
           end_val = nil
       end
-      parent = @data[args[:table_name]][hash_key]
+      parent = get_table(args[:table_name])[hash_key]
       return OpenStruct.new(items:[]) unless parent
 
       selected = parent.values
@@ -143,10 +142,11 @@ module Dynamini
 
       if args[:attribute_updates]
         args[:attribute_updates].each do |k, v|
+          table = get_table(args[:table_name])
 
-          if v[:action] == 'ADD' && @data[args[:table_name]][hash_key_value]
+          if v[:action] == 'ADD' && table[hash_key_value]
             # if record has been saved
-            data = @data[args[:table_name]][hash_key_value]
+            data = table[hash_key_value]
             data = (data[range_key_value] ||= {}) if range_key_value
 
             attribute_hash[k] = (v[:value] + data[k].to_f)

data/spec/dynamini/base_spec.rb

@@ -119,91 +119,6 @@ describe Dynamini::Base do
       end
     end
 
-    describe '.find' do
-
-      it 'should return a model with the retrieved attributes' do
-        found = Dynamini::Base.find('abcd1234')
-        expect(found.price).to eq(9.99)
-        expect(found.name).to eq('Widget')
-        expect(found.hash_key).to eq('009')
-      end
-
-      context 'when the object does not exist' do
-        it 'should raise an error' do
-          expect { Dynamini::Base.find('f') }.to raise_error 'Item not found.'
-        end
-
-      end
-
-      context 'when retrieving a subclass' do
-        class Foo < Dynamini::Base
-          self.in_memory = true
-        end
-
-        it 'should return the object as an instance of the subclass' do
-          Foo.create(id: '1')
-          expect(Foo.find('1')).to be_a Foo
-        end
-      end
-    end
-
-    describe '.query' do
-      before do
-        4.times do |i|
-          TestClassWithRange.create(foo: 'foo', bar: i + 1)
-        end
-      end
-      context 'start value provided' do
-        it 'should return records with a range key greater than or equal to the start value' do
-          records = TestClassWithRange.query(hash_key: 'foo', start: 2)
-          expect(records.length).to eq 3
-          expect(records.first.bar).to eq 2
-          expect(records.last.bar).to eq 4
-        end
-      end
-      context 'end value provided' do
-        it 'should return records with a range key less than or equal to the start value' do
-          records = TestClassWithRange.query(hash_key: 'foo', end: 2)
-          expect(records.length).to eq 2
-          expect(records.first.bar).to eq 1
-          expect(records.last.bar).to eq 2
-        end
-      end
-      context 'start and end values provided' do
-        it 'should return records between the two values inclusive' do
-          records = TestClassWithRange.query(hash_key: 'foo', start: 1, end: 3)
-          expect(records.length).to eq 3
-          expect(records.first.bar).to eq 1
-          expect(records.last.bar).to eq 3
-        end
-      end
-      context 'neither value provided' do
-        it 'should return all records belonging to that hash key' do
-          records = TestClassWithRange.query(hash_key: 'foo')
-          expect(records.length).to eq 4
-          expect(records.first.bar).to eq 1
-          expect(records.last.bar).to eq 4
-        end
-      end
-
-      context 'a non-numeric range field' do
-        it 'should raise an error' do
-          class TestClassWithStringRange < Dynamini::Base
-            self.in_memory = true
-            set_hash_key :group
-            set_range_key :user_name
-          end
-          expect { TestClassWithStringRange.query(hash_key: 'registered', start: 'a') }.to raise_error TypeError
-        end
-      end
-
-      context 'hash key does not exist' do
-        it 'should return an empty array' do
-          expect(TestClassWithRange.query(hash_key: 'non-existent key')).to eq([])
-        end
-      end
-    end
-
     describe '.increment!' do
       context 'when incrementing a nil value' do
         it 'should save' do
@@ -277,36 +192,6 @@ describe Dynamini::Base do
       end
     end
 
-    describe '.find_or_new' do
-      context 'when a record with the given key exists' do
-        it 'should return that record' do
-          existing_record = Dynamini::Base.find_or_new(model.id)
-          expect(existing_record.new_record?).to eq(false)
-          expect(existing_record.id).to eq(model.id)
-        end
-
-        it 'should return the record for table with range key' do
-          existing_record = TestClassWithRange.create!(foo: 1, bar: 123)
-          expect(TestClassWithRange.find_or_new(existing_record.foo, existing_record.bar).new_record?).to eq(false)
-          expect(existing_record.foo).to eq(1)
-          expect(existing_record.bar).to eq(123)
-        end
-
-      end
-      context 'when the key cannot be found' do
-        it 'should initialize a new object with that key' do
-          expect(Dynamini::Base.find_or_new('foo').new_record?).to be_truthy
-        end
-
-        it 'should initialize a new object with hash key and range key' do
-          new_record = TestClassWithRange.find_or_new(1, 6)
-          expect(new_record.new_record?).to be_truthy
-          expect(new_record.foo).to eq(1)
-          expect(new_record.bar).to eq(6)
-        end
-      end
-    end
-
     describe '#==' do
       let(:model_a) { Dynamini::Base.new(model_attributes).tap {
           |model| model.send(:clear_changes)
@@ -672,40 +557,6 @@ describe Dynamini::Base do
       end
     end
 
-    describe '.exists?' do
-
-      context 'with hash key' do
-        context 'the item exists' do
-          it 'should return true' do
-            expect(Dynamini::Base.exists?(model_attributes[:id])).to be_truthy
-          end
-        end
-
-        context 'the item does not exist' do
-          it 'should return false' do
-            expect(Dynamini::Base.exists?('nonexistent id')).to eq(false)
-          end
-        end
-      end
-
-      context 'with hash key and range key' do
-
-        it 'should return true if item exists' do
-          TestClassWithRange.create!(foo: 'abc', bar: 123)
-
-          expect(TestClassWithRange.exists?('abc', 123)).to eq(true)
-        end
-
-        it 'should return false if the item does not exist' do
-          TestClassWithRange.create!(foo: 'abc', bar: 123)
-
-          expect(TestClassWithRange.exists?('abc', 'nonexistent range key')).to eq(false)
-        end
-
-      end
-    end
-
-
     describe '#new_record?' do
       it 'should return true for a new record' do
         expect(Dynamini::Base.new).to be_truthy

data/spec/dynamini/querying_spec.rb

@@ -0,0 +1,178 @@
+require 'spec_helper'
+
+describe Dynamini::Querying do
+
+  let(:model_attributes) {
+    {
+        name: 'Widget',
+        price: 9.99,
+        id: 'abcd1234',
+        hash_key: '009'
+    }
+  }
+
+  subject(:model) { Dynamini::Base.new(model_attributes) }
+
+  class TestClassWithRange < Dynamini::Base
+    set_hash_key :foo
+    set_range_key :bar
+    self.in_memory = true
+    handle :bar, :integer
+  end
+
+  describe '.find' do
+
+    before do
+      model.save
+    end
+
+    it 'should return a model with the retrieved attributes' do
+      found = Dynamini::Base.find('abcd1234')
+      expect(found.price).to eq(9.99)
+      expect(found.name).to eq('Widget')
+      expect(found.hash_key).to eq('009')
+    end
+
+    context 'when the object does not exist' do
+      it 'should raise an error' do
+        expect { Dynamini::Base.find('f') }.to raise_error 'Item not found.'
+      end
+
+    end
+
+    context 'when retrieving a subclass' do
+      class Foo < Dynamini::Base
+        self.in_memory = true
+      end
+
+      it 'should return the object as an instance of the subclass' do
+        Foo.create(id: '1')
+        expect(Foo.find('1')).to be_a Foo
+      end
+    end
+  end
+
+  describe '.query' do
+    before do
+      4.times do |i|
+        TestClassWithRange.create(foo: 'foo', bar: i + 1)
+      end
+    end
+    context 'start value provided' do
+      it 'should return records with a range key greater than or equal to the start value' do
+        records = TestClassWithRange.query(hash_key: 'foo', start: 2)
+        expect(records.length).to eq 3
+        expect(records.first.bar).to eq 2
+        expect(records.last.bar).to eq 4
+      end
+    end
+    context 'end value provided' do
+      it 'should return records with a range key less than or equal to the start value' do
+        records = TestClassWithRange.query(hash_key: 'foo', end: 2)
+        expect(records.length).to eq 2
+        expect(records.first.bar).to eq 1
+        expect(records.last.bar).to eq 2
+      end
+    end
+    context 'start and end values provided' do
+      it 'should return records between the two values inclusive' do
+        records = TestClassWithRange.query(hash_key: 'foo', start: 1, end: 3)
+        expect(records.length).to eq 3
+        expect(records.first.bar).to eq 1
+        expect(records.last.bar).to eq 3
+      end
+    end
+    context 'neither value provided' do
+      it 'should return all records belonging to that hash key' do
+        records = TestClassWithRange.query(hash_key: 'foo')
+        expect(records.length).to eq 4
+        expect(records.first.bar).to eq 1
+        expect(records.last.bar).to eq 4
+      end
+    end
+
+    context 'a non-numeric range field' do
+      it 'should raise an error' do
+        class TestClassWithStringRange < Dynamini::Base
+          self.in_memory = true
+          set_hash_key :group
+          set_range_key :user_name
+        end
+        expect { TestClassWithStringRange.query(hash_key: 'registered', start: 'a') }.to raise_error TypeError
+      end
+    end
+
+    context 'hash key does not exist' do
+      it 'should return an empty array' do
+        expect(TestClassWithRange.query(hash_key: 'non-existent key')).to eq([])
+      end
+    end
+  end
+
+  describe '.exists?' do
+    context 'with hash key' do
+      context 'the item exists' do
+        before do
+          model.save
+        end
+        it 'should return true' do
+          expect(Dynamini::Base.exists?(model_attributes[:id])).to be_truthy
+        end
+      end
+
+      context 'the item does not exist' do
+        it 'should return false' do
+          expect(Dynamini::Base.exists?('nonexistent id')).to eq(false)
+        end
+      end
+    end
+
+    context 'with hash key and range key' do
+
+      it 'should return true if item exists' do
+        TestClassWithRange.create!(foo: 'abc', bar: 123)
+
+        expect(TestClassWithRange.exists?('abc', 123)).to eq(true)
+      end
+
+      it 'should return false if the item does not exist' do
+        TestClassWithRange.create!(foo: 'abc', bar: 123)
+
+        expect(TestClassWithRange.exists?('abc', 'nonexistent range key')).to eq(false)
+      end
+    end
+  end
+
+  describe '.find_or_new' do
+    context 'when a record with the given key exists' do
+      before do
+        model.save
+      end
+      it 'should return that record' do
+        existing_record = Dynamini::Base.find_or_new(model.id)
+        expect(existing_record.new_record?).to eq(false)
+        expect(existing_record.id).to eq(model.id)
+      end
+
+      it 'should return the record for table with range key' do
+        existing_record = TestClassWithRange.create!(foo: 1, bar: 123)
+        expect(TestClassWithRange.find_or_new(existing_record.foo, existing_record.bar).new_record?).to eq(false)
+        expect(existing_record.foo).to eq(1)
+        expect(existing_record.bar).to eq(123)
+      end
+
+    end
+    context 'when the key cannot be found' do
+      it 'should initialize a new object with that key' do
+        expect(Dynamini::Base.find_or_new('foo').new_record?).to be_truthy
+      end
+
+      it 'should initialize a new object with hash key and range key' do
+        new_record = TestClassWithRange.find_or_new(1, 6)
+        expect(new_record.new_record?).to be_truthy
+        expect(new_record.foo).to eq(1)
+        expect(new_record.bar).to eq(6)
+      end
+    end
+  end
+end

metadata

@@ -1,7 +1,7 @@
 --- !ruby/object:Gem::Specification
 name: dynamini
 version: !ruby/object:Gem::Version
-  version: 1.10.1
+  version: 1.10.2
 platform: ruby
 authors:
 - Greg Ward
@@ -21,104 +21,104 @@ dependencies:
   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
@@ -145,9 +145,11 @@ files:
 - lib/dynamini/base.rb
 - lib/dynamini/batch_operations.rb
 - lib/dynamini/configuration.rb
+- lib/dynamini/querying.rb
 - lib/dynamini/test_client.rb
 - spec/dynamini/base_spec.rb
 - spec/dynamini/batch_operations_spec.rb
+- spec/dynamini/querying_spec.rb
 - spec/dynamini/test_client_spec.rb
 - spec/spec_helper.rb
 homepage: https://github.com/47colborne/dynamini
@@ -160,22 +162,23 @@ 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.4.6
+rubygems_version: 2.2.2
 signing_key: 
 specification_version: 4
 summary: DynamoDB interface
 test_files:
 - spec/dynamini/base_spec.rb
 - spec/dynamini/batch_operations_spec.rb
+- spec/dynamini/querying_spec.rb
 - spec/dynamini/test_client_spec.rb
 - spec/spec_helper.rb