rom-dynamodb 2.0.2 → 2.2.0

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA1:
-  metadata.gz: 828f463a357464de133be0aa1c4ac5f72ffecff6
-  data.tar.gz: a42ab2427b122c3c8c6c9b7fb2b6fc9c069743fa
+  metadata.gz: 5dfe29ecc7e7f6bc3d64a8cdb9413034b1a36ee7
+  data.tar.gz: fab828906c5c5c0778f14632713b7dcbf82b970b
 SHA512:
-  metadata.gz: 906b3e36665c1741af7c7076c1484c867a738174a47cc4ef00edb22729723b679048fdd416988ff56feff7290d79dba778bebc77c62877c950c885486437a525
-  data.tar.gz: 38dd2529874f699c5d38f93299cb4fe78c16f05d8dc0c1981d427a2f16268bc564cc947d8d358f215991039255515725922307530126814d2d80e85073bb7c82
+  metadata.gz: 06a62bc7f70a74398de8fffc03aa0ba35995daf6915717a130c985155078e28d9a01dda35daf485de909f269b3b1eb463c2835c658f03ca6a8756a4d7d9aadec
+  data.tar.gz: 840044b23db325be06a58b74dc2d5861b7aa74c020e0d120ad72a635569f32526fd47d1b9dc5a8e10930ad2acc5b8092f71d62213ef8e40101dab9a2ce6e4118

data/.github/issue_template.md

@@ -10,6 +10,4 @@ Describe what should happen
 Describe what happens instead
 
 ### System configuration
-**Drumbeat version**:
-
 **Ruby version**:

data/.travis.yml

@@ -1,4 +1,5 @@
-sudo: false
+services:
+  - docker
 
 sudo: required
 
@@ -6,12 +7,15 @@ before_install:
   - docker-compose pull
   - docker-compose build
 
-script: docker-compose run rom bundle exec rspec
+script:
+  - docker-compose run rom bundle exec rspec
+
+after_success:
+  - bundle exec codeclimate-test-reporter
 
 env:
   global:
-    - CI=true
-    - TRAVIS=true
+    - secure: "y+WKE+O64Mk9/MIiVDsHY12FsIDv31c5kGT1PD8X3bGzDLSs2RsxH+6aAPKj8soQIU6vN1cpXzHOI9rmgSa/jPwXN/TVhXNQUEaQGaCQjlucx4D7M0SjXxrEVcFsXeQpkb+sDH7zeRDj9mxnpzpHzFc1uLBodKUKFoqDJP67rYzdfHYTGettvGxPBR38gZxSPGejVNbb+cnY8bvUECK/Qn+0MTR3xjkZi+y4PKsj4ZlN7+4m8GOQt/S/9SK++5MJtlXXRtC7tufXZ3QJvmyfB/FbDYm5/e+ovAWVFI2s62/IuE5qdoEjBK3j8cKvTErrBzp1mo9JtM1QeJGAGuOroM8ki9cjPV+mtuFdIq7pzjBOK8ZIWGCQCljuIvyWZ88jZQzqkjgcREvBxGJa5u/maaNduUXWdfR/Q2DFazX7SfrD5CLXvinemVdPpo8/D0NhduSW8pgSKF0E9WBGng2z3BP40L+l7aTFfzrrirdzDNU1KsOzfDDs9+h9Rq8uwIhKiZhiPr+4ztXteNmaJMaeL9KnAgIhZGW1EYUkC1gAVXRkzaFFh3tnRhKAzU1LJxl2qskf0MJFgc/hr3hTHvWgYCQYe2QCZdulqb7HdnUH55Twsha+XVtMp25GxKVrTN4ET5L971xALGvTRxKaO2lekZmVxr4qauhyoXMUc1pCN4g="
     - secure: "kQuM1k5J7COei8KyvabP/YROhoUFlLZkieaDQLFyOj2cobYW6bYsfzuWkNKaNpBrVjEenumLHwHg6P9vVmI7FQ1IEUW2QkAYSUUni/jRBK53jICIINWo6YLWgLQdpdkBnCzMv8MVXBlrqLgqcUn3aUXEtOhM9uHQbhknBx+z+Yja8tdjt6m8scBmqGj8a3zH3Pypi0PbH7fNHUXzAGx/CUyB/s58zUkm9SRs7uR5TRVKtmUyXaroTxmKL9iDIuArjMsOTzu/Xr1kwdlg1kmzB//j0basRzYPOSNdJAGKEdwXo6ul7ZGc993iIJGS/+LZuLgrOcdjHklBSWlduQABEqOFpL76cG7RUH5Mo58Wqd+ftR/Lz5+vEDxpj1JXOUzKv4yB/EA3hTxnK7vCvp5pYSAD+sqtTn5f8TpcxaKYwR0n5YUtV9E8JhZ4I5QvWONU1zXsb9ulhGBFRhZniFKNEsBoapdCA+rAEXLJS0D7ODEE7degsv1uMhO6QPt1sAWvHZvZh01XvlEM9p7aeTOnD72DjKw47GTU/GL6Ekl8er+wubk/ZGBKMQ9YZXiT2jQwgIJyKSWw19s0Ru9otLhrSgwY0eHhvQuyYWL2DwFV2Bcrx1Glgj96+nSzj8g/42NTL1fX5cYAAPYjnqWLc8yuqF+ioF24Yq22CuTQhn/u0BE="
 
 addons:
