module Dynamoid::Persistence::ClassMethods

Public Instance Methods

create_table(options = {}) click to toggle source

Creates a table.

@param [Hash] options options to pass for table creation @option options [Symbol] :id the id field for the table @option options [Symbol] :table_name the actual name for the table @option options [Integer] :read_capacity set the read capacity for the table; does not work on existing tables @option options [Integer] :write_capacity set the write capacity for the table; does not work on existing tables @option options [Hash] {range_key => :type} a hash of the name of the range key and a symbol of its type

@since 0.4.0

# File lib/dynamoid/persistence.rb, line 33
def create_table(options = {})
  if self.range_key
    range_key_hash = { range_key => dynamo_type(attributes[range_key][:type]) }
  else
    range_key_hash = nil
  end
  options = {
    :id => self.hash_key,
    :table_name => self.table_name,
    :write_capacity => self.write_capacity,
    :read_capacity => self.read_capacity,
    :range_key => range_key_hash
  }.merge(options)

  return true if table_exists?(options[:table_name])

  Dynamoid::Adapter.tables << options[:table_name] if Dynamoid::Adapter.create_table(options[:table_name], options[:id], options)
end
dynamo_type(type) click to toggle source
# File lib/dynamoid/persistence.rb, line 115
def dynamo_type(type)
  case type
  when :integer, :float, :datetime
    :number
  when :string, :serialized
    :string
  else
    raise 'unknown type'
  end
end
from_database(attrs = {}) click to toggle source
# File lib/dynamoid/persistence.rb, line 59
def from_database(attrs = {})
  new(attrs).tap { |r| r.new_record = false }
end
table_exists?(table_name) click to toggle source

Does a table with this name exist?

@since 0.2.0

# File lib/dynamoid/persistence.rb, line 55
def table_exists?(table_name)
  Dynamoid::Adapter.tables ? Dynamoid::Adapter.tables.include?(table_name) : false
end
table_name() click to toggle source

Returns the name of the table the class is for.

@since 0.2.0

# File lib/dynamoid/persistence.rb, line 19
def table_name
  "#{Dynamoid::Config.namespace}_#{options[:name] ? options[:name] : self.name.split('::').last.downcase.pluralize}"
end
undump(incoming = nil) click to toggle source

Undump an object into a hash, converting each type from a string representation of itself into the type specified by the field.

@since 0.2.0

# File lib/dynamoid/persistence.rb, line 66
def undump(incoming = nil)
  incoming = (incoming || {}).symbolize_keys
  Hash.new.tap do |hash|
    self.attributes.each do |attribute, options|
      hash[attribute] = undump_field(incoming[attribute], options)
    end
    incoming.each {|attribute, value| hash[attribute] ||= value }
  end
end
undump_field(value, options) click to toggle source

Undump a value for a given type. Given a string, it’ll determine (based on the type provided) whether to turn it into a string, integer, float, set, array, datetime, or serialized return value.

@since 0.2.0

# File lib/dynamoid/persistence.rb, line 80
def undump_field(value, options)
  if value.nil? && (default_value = options[:default])
    value = default_value.respond_to?(:call) ? default_value.call : default_value
  else
    return if value.nil? || (value.respond_to?(:empty?) && value.empty?)
  end

  case options[:type]
  when :string
    value.to_s
  when :integer
    value.to_i
  when :float
    value.to_f
  when :set, :array
    if value.is_a?(Set) || value.is_a?(Array)
      value
    else
      Set[value]
    end
  when :datetime
    if value.is_a?(Date) || value.is_a?(DateTime) || value.is_a?(Time)
      value
    else
      Time.at(value).to_datetime
    end
  when :serialized
    if value.is_a?(String)
      options[:serializer] ? options[:serializer].load(value) : YAML.load(value)
    else
      value
    end
  end
end