synamoid 1.2.1 → 1.2.2

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA1:
-  metadata.gz: a8ac7dcf3f6d93dc42cc10d5b0eecb940ac39297
-  data.tar.gz: 89f8d6b38bd81b5dfe823f2738a62031d4352dda
+  metadata.gz: 1524b6ecb48d2bbea676257322ee7e5ddf8edf15
+  data.tar.gz: 4769c15ddf8e45b1cd1c4b733ab299ebe9a870ee
 SHA512:
-  metadata.gz: 919a8a9b267f51c76a816a5360b2c30df74cc36d3c2a44be09ea8ce85c33c6aec80646b04ab73d32a387648319ff52aa8af9d85dcaef0fa2d78300ee9075e4df
-  data.tar.gz: 18eba82fb6d53c96a30129ebd18760659a13f72005cf9ceb29e7ab7021f85b59252553ec9c0320e89e2535732bd0a0890a16bab86a05eb4d2b32135eb352e872
+  metadata.gz: a9f42341036d5329c14bbf24754b7a7c638973085f854f28a219224da0b356645e8c265aece2c55ff715c0e0b7dfdf7ca3fa9cf0745a34fb9b78e5f6420ca6f2
+  data.tar.gz: 64af375b597084c891418c8c34580f53dcde5ecce9c23a8758d275c1490330e8060eff3c349629f1bc64a0d9a36d531589cac4481eabe5262a4c31897dcf13f0

data/README.md

@@ -1,6 +1,6 @@
-# Dynamoid
+# Synamoid
 