@@ -19,12 +23,6 @@ addons:
     repo_token:
       secure: "AL3aOEHyWvXkXGne+U3n6ToU0Ubp8yiy3y6gqo/IF2DsN133ynEwcUsif81eIeMTYa+LH4PfDV4iImbwrawhJdyr1ghAqC98k2xfzD5oBSOO8b6gj5k3fRLGRIlGcFwrSSZm9t3F3J3teU3QeaeOW5QhJrtGtlApVvMRzUQPmPbFKjSbzg9oXnl6rWpghUGPjkJZ1zJARZqYx6yJ5JYoRFX7xPcwmwvMa3tCnLh3wfpVCexsa33gssFCGUuh/qU2aLO9f/EyLV95nkxNoXdNoMAajuddDAUK2GQSBLuGijyydUl+x9ZLEsfMJbW3xFqeYVQzMiRXMku0kp7NuzSF9TfPP4TSv5EIJAuVujB3u7sc+jRGEy+m+WawUunu8BmX1l9vjBMcMUonqcsToTBHf9u1nLBdJMhwk0WQkvcJ31g4lrc5y4wut/mRdylBTrplAJAwcHfXnM7ADWL4DN3Yx+Vo+lPgkCrtnsMST2PUcyW2v+hln/BR9qB9PGPC121o7D+BNNuT4oLrw7tebnl3CWI9cpb2jaZl1cVrINhOnApukO1oqxOE2xGVCkNIZ4RIDLlj1WVbbLBN/C/dREjf6n/jNT5LylWEULHofYpit2+1o8KSHjT7aCMLwWlyIuAyYz45WSPviy4oyrjeLUGUo3u15EjJeGcKhXtrtreVdvk="
 
-services:
-  - docker
-
-# after_success:
-#   - CI=true TRAVIS=true coveralls --verbose
-
 deploy:
   provider: rubygems
   api_key:

data/CHANGELOG.md

@@ -0,0 +1,6 @@
+#### v2.2.0
+- Added ability to use `where { ... }` directly from the relation
+- Using `:expression_attribute_values`, `:expression_attribute_names` and `:key_condition_expression` when querying.
+
+#### v2.0.2
+- Initial release of adapter

data/README.md

@@ -1,11 +1,12 @@
 # ROM DynamoDB Adapter
