dynameek 0.0.1a

data/lib/dynameek/dynamo_db.rb

@@ -0,0 +1,58 @@
+module Dynameek
+  module DynamoDb
+    def convert_from_dynamodb(type, value)
+      case type
+        when :integer
+          value.to_i
+        when :float
+          value.to_f
+        when :string
+          value.to_s
+        when :datetime
+          Time.at(value).to_datetime
+        else
+          value
+      end
+    end
+    def convert_to_dynamodb(type, value)
+      case type
+        when :datetime
+          value.to_time.to_f
+        else
+          value
+      end
+    end
+    
+    def exists?
+      table.exists?
+    end
+    
+    def build!
+      return if dynamo_db.tables[table_name].exists?
+      new_table = dynamo_db.tables.create(table_name, @@read_write[0], @@read_write[1],
+        :hash_key => { @@hash_key.field => @@hash_key.type },
+        :range_key => { @@range.field => @@range.type == :datetime ? :number : @@range.type }
+      )
+      puts "Creating table, this may take a few minutes"
+      while new_table.status == :creating
+        sleep 1
+      end
+    end
+    
+    @@table = nil
+    @@dynamo_db = nil
+
+    def dynamo_db
+      @@dynamo_db = AWS::DynamoDB.new if @@dynamo_db.nil?
+      @@dynamo_db
+    end
+
+    def table
+      build!
+      @@table = dynamo_db.tables[table_name] if @@table.nil?
+      @@table.load_schema if !@@table.schema_loaded?
+      @@table
+    end
+    
+  end
+end

data/lib/dynameek/model.rb

@@ -0,0 +1,92 @@
+class Dynameek::Model
+  extend Dynameek::DynamoDb
+  extend Dynameek::ModelStructure
+  extend Dynameek::Query
+  
+  
+  
+  
+  attr_accessor :attributes
+  
+  
+  
+  def self.find(hash_key, range_val=nil)
+    raise Exception("This has a composite hash with a range, the range val is required") if(range_val.nil? && !@@range.field.nil?)
+    #multicolumn
+    hash_key = hash_key.join(multi_column_join) if(hash_key.is_a?(Array))
+
+    items = if !range_val.nil?
+      range_val = convert_to_dynamodb(range_field.type, range_val)
+      table.batch_get(:all, [[hash_key, range_val]])
+    else  
+      table.batch_get(:all, [hash_key])
+    end
+    # p items.methods - Object.new.methods
+    return nil if(items.entries.size == 0)
+    item_to_instance(items.first)
+    
+  end
+  
+
+  
+  def self.item_to_instance(item)
+    item = item.attributes if item.is_a?(AWS::DynamoDB::Item)
+    instance = self.new
+    fields.each do |field, type|
+      next if multi_column_hash_key? && field == hash_key_field.field
+      instance.send "#{field.to_s}=", convert_from_dynamodb(type, item[field.to_s])
+    end
+    instance
+  end
+  
+
+  
+  def self.create(attrib)
+    instance = self.new
+    attrib.each do |key, val|
+      instance.send "#{key.to_s}=", val
+    end
+    instance.save
+  end
+  
+  @@before_save_callbacks = Set.new
+  def self.before_save method
+    @@before_save_callbacks.add(method.to_sym)  
+  end
+  
+  def save
+    attribs = self.class.fields.reduce({}) do |memo, (field, type)|
+      #Always call the read method in case it has been overwritten
+      #Note that this is required for the multicolumn key
+      val =  self.send field
+      val = self.class.convert_to_dynamodb(type, val)
+      memo[field] = val
+      memo
+    end
+    @@before_save_callbacks.each{|method| self.send method}
+    self.class.table.batch_write(
+      :put => [
+        attribs
+      ]
+    )
+    self
+  end
+
+  
+  def self.table_name
+    self.to_s
+  end
+  
+  private
+  
+  def read_attribute(fieldname)
+    @attributes[fieldname]
+  end
+
+  def write_attribute(fieldname, value)
+    @attributes = {} if(!@attributes) 
+    @attributes[fieldname] = value
+  end
+
+  
+end

data/lib/dynameek/model_structure.rb