-Dynamoid is an ORM for Amazon's DynamoDB for Ruby applications. It
+Synamoid is an ORM for Amazon's DynamoDB for Ruby applications. It
 provides similar functionality to ActiveRecord and improves on
 Amazon's existing
 [HashModel](http://docs.amazonwebservices.com/AWSRubySDK/latest/AWS/Record/HashModel.html)
@@ -12,14 +12,14 @@ But if you want a fast, scalable, simple, easy-to-use database (and a Gem that s
 
 ## Installation
 
-Installing Dynamoid is pretty simple. First include the Gem in your Gemfile:
+Installing Synamoid is pretty simple. First include the Gem in your Gemfile:
 
 ```ruby
-gem 'dynamoid', '~> 1'
+gem 'synamoid', '~> 1'
 ```
 ## Prerequisities
 
-Dynamoid depends on the aws-sdk, and this is tested on the current version of aws-sdk (~> 2), rails (~> 4).
+Synamoid depends on the aws-sdk, and this is tested on the current version of aws-sdk (~> 2), rails (~> 4).
 Hence the configuration as needed for aws to work will be dealt with by aws setup.
 
 Here are the steps to setup aws-sdk.
@@ -30,7 +30,7 @@ gem 'aws-sdk', '~>2'
 
 (or) include the aws-sdk in your Gemfile.
 
-**NOTE:** Dynamoid-1.0 doesn't support aws-sdk Version 1 (Use Dynamoid Major Version 0 for aws-sdk 1)
+**NOTE:** Synamoid-1.0 doesn't support aws-sdk Version 1 (Use Synamoid Major Version 0 for aws-sdk 1)
 
 Configure AWS access:
 [Reference](https://github.com/aws/aws-sdk-ruby)
@@ -51,12 +51,12 @@ Create config/initializers/aws.rb as follows:
 For a full list of the DDB regions, you can go
 [here](http://docs.aws.amazon.com/general/latest/gr/rande.html#ddb_region).
 
-Then you need to initialize Dynamoid config to get it going. Put code similar to this somewhere (a Rails initializer would be a great place for this if you're using Rails):
+Then you need to initialize Synamoid config to get it going. Put code similar to this somewhere (a Rails initializer would be a great place for this if you're using Rails):
 
 ```ruby
-  Dynamoid.configure do |config|
+  Synamoid.configure do |config|
     config.adapter = 'aws_sdk_v2' # This adapter establishes a connection to the DynamoDB servers using Amazon's own AWS gem.
-    config.namespace = "dynamoid_app_development" # To namespace tables created by Dynamoid from other tables you might have. Set to nil to avoid namespacing.
+    config.namespace = "synamoid_app_development" # To namespace tables created by Synamoid from other tables you might have. Set to nil to avoid namespacing.
     config.warn_on_scan = true # Output a warning to the logger when you perform a scan rather than a query on a table.
     config.read_capacity = 5 # Read capacity for your tables
     config.write_capacity = 5 # Write capacity for your tables
@@ -69,28 +69,28 @@ Once you have the configuration set up, you need to move on to making models.
 
 ## Setup
 
-You *must* include ```Dynamoid::Document``` in every Dynamoid model.
+You *must* include ```Synamoid::Document``` in every Synamoid model.
 
 ```ruby
 class User
-  include Dynamoid::Document
+  include Synamoid::Document
 
 end
 ```
 
 ### Table
 
-Dynamoid has some sensible defaults for you when you create a new table, including the table name and the primary key column. But you can change those if you like on table creation.
+Synamoid has some sensible defaults for you when you create a new table, including the table name and the primary key column. But you can change those if you like on table creation.
 
 ```ruby
 class User
-  include Dynamoid::Document
+  include Synamoid::Document
 
   table :name => :awesome_users, :key => :user_id, :read_capacity => 5, :write_capacity => 5
 end
 ```
 
-These fields will not change an existing table: so specifying a new read_capacity and write_capacity here only works correctly for entirely new tables. Similarly, while Dynamoid will look for a table named `awesome_users` in your namespace, it won't change any existing tables to use that name; and if it does find a table with the correct name, it won't change its hash key, which it expects will be user_id. If this table doesn't exist yet, however, Dynamoid will create it with these options.
+These fields will not change an existing table: so specifying a new read_capacity and write_capacity here only works correctly for entirely new tables. Similarly, while Synamoid will look for a table named `awesome_users` in your namespace, it won't change any existing tables to use that name; and if it does find a table with the correct name, it won't change its hash key, which it expects will be user_id. If this table doesn't exist yet, however, Synamoid will create it with these options.
 
 ### Fields
 
@@ -105,7 +105,7 @@ You get magic columns of id (string), created_at (datetime), and updated_at (dat
 
 ```ruby
 class User
-  include Dynamoid::Document
+  include Synamoid::Document
 
   field :name
   field :email
@@ -130,26 +130,26 @@ To use a custom type for a field, suppose you have a `Money` type.
   class Money
     # ... your business logic ...
 
-    def dynamoid_dump
+    def synamoid_dump
       "serialized representation as a string"
     end
 
-    def self.dynamoid_load(serialized_str)
+    def self.synamoid_load(serialized_str)
       # parse serialized representation and return a Money instance
       Money.new(...)
     end
   end
 
   class User
-    include Dynamoid::Document
+    include Synamoid::Document
 
     field :balance, Money
   end
 ```
 
-If you want to use a third-party class (which does not support `#dynamoid_dump` and `.dynamoid_load`)
-as your field type, you can use an adapter class providing `.dynamoid_dump` and `.dynamoid_load` class methods
-for your third-party class.  (`.dynamoid_load` can remain the same from the previous example; here we just
+If you want to use a third-party class (which does not support `#synamoid_dump` and `.synamoid_load`)
+as your field type, you can use an adapter class providing `.synamoid_dump` and `.synamoid_load` class methods
+for your third-party class.  (`.synamoid_load` can remain the same from the previous example; here we just
 add a level of indirection for serializing.)  Example:
 
 ```ruby
@@ -157,17 +157,17 @@ add a level of indirection for serializing.)  Example:
   class Money; end
 
   class MoneyAdapter
-    def self.dynamoid_load(money_serialized_str)
+    def self.synamoid_load(money_serialized_str)
       Money.new(...)
     end
 
-    def self.dynamoid_dump(money_obj)
+    def self.synamoid_dump(money_obj)
       money_obj.value.to_s
     end
   end
 
   class User
-    include Dynamoid::Document
+    include Synamoid::Document
 
     field :balance, MoneyAdapter
   end
@@ -176,20 +176,20 @@ add a level of indirection for serializing.)  Example:
 Lastly, you can control the data type of your custom-class-backed field at the DynamoDB level.
 This is especially important if you want to use your custom field as a numeric range or for
 number-oriented queries.  By default custom fields are persisted as a string attribute, but
-your custom class can override this with a `.dynamoid_field_type` class method, which would
+your custom class can override this with a `.synamoid_field_type` class method, which would
 return either `:string` or `:number`.
-(DynamoDB supports some other attribute types, but Dynamoid does not yet.)
+(DynamoDB supports some other attribute types, but Synamoid does not yet.)
 
 
 ### Associations
 
-Just like in ActiveRecord (or your other favorite ORM), Dynamoid uses associations to create links between models.
+Just like in ActiveRecord (or your other favorite ORM), Synamoid uses associations to create links between models.
 
-The only supported associations (so far) are ```has_many```, ```has_one```, ```has_and_belongs_to_many```, and ```belongs_to```. Associations are very simple to create: just specify the type, the name, and then any options you'd like to pass to the association. If there's an inverse association either inferred or specified directly, Dynamoid will update both objects to point at each other.
+The only supported associations (so far) are ```has_many```, ```has_one```, ```has_and_belongs_to_many```, and ```belongs_to```. Associations are very simple to create: just specify the type, the name, and then any options you'd like to pass to the association. If there's an inverse association either inferred or specified directly, Synamoid will update both objects to point at each other.
 
 ```ruby
 class User
-  include Dynamoid::Document
+  include Synamoid::Document
 
   ...
 
@@ -203,7 +203,7 @@ class User
 end
 
 class Address
-  include Dynamoid::Document
+  include Synamoid::Document
 
   ...
 
@@ -216,11 +216,11 @@ Contrary to what you'd expect, association information is always contained on th
 
 ### Validations
 
-Dynamoid bakes in ActiveModel validations, just like ActiveRecord does.
+Synamoid bakes in ActiveModel validations, just like ActiveRecord does.
 
 ```ruby
 class User
-  include Dynamoid::Document
+  include Synamoid::Document
 
   ...
 
@@ -233,11 +233,11 @@ To see more usage and examples of ActiveModel validations, check out the [Active
 
 ### Callbacks
 
-Dynamoid also employs ActiveModel callbacks. Right now, callbacks are defined on ```save```, ```update```, ```destroy```, which allows you to do ```before_``` or ```after_``` any of those.
+Synamoid also employs ActiveModel callbacks. Right now, callbacks are defined on ```save```, ```update```, ```destroy```, which allows you to do ```before_``` or ```after_``` any of those.
 
 ```ruby
 class User
-  include Dynamoid::Document
+  include Synamoid::Document
 
   ...
 
@@ -251,7 +251,7 @@ end
 
 ### Object Creation
 
-Dynamoid's syntax is generally very similar to ActiveRecord's. Making new objects is simple:
+Synamoid's syntax is generally very similar to ActiveRecord's. Making new objects is simple:
 
 ```ruby
 u = User.new(:name => 'Josh')
@@ -289,7 +289,7 @@ And you can also query on associations:
 u.addresses.where(:city => 'Chicago').all
 ```
 
-But keep in mind Dynamoid -- and document-based storage systems in general -- are not drop-in replacements for existing relational databases. The above query does not efficiently perform a conditional join, but instead finds all the user's addresses and naively filters them in Ruby. For large associations this is a performance hit compared to relational database engines.
+But keep in mind Synamoid -- and document-based storage systems in general -- are not drop-in replacements for existing relational databases. The above query does not efficiently perform a conditional join, but instead finds all the user's addresses and naively filters them in Ruby. For large associations this is a performance hit compared to relational database engines.
 
 You can also limit the number of evaluated records, or select a record from which to start, to support pagination:
 
@@ -297,7 +297,7 @@ You can also limit the number of evaluated records, or select a record from whic
 Address.eval_limit(5).start(address) # Only 5 addresses.
 ```
 
-For large queries that return many rows, Dynamoid can use AWS' support for requesting documents in batches:
+For large queries that return many rows, Synamoid can use AWS' support for requesting documents in batches:
 
 ```ruby
 #Do some maintenance on the entire table without flooding DynamoDB
@@ -316,7 +316,7 @@ Address.where(:city => 'Chicago').consistent.all    # Find all addresses where t
 
 ### Range Finding
 
-If you have a range index, Dynamoid provides a number of additional other convenience methods to make your life a little easier:
+If you have a range index, Synamoid provides a number of additional other convenience methods to make your life a little easier:
 
 ```ruby
 User.where("created_at.gt" => DateTime.now - 1.day).all
@@ -327,7 +327,7 @@ It also supports .gte and .lte. Turning those into symbols and allowing a Rails
 
 ## Concurrency
 
-Dynamoid supports basic, ActiveRecord-like optimistic locking on save operations. Simply add a `lock_version` column to your table like so:
+Synamoid supports basic, ActiveRecord-like optimistic locking on save operations. Simply add a `lock_version` column to your table like so:
 
 ```ruby
 class MyTable
@@ -339,7 +339,7 @@ class MyTable
 end
 ```
 
-In this example, all saves to `MyTable` will raise an `Dynamoid::Errors::StaleObjectError` if a concurrent process loaded, edited, and saved the same row. Your code should trap this exception, reload the row (so that it will pick up the newest values), and try the save again.
+In this example, all saves to `MyTable` will raise an `Synamoid::Errors::StaleObjectError` if a concurrent process loaded, edited, and saved the same row. Your code should trap this exception, reload the row (so that it will pick up the newest values), and try the save again.
 
 Calls to `update` and `update!` also increment the `lock_version`, however they do not check the existing value. This guarantees that a update operation will raise an exception in a concurrent save operation, however a save operation will never cause an update to fail. Thus, `update` is useful & safe only for doing atomic operations (e.g. increment a value, add/remove from a set, etc), but should not be used in a read-modify-write pattern.
 
@@ -348,22 +348,22 @@ Calls to `update` and `update!` also increment the `lock_version`, however they
 In test environment you will most likely want to clean the database between test runs to keep tests completely isolated. This can be achieved like so
 
 ```ruby
-module DynamoidReset
+module SynamoidReset
   def self.all
-    Dynamoid.adapter.list_tables.each do |table|
+    Synamoid.adapter.list_tables.each do |table|
       # Only delete tables in our namespace
-      if table =~ /^#{Dynamoid::Config.namespace}/
-        Dynamoid.adapter.delete_table(table)
+      if table =~ /^#{Synamoid::Config.namespace}/
+        Synamoid.adapter.delete_table(table)
       end
     end
-    Dynamoid.adapter.tables.clear
+    Synamoid.adapter.tables.clear
     # Recreate all tables to avoid unexpected errors
-    Dynamoid.included_models.each(&:create_table)
+    Synamoid.included_models.each(&:create_table)
   end
 end
 
 # Reduce noise in test output
-Dynamoid.logger.level = Logger::FATAL
+Synamoid.logger.level = Logger::FATAL
 ```
 
 If you're using RSpec you can invoke the above like so:
@@ -371,7 +371,7 @@ If you're using RSpec you can invoke the above like so:
 ```ruby
 RSpec.configure do |config|
   config.before(:each) do
-    DynamoidReset.all
+    SynamoidReset.all
   end
 end
 ```
@@ -380,14 +380,14 @@ In Rails, you may also want to ensure you do not delete non-test data accidental
 
 ```ruby
 raise "Tests should be run in 'test' environment only" if Rails.env != 'test'
-Dynamoid.configure do |config|
+Synamoid.configure do |config|
   config.namespace = "#{Rails.application.railtie_name}_#{Rails.env}"
 end
 ```
 
 ## Credits
 
-Dynamoid borrows code, structure, and even its name very liberally from the truly amazing [Mongoid](https://github.com/mongoid/mongoid). Without Mongoid to crib from none of this would have been possible, and I hope they don't mind me reusing their very awesome ideas to make DynamoDB just as accessible to the Ruby world as MongoDB.
+Synamoid borrows code, structure, and even its name very liberally from the truly amazing [Mongoid](https://github.com/mongoid/mongoid). Without Mongoid to crib from none of this would have been possible, and I hope they don't mind me reusing their very awesome ideas to make DynamoDB just as accessible to the Ruby world as MongoDB.
 
 Also, without contributors the project wouldn't be nearly as awesome. So many thanks to:
 
@@ -429,8 +429,8 @@ Running the tests is fairly simple. You should have an instance of DynamoDB runn
     rake
     ```
 
-[![Build Status](https://travis-ci.org/Dynamoid/Dynamoid.svg)](https://travis-ci.org/Dynamoid/Dynamoid)
-[![Coverage Status](https://coveralls.io/repos/Dynamoid/Dynamoid/badge.svg?branch=master&service=github)](https://coveralls.io/github/Dynamoid/Dynamoid?branch=master)
+[![Build Status](https://travis-ci.org/Synamoid/Synamoid.svg)](https://travis-ci.org/Synamoid/Synamoid)
+[![Coverage Status](https://coveralls.io/repos/Synamoid/Synamoid/badge.svg?branch=master&service=github)](https://coveralls.io/github/Synamoid/Synamoid?branch=master)
 
 ## Copyright
 

metadata

@@ -1,7 +1,7 @@
 --- !ruby/object:Gem::Specification
 name: synamoid
 version: !ruby/object:Gem::Version
-  version: 1.2.1
+  version: 1.2.2
 platform: ruby
 authors:
 - Josh Symonds
@@ -190,9 +190,8 @@ dependencies:
     - - ">="
       - !ruby/object:Gem::Version
         version: '0'
-description: Dynamoid is an ORM for Amazon's DynamoDB that supports offline development,
-  associations, querying, and everything else you'd expect from an ActiveRecord-style
-  replacement.
+description: Synamoid is Dynamoid just change only dependency and name to push to
+  rubygem only nothing's mine.
 email:
 - peter.boling@gmail.com
 - brian@stellaservice.com
@@ -202,44 +201,9 @@ extra_rdoc_files:
 - LICENSE.txt
 - README.md
 files:
-- ".document"
-- ".gitignore"
-- ".rspec"
-- ".travis.yml"
-- CHANGELOG.md
-- Gemfile
 - LICENSE.txt
 - README.md
-- Rakefile
-- dynamoid.gemspec
-- lib/dynamoid.rb
-- lib/dynamoid/adapter.rb
-- lib/dynamoid/adapter_plugin/aws_sdk_v2.rb
-- lib/dynamoid/associations.rb
-- lib/dynamoid/associations/association.rb
-- lib/dynamoid/associations/belongs_to.rb
-- lib/dynamoid/associations/has_and_belongs_to_many.rb
-- lib/dynamoid/associations/has_many.rb
-- lib/dynamoid/associations/has_one.rb
-- lib/dynamoid/associations/many_association.rb
-- lib/dynamoid/associations/single_association.rb
-- lib/dynamoid/components.rb
-- lib/dynamoid/config.rb
-- lib/dynamoid/config/options.rb
-- lib/dynamoid/criteria.rb
-- lib/dynamoid/criteria/chain.rb
-- lib/dynamoid/dirty.rb
-- lib/dynamoid/document.rb
-- lib/dynamoid/errors.rb
-- lib/dynamoid/fields.rb
-- lib/dynamoid/finders.rb
-- lib/dynamoid/identity_map.rb
-- lib/dynamoid/indexes.rb
-- lib/dynamoid/middleware/identity_map.rb
-- lib/dynamoid/persistence.rb
-- lib/dynamoid/validations.rb
-- lib/dynamoid/version.rb
-homepage: http://github.com/Dynamoid/Dynamoid
+homepage: http://github.com/Synamoid/Synamoid
 licenses:
 - MIT
 metadata: {}
@@ -262,5 +226,5 @@ rubyforge_project:
 rubygems_version: 2.5.1
 signing_key: 
 specification_version: 4
-summary: Dynamoid is an ORM for Amazon's DynamoDB
+summary: Synamoid is an ORM for Amazon's DynamoDB
 test_files: []

data/.document

@@ -1,5 +0,0 @@
-lib/**/*.rb
-bin/*
-- 
-features/**/*.feature
-LICENSE.txt

data/.gitignore

@@ -1,67 +0,0 @@
-.project
-
-# rcov generated
-coverage
-
-# rdoc generated
-rdoc
-
-# yardoc generated
-.yardoc
-/_yardoc/
-
-# bundler
-/.bundle/
-
-# jeweler generated
-/pkg/
-
-# Have editor/IDE/OS specific files you need to ignore? Consider using a global gitignore:
-#
-# * Create a file at ~/.gitignore
-# * Include files you want ignored
-# * Run: git config --global core.excludesfile ~/.gitignore
-#
-# After doing this, these files will be ignored in all your git projects,
-# saving you from having to 'pollute' every project you touch with them
-#
-# Not sure what to needs to be ignored for particular editors/OSes? Here's some ideas to get you started. (Remember, remove the leading # of the line)
-#
-# For MacOS:
-#
-#.DS_Store
-
-# For TextMate
-#*.tmproj
-#tmtags
-
-# For emacs:
-#*~
-#\#*
-#.\#*
-
-# For vim:
-#*.swp
-
-# For redcar:
-#.redcar
-
-# For rubinius:
-#*.rbc
-
-# for RVM
-.rvmrc
-
-# For RubyMine:
-/.idea/
-
-# For Ctags
-.gemtags
-.tags
-.tags_sorted_by_file
-
-Gemfile.lock
-/doc/
-/spec/reports/
-/tmp/
-/spec/DynamoDBLocal-latest/