+ [![Gem Version](https://badge.fury.io/rb/rom-dynamodb.svg)](https://badge.fury.io/rb/rom-dynamodb) [![GitHub](https://img.shields.io/badge/github-davidkelley%2From--dynamo-blue.svg)](https://github.com/davidkelley/rom-dynamodb) [![Documentation](http://img.shields.io/badge/docs-rdoc.info-blue.svg)](http://www.rubydoc.info/github/davidkelley/rom-dynamodb) [![License](http://img.shields.io/badge/license-MIT-yellowgreen.svg)](#license)  [![Gitter](http://img.shields.io/badge/gitter-rom--rb-red.svg)](https://gitter.im/rom-rb/chat)
 
-[![Gem Version](https://badge.fury.io/rb/rom-dynamodb.svg)](https://badge.fury.io/rb/rom-dynamodb) [![Code Climate](https://codeclimate.com/github/davidkelley/rom-dynamodb/badges/gpa.svg)](https://codeclimate.com/github/davidkelley/rom-dynamodb) [![Test Coverage](https://codeclimate.com/github/davidkelley/rom-dynamodb/badges/coverage.svg)](https://codeclimate.com/github/davidkelley/rom-dynamodb/coverage) [![Dependency Status](https://gemnasium.com/badges/github.com/davidkelley/rom-dynamodb.svg)](https://gemnasium.com/github.com/davidkelley/rom-dynamodb)
+ [![Code Climate](https://codeclimate.com/github/davidkelley/rom-dynamodb/badges/gpa.svg)](https://codeclimate.com/github/davidkelley/rom-dynamodb) [![Coverage Status](https://coveralls.io/repos/github/davidkelley/rom-dynamodb/badge.svg?branch=master)](https://coveralls.io/github/davidkelley/rom-dynamodb?branch=master) [![Dependency Status](https://gemnasium.com/badges/github.com/davidkelley/rom-dynamodb.svg)](https://gemnasium.com/github.com/davidkelley/rom-dynamodb)
  [![Build Status](https://travis-ci.org/davidkelley/rom-dynamodb.svg?branch=master)](https://travis-ci.org/davidkelley/rom-dynamodb) [![Inline docs](http://inch-ci.org/github/davidkelley/rom-dynamodb.svg?branch=master)](http://inch-ci.org/github/davidkelley/rom-dynamodb)
 
 ---
 
-TODO: Delete this and the text above, and describe your gem
+This adapter uses [ROM (>= 2.0.0)](http://rom-rb.org/) to provide an easy-to-use, clean and understandable interface for [AWS DynamoDB](https://aws.amazon.com/documentation/dynamodb/).
 
 ## Installation
 
@@ -25,11 +26,150 @@ Or install it yourself as:
 
 ## Usage
 
-TODO
+The following container setup is for demonstration purposes only. You should follow the standard way of integrating ROM into your environment, as [documented here](http://rom-rb.org/learn/advanced/flat-style-setup/).
+
+```ruby
+require 'rom/dynamodb'
+
+TABLE = "my-dynamodb-users-table"
+
+# any other AWS::DynamoDB::Client options
+credentials = { region: 'us-east-1' }
+
+container = ROM.container(:dynamodb, credentials) do |rom|
+  rom.relation(:users) do
+    # Key Schema: id<Hash>
+    dataset TABLE
+
+    def by_id(val)
+      where { id == val }
+    end
+  end
+
+  rom.commands(:users) do
+    FILTER = Functions[:symbolize_keys] >> Functions[:accept_keys, [:id]]
+
+    define(:create) do
+      KEYS = %w(id name)
+      result :one
+      input Functions[:accept_keys, KEYS]
+    end
+
+    define(:delete) do
+      result :one
+      input FILTER
+    end
+
+    define(:update) do
+      result :one
+      input FILTER
+    end
+  end
+end
+
+relation = container.relation(:users)
+
+relation.count # => 1234
+
+relation.where { id == 1 }.one! # => { id: 1, name: "David" }
+
+relation.info # => <Hash> DynamoDB Table Information
+
+relation.status # => :active
+
+# create a new user
+create = container.commands[:users][:create]
+user = create.call({ id: 2, name: "James" })
+
+# update an existing user
+update = container.commands[:users][:update]
+update.by_id(user[:id]).call(name: "Mark")
+
+relation.where(id: user[:id]) { id == id }.one! # => { id: 2, name: "Mark" }
+
+# delete an existing user
+delete = container.commands[:users][:delete]
+delete.by_id(user[:id]).call
+```
+---
+
+#### Querying a composite key DynamoDB Table
+
+```ruby
+container = ROM.container(:dynamodb, credentials) do |rom|
+  rom.relation(:logs) do
+    # Key Schema: host<Hash>, timestamp<Range>
+    dataset "my-logs-table"
+
+    def by_host(ip)
+      where { host == ip }
+    end
+
+    def after_timestamp(time)
+      where { timestamp > time }
+    end
+
+    def before_timestamp(time)
+      where { timestamp < time }
+    end
+  end
+
+  rom.commands(:logs) do
+    define(:create) do
+      KEYS = %w(host timestamp message)
+      result :one
+      input Functions[:accept_keys, KEYS]
+    end
+  end
+end
+
+num_of_logs = 20
+
+host = "192.168.0.1"
+
+logs = (1..num_of_logs).to_a.collect do |i|
+  { host: host, timestamp: Time.now.to_f + (i * 60), message: "some message" }
+end
+
+# create fake logs
+container.commands[:logs][:create].call(logs)
+
+relation = container.relation(:logs)
+
+relation.count == num_of_logs # => true
+
+all = relation.where(ip: host) { host == ip }.after(0).to_a # => [{host: "192.168.0.1", ... }, ...]
+
+all.size # => 20
+
+before = relation.where(ip: host) { [host == ip, timestamp < (Time.now.to_f + 60 * 60)] }.limit(1).to_a
+
+before.size # => 1
+
+before.first == logs.first # => true
+
+offset = { ip: host, timestamp: logs[-2][:timestamp] }
+
+last = relation.where(ip: host) { ip == host }.descending.after(0).offset(offset).limit(1).one!
+
+last == logs.last # => true
+```
+---
 
 ## Development
 
-TODO
+All development takes place inside [Docker Compose](). Run the following commands to get setup:
+
+```
+$ docker-compose pull
+$ docker-compose build
+```
+
+You can then begin developing, running RSpec tests with the following command:
+
+```
+$ docker-compose run rom rspec [args...]
+```
 
 ## Contributing
 

data/docker-compose.yml

@@ -13,7 +13,13 @@ services:
       dockerfile: Dockerfile.development
     command: rspec
     environment:
-      DYNAMO_ENDPOINT: 'http://dynamo:8000'
+      - DYNAMO_ENDPOINT=http://dynamo:8000
+      - CI
+      - TRAVIS
+      - TRAVIS_BRANCH
+      - TRAVIS_JOB_ID
+      - TRAVIS_PULL_REQUEST
+      - CODECLIMATE_REPO_TOKEN
     volumes:
       - .:/app
     links:

data/lib/rom/dynamodb/commands/update.rb

@@ -10,7 +10,7 @@ module ROM
 
         def with_tuple(tuple, attributes)
           data = tuple.is_a?(Hash) ? tuple : tuple.to_h
-          relation.update(input[data], attributes.to_h)
+          source.update(input[data], attributes.to_h)
         end
       end
     end

data/lib/rom/dynamodb/dataset.rb

@@ -1,8 +1,40 @@
+require "rom/dynamodb/dataset/where_clause"
+
 module ROM
   module DynamoDB
     class Dataset
+      # @!macro rom.dynamodb.dataset.chain_note
+      # @note This method can be chained with other relational methods.
+
+      # @!macro rom.dynamodb.dataset.order_note
+      # @note Items with the same partition key value are stored in sorted
+      #   order by sort key. If the sort key data type is Number, the results
+      #   are stored in numeric order. For type String, the results are stored
+      #   in order of ASCII character code values. For type Binary, DynamoDB
+      #   treats each byte of the binary data as unsigned.
+
+      # @!macro rom.dynamodb.dataset.series_note
+      # @note Whilst the naming and parameters of this method indicate a
+      #   time-series based operation, DynamoDB can perform a range query
+      #   for any orderable data.
+
+      # @attr_reader [String] name the full name of the DynamoDB Table to query.
+
+      # @attr_reader [Symbol] operation the operation to perform on DynamoDB.
+
+      # @attr_reader [Hash] config the configuration to apply to the underlying
+      #   DynamoDB client.
+
       attr_reader :name, :operation, :config
 
+      # @attr [Array<Hash>] queries the array of query sets to merge and use
+      #   to query DynamoDB.
+
+      #   This array of hashes is built up by chaining the
+      #   relational methods together and when the query is finally executed,
+      #   all the hashes in this array are merged and send to the underlying
+      #   DynamoDB client.
+
       attr_accessor :queries
 
       def initialize(name:, operation: :query, config: {}, queries: [])
@@ -12,42 +44,211 @@ module ROM
         @queries = queries
       end
 
+      # The name of an index to query. This index can be any local secondary
+      # index or global secondary index on the table.
+      #
+      # @!macro rom.dynamodb.dataset.chain_note
+      #
+      # @param name [String] the name of the index to query.
+      #
+      # @return [self] the {Dataset} object the method was performed on.
       def index(name)
         restrict(index_name: name)
       end
 
+      # Performs a traversal of the index in ascending order on the range key.
+      # DynamoDB will return the results in the order in which they
+      # have been stored.
+      #
+      # @note This is the default behaviour.
+      #
+      # @!macro rom.dynamodb.dataset.chain_note
+      # @!macro rom.dynamodb.dataset.order_note
+      #
+      # @return [self] the {Dataset} object the method was performed on.
       def ascending
         restrict(scan_index_forward: true)
       end
 
+      # Performs a traversal of the index in descending order on the range key.
+      # DynamoDB reads the results in reverse order by sort key value, and
+      # then returns the results to the client.
+      #
+      # @note This is the default behaviour.
+      #
+      # @!macro rom.dynamodb.dataset.chain_note
+      # @!macro rom.dynamodb.dataset.order_note
+      #
+      # @return [self] the {Dataset} object the method was performed on.
       def descending
         restrict(scan_index_forward: false)
       end
 
+      # Limits the number of results returned by the query or scan operation.
+      #
+      # The maximum number of items to evaluate (not necessarily the number of
+      # matching items). If DynamoDB processes the number of items up to the
+      # limit while processing the results, it stops the operation and returns
+      # the matching values up to that point.
+      #
+      # If there are more matches to be returned, the {#last_evaluated_key}
+      #
+      # @!macro rom.dynamodb.dataset.chain_note
+      #
+      # @return [self] the {Dataset} object the method was performed on.
       def limit(num = nil)
         append { { limit: num } unless num.nil? }
       end
 
+      # The composite key of the first item that the resulting query will
+      # evaluate. Use this method if you have a populated {#last_evaluated_key}.
+      #
+      # @!macro rom.dynamodb.dataset.chain_note
+      #
+      # @note When applying an offset, it must include the same composite key of
+      #   which the index you are querying is composed from. Therefore, if your
+      #   index has both a hash and range key, the key you provide must also have
+      #   these.
+      #
+      # @param key [Hash] the composite offset key matching the queryable index.
+      #
+      # @return [self] the {Dataset} object the method was performed on.
       def offset(key)
         append { { exclusive_start_key: key } unless key.nil? }
       end
 
+      # Selects one or more keys to retrieve from the table.
+      #
+      # These keys can include scalars, sets, or elements of a JSON
+      # document.
+      #
+      # @!macro rom.dynamodb.dataset.chain_note
+      #
+      # @param keys [Array<String>] an array of string expressions to apply
+      #   to the query
+      #
+      # @return [self] the {Dataset} object the method was performed on.
       def select(keys)
-        restrict(select: "SPECIFIC_ATTRIBUTES", attributes_to_get: keys.collect(&:to_s))
+        restrict(projection_expression: keys.collect(&:to_s).join(","))
       end
 
+      # Restricts keys within a composite key, by values using a specific operand.
+      #
+      # You can compose where clauses using compartive operators from inside
+      # a block, allowing a greater level of flexibility.
+      #
+      # Multiple where clauses can be chained, or multiple predicates defined
+      # inside an array within a single clause. See the examples below.
+      #
+      # @!macro rom.dynamodb.dataset.chain_note
+      #
+      # @note The following operands are supported, :>=, :>, :<, :<=, :== and :between
+      #
+      # @example Given Table[id<Hash>,legs<Range>]
+      #   animals = relation.where { [id == "mammal", legs > 0] }
+      #   animals #=> [{id: "mammal", legs: 2, name: "Human"}, ...]
+      #
+      # @example Using a value mapping hash
+      #   keys = { type: "mammal", min_legs: 2 }
+      #   animals = relation.where(keys) { [id == type, legs > min_legs] }
+      #   animals #=> [{id: "mammal", legs: 2, name: "Elephant"}, ...]
+      #
+      # @example Matching by exact value
+      #   keys = { type: "mammal" }
+      #   animals = relation.where(keys) { id == type }
+      #   animals #=> [{id: "mammal", legs: 2, name: "Elephant"}, ...]
+      #
+      # @example Between two values
+      #
+      # @example Matching with begins_with
+      #
+      def where(maps = {}, &block)
+        clauses = WhereClause.new(maps).execute(&block).clauses
+        append(:query) do
+          {
+            expression_attribute_values: clauses.expression_attribute_values,
+            expression_attribute_names: clauses.expression_attribute_names,
+            key_condition_expression: clauses.key_condition_expression,
+          }
+        end
+      end
+
+      # Retrieves a key present within the composite key for this index by its
+      # exact value.
+      #
+      # @deprecated Use {#where} instead.
+      #
+      # @!macro rom.dynamodb.dataset.chain_note
+      #
+      # @example Given Table[id<Hash>]
+      #   relation.equal(:id, 1).one! #=> { id: 1, ... }
+      #
+      # @example Given Table[id<Hash>,created_at<Range>]
+      #   relation.equal(:id, 1).equal(:created_at, Time.now.to_f).one! #=> { id: 1, ... }
+      #
+      # @param key [Symbol] the key to match the provided value against.
+      # @param val the value to match against the key in the index.
+      # @param predicate [Symbol] the query predicate to apply to DynamoDB.
+      #
+      # @return [self] the {Dataset} object the method was performed on.
       def equal(key, val, predicate = :eq)
         restrict_by(key, predicate, [val])
       end
 
+      # Retrieves all matching range keys within the composite key for the
+      # index between two points.
+      #
+      # @deprecated Use {#where} instead.
+      #
+      # @!macro rom.dynamodb.dataset.chain_note
+      #
+      # @!macro rom.dynamodb.dataset.series_note
+      #
+      # @example Given Table[id<Hash>,legs<Range>]
+      #   users = relation.equal(:id, "mammal").between(:legs, 0, 4).to_a
+      #   users #=> [{id: "mammal", legs: 2, name: "Human"}, {id: "mammal", legs: 4, name: "Elephant"}, ...]
+      #
+      # @param key [Symbol] the key to match the provided value against.
+      # @param after the value to match range values after
+      # @param before the value to match range values before
+      #
+      # @return [self] the {Dataset} object the method was performed on.
       def between(key, after, before, predicate = :between)
         restrict_by(key, predicate, [after, before])
       end
 
+      # Retrieves all matching range keys within the composite key after the
+      # value provided.
+      #
+      # @deprecated Use {#where} instead.
+      #
+      # @!macro rom.dynamodb.dataset.chain_note
+      #
+      # @!macro rom.dynamodb.dataset.series_note
+      #
+      # @deprecated Use {#where} instead.
+      #
+      # @example Given Table[id<Hash>,legs<Range>]
+      #   users = relation.equal(:id, "mammal").after(:legs, 0).to_a
+      #   users #=> [{id: "mammal", legs: 2, name: "Human"}, ...]
+      #
+      # @param key [Symbol] the key to match the provided value against.
+      # @param after the value to match range values after
+      # @param predicate [String] the query predicate to apply to DynamoDB.
+      #
+      # @return [self] the {Dataset} object the method was performed on.
       def after(key, after, predicate = :ge)
         restrict_by(key, predicate, [after])
       end
 
+      # Retreives all matching range keys within the composite key before the
+      # value provided.
+      #
+      # @deprecated Use {#where} instead.
+      #
+      # @!macro rom.dynamodb.dataset.chain_note
+      #
+      # @!macro rom.dynamodb.dataset.series_note
       def before(key, before, predicate = :le)
         restrict_by(key, predicate, [before])
       end
@@ -135,6 +336,9 @@ module ROM
 
       def append(operation = :query, &block)
         result = block.call
+        if result[:key_condition_expression]
+
+        end
         if result
           args = { name: name, config: config, operation: operation }
           self.class.new(args.merge(queries: queries + [result].flatten))
@@ -144,17 +348,10 @@ module ROM
       end
 
       def to_update_structure(hash)
-        values = {}
-        maps = {}
-        expr = 'SET ' + hash.map do |key, val|
-          values[":#{key}"] = val
-          maps["##{key}"] = key
-          "##{key}=:#{key}"
-        end.join(', ')
         {
-          expression_attribute_values: values,
-          expression_attribute_names: maps,
-          update_expression: expr
+          expression_attribute_values: Hash[hash.map { |k, v| [":#{k}_u", v] }],
+          expression_attribute_names: Hash[hash.map { |k, v| ["##{k}_u", k] }],
+          update_expression: "SET " + hash.map { |k, v| "##{k}_u = :#{k}_u" }.join(", "),
         }
       end
     end

data/lib/rom/dynamodb/dataset/where_clause.rb

@@ -0,0 +1,100 @@
+module ROM
+  module DynamoDB
+    class Dataset
+      class WhereClause
+        class Clause
+          attr_reader :clauses
+
+          def initialize(clauses = [])
+            @clauses = clauses.is_a?(Array) ? clauses : [clauses]
+          end
+
+          def concat(val)
+            @clauses.concat(val.is_a?(Array) ? val : [val])
+          end
+
+          def expression_attribute_values
+            clauses.collect(&method(:to_values)).inject(:merge)
+          end
+
+          def expression_attribute_names
+            clauses.collect(&method(:to_names)).inject(:merge)
+          end
+
+          def key_condition_expression
+            clauses.collect(&method(:to_expression)).join(" AND ")
+          end
+
+          def to_expression(clause)
+            case clause.operand
+            when :between
+              "##{clause.key} BETWEEN :#{clause.key}_a AND :#{clause.key}_b"
+            when :begins_with
+              "begins_with(##{clause.key}, :#{clause.key})"
+            when :==
+              "##{clause.key} = :#{clause.key}"
+            else
+              "##{clause.key} #{clause.operand} :#{clause.key}"
+            end
+          end
+
+          def to_values(clause)
+            case clause.operand
+            when :between
+              value = clause.val
+              min = value.min.is_a?(Operand) ? value.min.val : value.min
+              max = value.max.is_a?(Operand) ? value.max.val : value.max
+              {
+                ":#{clause.key}_a" => min,
+                ":#{clause.key}_b" => max
+              }
+            else
+              { ":#{clause.key}" => clause.val }
+            end
+          end
+
+          def to_names(clause)
+            { "##{clause.key}" => clause.key }
+          end
+        end
+
+        class Operand
+          attr_reader :key, :operand, :val
+
+          def initialize(key:, val:)
+            @key = key
+            @val = val
+          end
+
+          %i(<= == >= > < between).each do |com|
+            define_method(com) do |val|
+              @operand = com
+              @val = val.is_a?(Operand) ? val.val : val
+              self
+            end
+          end
+
+          def <=>(op)
+            val <=> op.val
+          end
+        end
+
+        attr_reader :maps, :clauses
+
+        def initialize(maps = {})
+          @clauses = Clause.new
+          @maps = maps
+        end
+
+        def execute(&block)
+          @clauses.concat(instance_exec(&block))
+          self
+        end
+
+        def method_missing(key)
+          Operand.new(key: key, val: maps[key])
+        end
+      end
+    end
+  end
+end

data/lib/rom/dynamodb/relation.rb

@@ -3,29 +3,72 @@ module ROM
     class Relation < ROM::Relation
       adapter :dynamodb
 
-      # retrieval
-      forward :restrict, :scan, :retrieve, :batch_get, :equal, :index,
-              :before, :after, :between, :select, :offset, :limit
+      # @!macro [attach] r.forward
+      # Performs a $1 action on the relation. In most cases, these operations
+      # can be chained to build up larger queries to perform.
+      # @note This method forwards the $1 operation to the underlying dataset.
+      # @see DynamoDB::Dataset#$1
+      forward :restrict
 
-      # operations
-      forward :create, :delete, :update
+      forward :scan
 
-      # storing
-      forward :ascending, :descending
+      forward :retrieve
 
-      # def initialize(*r)
-      #   super *r
-      #   puts schema.inspect
-      # end
+      forward :batch_get
 
+      forward :equal
+
+      forward :index
+
+      forward :where
+
+      forward :before
+
+      forward :after
+
+      forward :between
+
+      forward :select
+
+      forward :offset
+
+      forward :limit
+
+      forward :create
+
+      forward :delete
+
+      forward :update
+
+      forward :ascending
+
+      forward :descending
+
+      # Retrieve a single record, providing a hash key name and the ID to
+      # fetch.
+      #
+      # @note This is a very simple helper allowing you to easily retrieve
+      #   singular records using a hash key lookup.
+      #
+      # @param key [Symbol] the hash key name to fetch on
+      # @param id [String, Fixnum] an accepted data format for DynamoDB to lookup on
+      # @return [Hash] a single object retrieved from DynamoDB
+      def fetch(key, id)
+        retrieve(key, id).one!
+      end
+
+      # @see https://docs.aws.amazon.com/sdkforruby/api/Aws/DynamoDB/Client.html#describe_table-instance_method
+      # @return [Hash] AWS SDK payload of table information
       def info
         dataset.information
       end
 
+      # @return [Fixnum] current total item count for the associated DynamoDB table
       def count
         dataset.information.item_count
       end
 
+      # @return [Symbol] current status of the DynamoDB table
       def status
         dataset.information.table_status.downcase.to_sym
       rescue

data/lib/rom/dynamodb/version.rb

@@ -1,5 +1,5 @@
 module ROM
   module DynamoDB
-    VERSION = "2.0.2"
+    VERSION = "2.2.0"
   end
 end

data/rom-dynamodb.gemspec

@@ -28,6 +28,7 @@ Gem::Specification.new do |spec|
   spec.add_development_dependency "bigdecimal", "~> 1.3"
   spec.add_development_dependency "rake", "~> 10.0"
   spec.add_development_dependency "rspec", "~> 3.0"
-  spec.add_development_dependency "coveralls", "~> 0.8"
+  spec.add_development_dependency "yard", "~> 0.9"
+  spec.add_development_dependency "codeclimate-test-reporter", "~> 1.0"
   spec.add_development_dependency "factory_girl", "~> 4.5"
 end

metadata

@@ -1,14 +1,14 @@
 --- !ruby/object:Gem::Specification
 name: rom-dynamodb
 version: !ruby/object:Gem::Version
-  version: 2.0.2
+  version: 2.2.0
 platform: ruby
 authors:
 - davidkelley
 autorequire: 
 bindir: exe
 cert_chain: []
-date: 2017-01-18 00:00:00.000000000 Z
+date: 2017-02-01 00:00:00.000000000 Z
 dependencies:
 - !ruby/object:Gem::Dependency
   name: rom
@@ -123,19 +123,33 @@ dependencies:
       - !ruby/object:Gem::Version
         version: '3.0'
 - !ruby/object:Gem::Dependency
-  name: coveralls
+  name: yard
   requirement: !ruby/object:Gem::Requirement
     requirements:
     - - "~>"
       - !ruby/object:Gem::Version
-        version: '0.8'
+        version: '0.9'
   type: :development
   prerelease: false
   version_requirements: !ruby/object:Gem::Requirement
     requirements:
     - - "~>"
       - !ruby/object:Gem::Version
-        version: '0.8'
+        version: '0.9'
+- !ruby/object:Gem::Dependency
+  name: codeclimate-test-reporter
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: '1.0'
+  type: :development
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: '1.0'
 - !ruby/object:Gem::Dependency
   name: factory_girl
   requirement: !ruby/object:Gem::Requirement
@@ -162,6 +176,7 @@ files:
 - ".gitignore"
 - ".rspec"
 - ".travis.yml"
+- CHANGELOG.md
 - CODE_OF_CONDUCT.md
 - Dockerfile.development
 - Gemfile
@@ -177,6 +192,7 @@ files:
 - lib/rom/dynamodb/commands/delete.rb
 - lib/rom/dynamodb/commands/update.rb
 - lib/rom/dynamodb/dataset.rb
+- lib/rom/dynamodb/dataset/where_clause.rb
 - lib/rom/dynamodb/functions.rb
 - lib/rom/dynamodb/gateway.rb
 - lib/rom/dynamodb/relation.rb