Add on-push workflow (#25)

* Add github on-push workflow,

* Documentation cleanup

Author: darrenklein

.github/workflows/on-push.yml

@@ -0,0 +1,18 @@
+name: on-push
+on: [push]
+env:
+  MIX_ENV: test
+jobs:
+  build:
+    runs-on: ubuntu-latest
+    steps:
+      - uses: actions/checkout@v2
+      - uses: erlef/setup-elixir@v1
+        with:
+          otp-version: '23.0.4'
+          elixir-version: '1.10.4'
+      - uses: rrainn/[email protected]
+      - run: mix deps.get
+      - run: mix compile
+      - run: mix format --check-formatted
+      - run: mix test

lib/ex_aws/dynamo.ex

@@ -1,8 +1,8 @@
 defmodule ExAws.Dynamo do
   @moduledoc """
-  Operations on the AWS Dynamo service.
+  Operations on the AWS DynamoDB service.
 
-  NOTE: When Mix.env in [:test, :dev] dynamo clients will run by default against
+  NOTE: When Mix.env in [:test, :dev], Dynamo clients will run by default against
   DynamoDB local.
 
   ## Basic usage
@@ -33,31 +33,31 @@ defmodule ExAws.Dynamo do
 
   ## General notes
   All options are handled as underscored atoms instead of camelcased binaries as specified
-  in the Dynamo API. IE `IndexName` would be `:index_name`. Anywhere in the API that requires
-  dynamo type annotation (`{"S":"mystring"}`) is handled for you automatically. IE
+  in the Dynamo API, e.g. `IndexName` would be `:index_name`. Anywhere in the API that requires
+  Dynamo type annotation (`{"S":"mystring"}`) is handled for you automatically. For example,
 
   ```elixir
   ExAws.Dynamo.scan("Users", expression_attribute_values: [api_key: "foo"])
   ```
-  Transforms into a query of
+  transforms into a query of
   ```elixir
   %{"ExpressionAttributeValues" => %{api_key: %{"S" => "foo"}}, "TableName" => "Users"}
   ```
 
   Consult the function documentation to see precisely which options are handled this way.
 
-  If you wish to avoid this kind of automatic behaviour you are free to specify the types yourself.
-  IE:
+  If you wish to avoid this kind of automatic behaviour, you are free to specify the types yourself.
+  For example,
   ```elixir
   ExAws.Dynamo.scan("Users", expression_attribute_values: [api_key: %{"B" => "Treated as binary"}])
   ```
-  Becomes:
+  becomes
   ```elixir
   %{"ExpressionAttributeValues" => %{api_key: %{"B" => "Treated as binary"}}, "TableName" => "Users"}
   ```
   Alternatively, if what's being encoded is a struct, you're always free to implement ExAws.Dynamo.Encodable for that struct.
 
-  http://docs.aws.amazon.com/amazondynamodb/latest/APIReference/API_Operations.html
+  https://docs.aws.amazon.com/amazondynamodb/latest/APIReference/API_Operations.html
   """
 
   import ExAws.Utils, only: [camelize: 1, camelize_keys: 1, camelize_keys: 2, upcase: 1]
@@ -150,9 +150,11 @@ defmodule ExAws.Dynamo do
   @doc """
   Create table
 
-  `key_schema` can be a simple binary or atom indicating a simple hash key
+  `key_schema` can be a simple binary or atom indicating a simple hash key.
 
-  `billing_mode` may be either `:provisioned` (default) or `:pay_per_request`. If you are creating a `:pay-per-request` table, you will still need to provide values for read and write capacities, although they will be ignored - you may consider providing `nil` in those cases.
+  `billing_mode` may be either `:provisioned` (default) or `:pay_per_request`.
+  If you are creating a `:pay-per-request` table, you will still need to provide values for read and write capacities,
+  although they will be ignored - you may consider providing `nil` in those cases.
   """
   @spec create_table(
           table_name :: binary,
@@ -214,14 +216,16 @@ defmodule ExAws.Dynamo do
   @doc """
   Create table with secondary indices
 
-  Each index should follow the format outlined here: http://docs.aws.amazon.com/amazondynamodb/latest/APIReference/API_CreateTable.html
+  Each index should follow the format outlined here: https://docs.aws.amazon.com/amazondynamodb/latest/APIReference/API_CreateTable.html
 
-  For convenience, the keys in each index map are allowed to be atoms. IE:
+  For convenience, the keys in each index map are allowed to be atoms. e.g:
   `"KeySchema"` in the aws docs can be `key_schema:`
 
   Note that both the `global_indexes` and `local_indexes` arguments expect a list of such indices.
 
-  `billing_mode` may be either `:provisioned` (default) or `:pay_per_request`. If you are creating a `:pay-per-request` table, you will still need to provide values for read and write capacities, although they will be ignored - you may consider providing `nil` in those cases.
+  `billing_mode` may be either `:provisioned` (default) or `:pay_per_request`.
+  If you are creating a `:pay-per-request` table, you will still need to provide values for read and write capacities,
+  although they will be ignored - you may consider providing `nil` in those cases.
 
   Examples
   ```
@@ -402,7 +406,7 @@ defmodule ExAws.Dynamo do
   @doc """
   Scan table
 
-  Please read http://docs.aws.amazon.com/amazondynamodb/latest/APIReference/API_Scan.html
+  Please read https://docs.aws.amazon.com/amazondynamodb/latest/APIReference/API_Scan.html
 
   ```
   Dynamo.scan("Users"
@@ -412,11 +416,11 @@ defmodule ExAws.Dynamo do
     filter_expression: "#asdf = :desired_api_key")
   ```
 
-  Generally speaking you won't need to use `:expression_attribute_names`. It exists
-  to alias a column name if one of the columns you want to search against is a reserved dynamo word,
-  like `Percentile`. In this case it's totally unnecessary as `api_key` is not a reserved word.
+  Generally speaking, you won't need to use `:expression_attribute_names`. It exists
+  to alias a column name if one of the columns you want to search against is a reserved Dynamo word,
+  like `Percentile`. In this case, it's totally unnecessary as `api_key` is not a reserved word.
 
-  Parameters with keys that are automatically annotated with dynamo types are:
+  Parameters with keys that are automatically annotated with Dynamo types are:
   `[:exclusive_start_key, :expression_attribute_names]`
   """
   @type scan_opts :: [
@@ -446,7 +450,7 @@ defmodule ExAws.Dynamo do
   @doc """
   Query Table
 
-  Please read: http://docs.aws.amazon.com/amazondynamodb/latest/APIReference/API_Query.html
+  Please read https://docs.aws.amazon.com/amazondynamodb/latest/APIReference/API_Query.html
 
   ```
   Dynamo.query("Users",
@@ -484,10 +488,10 @@ defmodule ExAws.Dynamo do
   end
 
   @doc """
-  Get up to 100 items (16mb)
+  Batch-get up to 100 items (16 MB total max)
 
   Map of table names to request parameter maps.
-  http://docs.aws.amazon.com/amazondynamodb/latest/APIReference/API_BatchGetItem.html
+  https://docs.aws.amazon.com/amazondynamodb/latest/APIReference/API_BatchGetItem.html
 
   Parameters with keys that are automatically annotated with dynamo types are:
   `[:keys]`
@@ -510,7 +514,7 @@ defmodule ExAws.Dynamo do
     }
   })
   ```
-  As you see you're largely free to use either keyword args or maps in the body. A map
+  As you see, you're largely free to use either keyword args or maps in the body. A map
   is required for the argument itself because the table names are most often binaries, and I refuse
   to inflict proplists on anyone.
 
@@ -582,12 +586,12 @@ defmodule ExAws.Dynamo do
   end
 
   @doc """
-  Put or delete up to 25 items (16mb)
+  Put or delete up to 25 items (16 MB total max)
 
   Map of table names to request parameter maps.
-  http://docs.aws.amazon.com/amazondynamodb/latest/APIReference/API_BatchWriteItem.html
+  https://docs.aws.amazon.com/amazondynamodb/latest/APIReference/API_BatchWriteItem.html
 
-  Parameters with keys that are automatically annotated with dynamo types are:
+  Parameters with keys that are automatically annotated with Dynamo types are:
   `[:keys]`
   """
   @type write_item :: [
@@ -652,7 +656,7 @@ defmodule ExAws.Dynamo do
   Update item in table
 
   For update_args format see
-  http://docs.aws.amazon.com/amazondynamodb/latest/APIReference/API_UpdateItem.html
+  https://docs.aws.amazon.com/amazondynamodb/latest/APIReference/API_UpdateItem.html
   """
   @type update_item_opts :: [
           {:condition_expression, binary}
@@ -862,7 +866,7 @@ defmodule ExAws.Dynamo do
   defp build_expression_attribute_values(data, _), do: data
 
   ## Various other helpers
-  ################
+  #########################
 
   defp add_upcased_opt(data, opts, key) do
     case Map.fetch(opts, key) do

lib/ex_aws/dynamo/decoder.ex

@@ -1,8 +1,8 @@
 defmodule ExAws.Dynamo.Decoder do
   @moduledoc """
-  Decodes a dynamo response into a struct.
+  Decodes a Dynamo response into a struct.
 
-  If Dynamo.Decodable is implemented for the struct it will be called
+  If Dynamo.Decodable is implemented for the struct, it will be called
   after the completion of the coercion.
 
   This is important for handling nested maps if you wanted the nested maps

lib/ex_aws/dynamo/encodable.ex

@@ -1,7 +1,7 @@
 defprotocol ExAws.Dynamo.Encodable do
   @type t :: any
 
-  @doc "Converts an elixir value into a map tagging the value with its dynamodb type"
+  @doc "Converts an Elixir value into a map tagging the value with its Dynamo type"
   def encode(value, options)
 end
 
@@ -104,7 +104,7 @@ defimpl ExAws.Dynamo.Encodable, for: List do
   def encode([], _), do: %{"L" => []}
 
   @doc """
-  Dynamodb offers typed sets and L, a generic list of typed attributes.
+  DynamoDB offers typed sets and L, a generic list of typed attributes.
   """
   def encode(list, _) do
     typed_values =

lib/ex_aws/dynamo/encoder.ex

@@ -1,6 +1,6 @@
 defmodule ExAws.Dynamo.Encoder do
   @moduledoc """
-  Takes an elixir value and converts it into a dynamo style map.
+  Takes an Elixir value and converts it into a Dynamo-style map.
 
   ```elixir
   MapSet.new [1,2,3] |> #{__MODULE__}.encode
@@ -33,8 +33,8 @@ defmodule ExAws.Dynamo.Encoder do
     ExAws.Dynamo.Encodable.encode(value, options)
   end
 
-  # Use this in case you want to encode something already in dynamo format
-  # For some reason I cannot fathom. If you find yourself using this, please open an issue
+  # Use this in case you want to encode something already in Dynamo format
+  # for some reason I cannot fathom. If you find yourself using this, please open an issue
   # so I can find out why and better support this.
   def encode!(value, options \\ []) do
     ExAws.Dynamo.Encodable.encode(value, options)

lib/ex_aws/dynamo/lazy.ex

@@ -1,7 +1,7 @@
 defmodule ExAws.Dynamo.Lazy do
   @moduledoc false
 
-  ## Implimentation of the lazy functions surfaced by ExAws.Dynamo.Client
+  ## Implementation of the lazy functions surfaced by ExAws.Dynamo.Client
 
   @doc "Generates a scan stream"
   def stream_scan(table, opts, config) do