class AWS::Record::HashModel::Scope

Book.shard(‘books-1’).first
# terminate a scope by getting the first record
Book.limit(10).each {|book| … }
# terminate a scope by enumerating
To terminate a scope you can enumerate it or call #first.
## Terminating Scopes
* {#limit}
* {#shard}
The following methods returns a scope that can be chained.
end
# yields up to 10 books from the table ‘books-1’
books.each do |book|
books = books.limit(10) # how many records to fetch
books = Book.shard(‘books-1’) # what table to search
# no request made by the following 2 statements
until required. This allows you to chain requests
Scope objects represent a request, but do not actualy make a request
## Chaining Scopes
Book.sampling #=> returns a scope that limits to 10
end
scope :sampling, limit(10)
class Book < AWS::Record::HashModel
Scopes are also returned from methods defined with the ‘scope` method.
books.class #=> AWS::Record::HashModel::Scope
books = Book.limit(100)
methods # (e.g. `shard` and `limit`).
Scope objects are returned from the AWS::Record::HashModel finder
You should normally never need to construct a Scope object directly.
## Getting a Scope Object
The primary interface for finding records with {AWS::Record::HashModel}.

def _each_object &block

def _each_object &block
  items = _item_collection
  items.select(:limit => @options[:limit]).each do |item_data|
    obj = base_class.new(:shard => _shard)
    obj.send(:hydrate, item_data.attributes['id'], item_data.attributes)
    yield(obj)
  end
end

def _handle_options options

def _handle_options options
  scope = self
  options.each_pair do |method, args|
    scope = scope.send(method, *args)
  end
  scope
end

def _item_collection

def _item_collection
  base_class.dynamo_db_table(_shard).items
end

def _merge_scope scope

def _merge_scope scope
  merged = self
  scope.instance_variable_get('@options').each_pair do |opt_name,opt_value|
    unless [nil, []].include?(opt_value)
      merged = merged.send(opt_name, *opt_value)
    end
  end
  merged
end