@@ -0,0 +1,106 @@
+module Dynameek
+  module ModelStructure
+    
+    @@fields = {}
+    @@hash_key = OpenStruct.new
+    @@hash_key.field = nil
+    @@hash_key.type = nil
+
+    @@range = OpenStruct.new
+    @@range.field = nil
+    @@range.type = nil
+
+    @@read_write = [10, 5]
+
+    @@multi_column_hash_key_fields = []
+    @@multi_column_join = "|"
+    
+    
+    def field fieldname, type
+      fieldname = fieldname.to_sym
+      type = type.to_sym
+      @@fields[fieldname] = type
+      define_method(fieldname.to_s) { read_attribute(fieldname) }
+      define_method("#{fieldname.to_s}?") { !read_attribute(fieldname).nil? }
+      define_method("#{fieldname.to_s}=") {|value| write_attribute(fieldname, value) }
+    end 
+
+
+
+    def hash_key fieldname
+      fieldname = fieldname.to_sym
+      check_field(fieldname)
+      @@hash_key.field = fieldname
+      @@hash_key.type = @@fields[fieldname]
+      define_method(:hash_key) { read_attribute(fieldname) }
+    end
+
+    def multi_column_join
+      @@multi_column_join
+    end
+    def multi_column_join=(join)
+      @@multi_column_join = join
+    end
+    def multi_column_hash_key?
+      !@@multi_column_hash_key_fields.empty?
+    end
+    
+    
+    
+    def multi_column_hash_key fieldnames
+      fields = fieldnames.map(&:to_sym)
+      fields.each{|f| check_field(f)}
+      @@multi_column_hash_key_fields = fields
+      fieldname = fieldnames.map(&:to_s).join("_").to_s
+      @@fields[fieldname] = :string
+      define_method(:hash_key) do
+        @@multi_column_hash_key_fields.reduce([]) do |memo, field|
+          memo << attributes[field]
+          memo
+        end.join(@@multi_column_join)
+      end
+      alias_method fieldname, :hash_key
+      @@hash_key.field = fieldname
+      @@hash_key.type = :string
+    end
+    
+    def hash_key_field
+      @@hash_key
+    end
+
+
+    def range fieldname
+      fieldname = fieldname.to_sym
+      check_field(fieldname)
+      @@range.field = fieldname
+      @@range.type = @@fields[fieldname]
+    end
+
+    
+    def read_write read, write
+      @@read_write = [read, write]
+    end
+    
+    def read_units
+      @@read_write[0]
+    end
+    def write_units
+      @@read_write[1]
+    end
+    
+    def fields
+      @@fields
+    end
+    
+    def range_field
+      @@range.field.nil? ? nil : @@range
+    end
+
+    def check_field(fieldname)
+      raise Exception("#{fieldname} is not a recognised field") if @@fields[fieldname].nil?
+    end
+
+  end
+end
+
+  

data/lib/dynameek/query.rb

@@ -0,0 +1,77 @@
+module Dynameek
+  module Query
+    #Similar to dynamoids approach but lighter (hopefully)
+    
+    class QueryChain
+      
+      def initialize(model)
+        @model = model
+        @hash_key = nil
+        @range = {eq: nil, within: nil, gte: nil, gt: nil, lte: nil, lt: nil, begins_with: nil}
+      end
+      
+      def query(hash_key)
+        @hash_key = hash_key
+        self
+      end
+      
+      def where(value, op=:eq)
+        raise Exception("Op #{op.to_s} not recognised") if(!@range.keys.include?(op))
+        @range[op] = value
+        self
+      end
+      
+      def all
+        run
+      end
+      
+      def each
+        all.each
+      end
+      
+      def each_with_index
+        all.each_with_index
+      end
+      
+      RANGE_QUERY_MAP =
+      {
+        eq: :range_value,
+        within: :range_value,
+        gte: :range_gte,
+        gt: :range_greater_than,
+        lte: :range_lte,
+        lt: :range_less_than,
+        begins_with: :range_begins_with
+      }
+      
+      private
+      
+      def run
+        hash_key = @hash_key
+        hash_key = hash_key.join(@model.multi_column_join) if(hash_key.is_a?(Array))
+        
+        query_hash = {:hash_value => hash_key}
+        
+        query_hash = @range.reduce(query_hash) do |hsh, (key, val)|
+          if(!val.nil?)
+            hsh[RANGE_QUERY_MAP[key]] = @model.convert_to_dynamodb(@model.range_field.type, val)
+          end
+          hsh
+        end
+        @model.table.items.query(query_hash).map{|item| @model.item_to_instance(item)}
+        
+      end
+      
+    
+    end
+    
+    [:query, :where, :all, :each, :each_with_index].each do |method|
+      define_method(method) do |*args|
+        qc = QueryChain.new(self)
+        args = [] if !args
+        qc.send method, *args
+      end
+    end
+    
+  end
+end

data/lib/dynameek.rb

@@ -0,0 +1,7 @@
+module Dynameek
+end
+
+require File.join(File.dirname(__FILE__), *%w[dynameek dynamo_db])
+require File.join(File.dirname(__FILE__), *%w[dynameek query])
+require File.join(File.dirname(__FILE__), *%w[dynameek model_structure])
+require File.join(File.dirname(__FILE__), *%w[dynameek model])

metadata

@@ -0,0 +1,58 @@
+--- !ruby/object:Gem::Specification 
+name: dynameek
+version: !ruby/object:Gem::Version 
+  prerelease: 5
+  version: 0.0.1a
+platform: ruby
+authors: 
+- Max Dupenois
+autorequire: 
+bindir: bin
+cert_chain: []
+
+date: 2013-03-20 00:00:00 Z
+dependencies: []
+
+description: A very lightweight model for DynamoDB tables in, certainly not in a finished state
+email: max.dupenois@forward.co.uk
+executables: []
+
+extensions: []
+
+extra_rdoc_files: []
+
+files: 
+- lib/dynameek/dynamo_db.rb
+- lib/dynameek/model.rb
+- lib/dynameek/model_structure.rb
+- lib/dynameek/query.rb
+- lib/dynameek.rb
+homepage: http://github.com/maxdupenois/dynameek
+licenses: []
+
+post_install_message: 
+rdoc_options: []
+
+require_paths: 
+- lib
+required_ruby_version: !ruby/object:Gem::Requirement 
+  none: false
+  requirements: 
+  - - ">="
+    - !ruby/object:Gem::Version 
+      version: "0"
+required_rubygems_version: !ruby/object:Gem::Requirement 
+  none: false
+  requirements: 
+  - - ">"
+    - !ruby/object:Gem::Version 
+      version: 1.3.1
+requirements: []
+
+rubyforge_project: 
+rubygems_version: 1.8.24
+signing_key: 
+specification_version: 3
+summary: Dynameek
+test_files: []
+