dinamo 0.1.0

checksums.yaml

@@ -0,0 +1,7 @@
+---
+SHA1:
+  metadata.gz: f5fe3967b08bb83ba8b65bb065bf886b133a559b
+  data.tar.gz: ff65fae8abc087bf0b622562468292ebff19d444
+SHA512:
+  metadata.gz: 71c0a99f50c16c791eed652d77ff743d22cd8c37bf6bc5f3df17e260a4541cd525d39d1b802618d26692c7ef1fcbb6ce5ce2e221121a7297d56324eff8515729
+  data.tar.gz: 181d5051ecead6d8868853ee331c85b43f2a49fe2338d4662a38e8feb15c9f2c5ff0c298866b8b0e957fafd5f44cd13b97abebb4994f12fcdf8803e1de3c0301

data/.gitignore

@@ -0,0 +1,9 @@
+/.bundle/
+/.yardoc
+/Gemfile.lock
+/_yardoc/
+/coverage/
+/doc/
+/pkg/
+/spec/reports/
+/tmp/

data/.rspec

@@ -0,0 +1,2 @@
+--format documentation
+--color

data/.travis.yml

@@ -0,0 +1,4 @@
+language: ruby
+rvm:
+  - 2.2.3
+before_install: gem install bundler -v 1.10.6

data/CODE_OF_CONDUCT.md

@@ -0,0 +1,13 @@
+# Contributor Code of Conduct
+
+As contributors and maintainers of this project, we pledge to respect all people who contribute through reporting issues, posting feature requests, updating documentation, submitting pull requests or patches, and other activities.
+
+We are committed to making participation in this project a harassment-free experience for everyone, regardless of level of experience, gender, gender identity and expression, sexual orientation, disability, personal appearance, body size, race, ethnicity, age, or religion.
+
+Examples of unacceptable behavior by participants include the use of sexual language or imagery, derogatory comments or personal attacks, trolling, public or private harassment, insults, or other unprofessional conduct.
+
+Project maintainers have the right and responsibility to remove, edit, or reject comments, commits, code, wiki edits, issues, and other contributions that are not aligned to this Code of Conduct. Project maintainers who do not follow the Code of Conduct may be removed from the project team.
+
+Instances of abusive, harassing, or otherwise unacceptable behavior may be reported by opening an issue or contacting one or more of the project maintainers.
+
+This Code of Conduct is adapted from the [Contributor Covenant](http://contributor-covenant.org), version 1.0.0, available at [http://contributor-covenant.org/version/1/0/0/](http://contributor-covenant.org/version/1/0/0/)

data/Gemfile

@@ -0,0 +1,4 @@
+source 'https://rubygems.org'
+
+# Specify your gem's dependencies in dinamo.gemspec
+gemspec

data/LICENSE.txt

@@ -0,0 +1,21 @@
+The MIT License (MIT)
+
+Copyright (c) 2015 namusyaka
+
+Permission is hereby granted, free of charge, to any person obtaining a copy
+of this software and associated documentation files (the "Software"), to deal
+in the Software without restriction, including without limitation the rights
+to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
+copies of the Software, and to permit persons to whom the Software is
+furnished to do so, subject to the following conditions:
+
+The above copyright notice and this permission notice shall be included in
+all copies or substantial portions of the Software.
+
+THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
+AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
+LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
+OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN
+THE SOFTWARE.

data/README.md

@@ -0,0 +1,52 @@
+# Dinamo
+
+Dinamo is an simple ORM for Amazon DynamoDB for Ruby applications.
+
+## Installation
+
+Add this line to your application's Gemfile:
+
+```ruby
+gem 'dinamo'
+```
+
+And then execute:
+
+    $ bundle
+
+Or install it yourself as:
+
+    $ gem install dinamo
+
+## Usage
+
+### Sample
+
+Your class must inherit `Dinamo::Model` in every Dinamo model.
+
+```ruby
+class User < Dinamo::Model
+  hash_key :id, type: :number
+  range_key :kind, type: :string
+  field :name, type: :string
+end
+
+user = User.new
+user.id   = 1
+user.kind = "developer"
+user.name = "namusyaka"
+
+user.valid? #=> true
+user.errors #=> {}
+user.save #=> true
+```
+
+## Contributing
+
+Bug reports and pull requests are welcome on GitHub at https://github.com/namusyaka/dinamo. This project is intended to be a safe, welcoming space for collaboration, and contributors are expected to adhere to the [Contributor Covenant](contributor-covenant.org) code of conduct.
+
+
+## License
+
+The gem is available as open source under the terms of the [MIT License](http://opensource.org/licenses/MIT).
+

data/Rakefile

@@ -0,0 +1,10 @@
+require "bundler/gem_tasks"
+require "rake/testtask"
+
+Rake::TestTask.new do |t|
+  t.libs << "test"
+  t.test_files = Dir["test/**/test_*.rb"]
+  t.verbose = true
+end
+
+task :default => :test

data/bin/console

@@ -0,0 +1,14 @@
+#!/usr/bin/env ruby
+
+require "bundler/setup"
+require "dinamo"
+
+# You can add fixtures and/or initialization code here to make experimenting
+# with your gem easier. You can also use a different console, if you like.
+
+# (If you use this, don't forget to add pry to your Gemfile!)
+# require "pry"
+# Pry.start
+
+require "irb"
+IRB.start

data/bin/setup

@@ -0,0 +1,7 @@
+#!/bin/bash
+set -euo pipefail
+IFS=$'\n\t'
+
+bundle install
+
+# Do any other automated setup that you need to do here

data/dinamo.gemspec

@@ -0,0 +1,38 @@
+# coding: utf-8
+lib = File.expand_path('../lib', __FILE__)
+$LOAD_PATH.unshift(lib) unless $LOAD_PATH.include?(lib)
+require 'dinamo/version'
+
+Gem::Specification.new do |spec|
+  spec.name          = "dinamo"
+  spec.version       = Dinamo::VERSION
+  spec.authors       = ["namusyaka"]
+  spec.email         = ["namusyaka@gmail.com"]
+
+  spec.summary       = "DynamoDB ORM for Ruby"
+  spec.description   = "DynamoDB ORM for Ruby"
+  spec.homepage      = "https://github.com/namusyaka/dinamo"
+  spec.license       = "MIT"
+
+  # Prevent pushing this gem to RubyGems.org by setting 'allowed_push_host', or
+  # delete this section to allow pushing this gem to any host.
+  if spec.respond_to?(:metadata)
+    spec.metadata['allowed_push_host'] = "TODO: Set to 'http://mygemserver.com'"
+  else
+    raise "RubyGems 2.0 or newer is required to protect against public gem pushes."
+  end
+
+  spec.files         = `git ls-files -z`.split("\x0").reject { |f| f.match(%r{^(test|spec|features)/}) }
+  spec.bindir        = "exe"
+  spec.executables   = spec.files.grep(%r{^exe/}) { |f| File.basename(f) }
+  spec.require_paths = ["lib"]
+
+  spec.add_dependency "activesupport", "~> 4.2.4"
+  spec.add_dependency "aws-sdk",       "~> 2.1.26"
+
+  spec.add_development_dependency "bundler", "~> 1.10"
+  spec.add_development_dependency "rake", "~> 10.0"
+  spec.add_development_dependency "test-unit"
+  spec.add_development_dependency "test-unit-rr"
+  spec.add_development_dependency "test-unit-power_assert"
+end

data/lib/dinamo/adapter.rb

@@ -0,0 +1,89 @@
+require 'dinamo/exceptions'
+require 'aws-sdk'
+
+module Dinamo
+  class Adapter
+    module Glue
+      def adapter_options
+        @adapter_options ||= {}
+      end
+
+      def adapter
+        @adapter ||= {}
+        @adapter[table_name] ||= Dinamo::Adapter.new(table_name: table_name, **adapter_options)
+      end
+    end
+
+    def initialize(table_name: nil, **options)
+      @options    = options
+      @database   = Aws::DynamoDB::Client.new
+      @table_name = table_name
+    end
+
+    def get(**keys)
+      @database.get_item(table_name: @table_name, key: keys)
+    rescue
+      handle_error! $!
+    end
+
+    def insert(**keys)
+      @database.put_item(
+        table_name: @table_name,
+        item: keys,
+        return_values: "ALL_OLD"
+      )
+    rescue
+      handle_error! $!
+    end
+
+    def update(key, attributes)
+      find_or_abort!(**key)
+      @database.update_item(
+        table_name: @table_name,
+        key: key,
+        attribute_updates: serialize_attributes(attributes),
+        return_values: "ALL_NEW"
+      )
+    rescue
+      handle_error! $!
+    end
+
+    def delete(key)
+      find_or_abort!(**key)
+      @database.update_item(
+        table_name: @table_name,
+        key: key
+      )
+    end
+
+    def serialize_attributes(attributes)
+      attributes.each_with_object({}) do |(key, value), new_attributes|
+        new_attributes[key] = { value: value, action: "PUT" }
+      end
+    end
+
+    def exist?(**keys)
+      !!get(**keys).item rescue false
+    end
+
+    private
+
+    def find_or_abort!(**key)
+      item = get(**key)
+      fail Exceptions::RecordNotFoundError,
+        "Corresponding record (%p) can not be found" % key unless item && item.item
+      item
+    end
+
+    def handle_error!(evar)
+      case evar
+      when Aws::DynamoDB::Errors::ValidationException
+        fail Dinamo::Exceptions::ValidationError, evar.message
+      when Aws::DynamoDB::Errors::ResourceNotFoundException
+        fail Dinamo::Exceptions::ResourceNotFoundError, evar.message
+      else
+        fail evar, evar.message
+      end
+    end
+  end
+end

data/lib/dinamo/exceptions.rb

@@ -0,0 +1,10 @@
+module Dinamo
+  module Exceptions
+    CastError             = Class.new(ArgumentError)
+    PrimaryKeyError       = Class.new(ArgumentError)
+    ValidationError       = Class.new(ArgumentError)
+    RecordNotFoundError   = Class.new(ArgumentError)
+    UnsupportedTypeError  = Class.new(ArgumentError)
+    ResourceNotFoundError = Class.new(StandardError)
+  end
+end

data/lib/dinamo/model/attributes.rb

@@ -0,0 +1,166 @@
+require 'active_support/core_ext/hash/indifferent_access'
+require 'dinamo/model/caster'
+
+module Dinamo
+  class Model
+    module Attributes
+      extend ActiveSupport::Concern
+
+      included do
+        before(:save) { self.attributes = self.class.caster.cast(attributes) }
+        after(:save) { changes_applied }
+
+        before :initialize do |**attributes|
+          @attributes = {}.with_indifferent_access
+          silent_assign(**attributes)
+          self.class.define_attribute_methods(*attributes.keys)
+        end
+
+        before :attribute_update do |attribute, value|
+          pkey = primary_keys[attribute]
+          if persisted? && pkey && pkey != value
+            raise Exceptions::PrimaryKeyError, "%p cannot be modified" % attribute
+          end
+        end
+      end
+
+      module ClassMethods
+        def attribute_methods
+          @attribute_names ||= []
+        end
+
+        def attribute_method?(attr)
+          attribute_methods.include?(attr)
+        end
+
+        def attribute_method_already_implemented?(attr)
+          attribute_method?(attr) && respond_to?(attr) && respond_to?("#{attr}=")
+        end
+
+        def define_attribute_methods(*attrs)
+          attrs.each { |attr| define_attribute_method(attr) }
+        end
+
+        def define_attribute_method(attr)
+          return if attribute_method_already_implemented?(attr)
+          define_method(attr) { @attributes[attr] }
+          define_method("#{attr}=") do |val|
+            with_callback :attribute_update, attr, val do
+              @attributes[attr] = val
+            end
+          end
+          attribute_methods << attr
+        end
+
+        def primary_keys
+          @primary_keys ||= {}
+        end
+
+        def primary_key(kind, key, type: nil, **options)
+          name = :"@#{kind}_key"
+          var = instance_variable_get(name)
+          primary_keys[kind] = key
+          var ? var : instance_variable_set(name, key.to_s)
+          define_attribute_method key
+          supported_fields << Key.new(key.to_s, type: type, required: true, primary: true)
+        end
+
+        def supported_fields
+          @supported_fields ||= []
+        end
+
+        def required_fields
+          supported_fields.select(&:required?)
+        end
+
+        def field(key, type: nil, **options)
+          caster.associate(key, type) if type
+          supported_fields << Key.new(key.to_s, type: type, **options)
+          define_attribute_method(key) unless respond_to?(:"#{key}=")
+        end
+
+        def hash_key(key, **options)
+          primary_key :hash, key, **options
+        end
+
+        def range_key(key, **options)
+          primary_key :range, key, **options
+        end
+
+        def caster
+          @caster ||= Caster.new
+        end
+
+        def cast(type, &block)
+          caster.register(type, &block)
+        end
+      end
+
+      attr_reader :attributes
+
+      def [](key)
+        attributes[key]
+      end
+
+      def []=(key, value)
+        self.attributes = { key => value }
+      end
+
+      def variable_attributes
+        keys = primary_keys.keys
+        attributes.select { |key, _| !keys.include?(key.to_sym) }
+      end
+
+      def attributes=(attrs)
+        attrs.each_pair do |key, val|
+          name = "#{key}="
+          self.class.define_attribute_method(key) unless respond_to?(name)
+          send(name, val)
+        end
+      end
+
+      def hash_key
+        attributes[self.class.primary_keys[:hash]]
+      end
+
+      def range_key
+        attributes[self.class.primary_keys[:range]]
+      end
+      
+      def silent_assign(new_attributes)
+        @attributes.merge!(new_attributes)
+      end
+
+      def ==(other)
+        return false unless other.kind_of?(Dinamo::Model)
+        hash_key == other.hash_key && range_key == other.range_key
+      end
+      alias equal? ==
+
+      def primary_keys
+        @primary_keys ||= self.class.primary_keys.inject({}) do |keys, (_, key)|
+          keys.merge(key => attributes[key])
+        end
+      end
+
+      class Key
+        attr_reader :name, :type
+
+        def initialize(name, type: nil, required: false, primary: false, **options)
+          @name = name
+          @type = type
+          @required = required
+          @primary = primary
+        end
+
+        def required?
+          @required
+        end
+
+        def primary?
+          @primary
+        end
+      end
+    end
+  end
+end

data/lib/dinamo/model/callback.rb

@@ -0,0 +1,39 @@
+module Dinamo
+  class Model
+    module Callback
+      extend ActiveSupport::Concern
+
+      def with_callback(kind, *args, &block)
+        invoke_callbacks(:before, kind, *args)
+        block.call
+      ensure
+        invoke_callbacks(:after, kind, *args)
+      end
+
+      def invoke_callbacks(type, kind, *args)
+        ref = respond_to?(:callbacks) ? callbacks : self.class.callbacks
+        current = ref[type][kind]
+        return unless current
+        current.each { |callback| instance_exec(*args, &callback) }
+      end
+
+      module ClassMethods
+        def on(type, kind, &callback)
+          (callbacks[type][kind] ||= []) << callback
+        end
+
+        def before(kind, &callback)
+          on(:before, kind, &callback)
+        end
+
+        def after(kind, &callback)
+          on(:after, kind, &callback)
+        end
+
+        def callbacks
+          @callbacks ||= { before: {}, after: {} }
+        end
+      end
+    end
+  end
+end

data/lib/dinamo/model/caster.rb

@@ -0,0 +1,75 @@
+require 'delegate'
+
+module Dinamo
+  class Model
+    class Caster
+      attr_reader :types
+
+      def initialize
+        @types = {}
+      end
+
+      def register(type, &block)
+        @types[type] = Any.new(type, &block)
+      end
+
+      def cast(attributes)
+        attributes.each_with_object({}) do |(key, value), casted|
+          casted[key] =
+            if found = @types.find { |_, any| any.supported_key?(key) }
+              found.pop.cast(value)
+            else
+              value
+            end
+        end
+      end
+
+      def supported_type?(type)
+        supported_types.include?(type)
+      end
+
+      def supported_types
+        @types.keys
+      end
+
+      def associate(key, type)
+        fail Exceptions::UnsupportedTypeError,
+          "%p type is not supported" % type unless @types.keys.include?(type)
+        current = @types[type]
+        current.support(key)
+      end
+
+      class Any
+        def initialize(type, &block)
+          @type = type
+          @block = block
+        end
+
+        def cast(value)
+          case @block.arity
+          when 0 then @block.call
+          when 1 then @block.call(value)
+          when 2 then @block.call(@type, value)
+          end
+        rescue
+          fail Exceptions::CastError,
+            "%p can not be casted into %p" % [value, @type]
+        end
+
+        def support(key)
+          keys << key.to_sym unless supported_key?(key)
+        end
+
+        def supported_key?(key)
+          keys.include?(key.to_sym)
+        end
+
+        private
+
+        def keys
+          @keys ||= []
+        end
+      end
+    end
+  end
+end

data/lib/dinamo/model/dirty.rb

@@ -0,0 +1,64 @@
+module Dinamo
+  class Model
+    module Dirty
+      extend ActiveSupport::Concern
+
+      included do
+        before :attribute_update do |attr, val|
+          previous_attribute = @attributes[attr]
+          unless previous_attribute == val
+            changed_attributes[attr]  = val
+            previous_attributes[attr] = previous_attribute
+          end
+        end
+        after(:save) { changes_applied }
+      end
+
+      def changed
+        changed_attributes.keys
+      end
+
+      def changed?
+        !changed_attributes.empty?
+      end
+
+      def changes
+        map = changed.map { |attr| [attr, attribute_change(attr)] }
+        ActiveSupport::HashWithIndifferentAccess[map]
+      end
+
+      def changed_attributes
+        @changed_attributes ||= ActiveSupport::HashWithIndifferentAccess.new
+      end
+
+      def attribute_changed?(attr)
+        changed.include?(attr.to_s)
+      end
+
+      def changes_applied
+        @previously_changed = changes
+        @changed_attributes = ActiveSupport::HashWithIndifferentAccess.new
+      end
+
+      def clear_changes_information
+        @previously_changed = ActiveSupport::HashWithIndifferentAccess.new
+        @changed_attributes = ActiveSupport::HashWithIndifferentAccess.new
+      end
+
+      def clear_previous_attributes
+        @previously_changed = ActiveSupport::HashWithIndifferentAccess.new
+      end
+
+      private
+
+      def attribute_change(attr)
+        return unless attribute_changed?(attr)
+        [previous_attributes[attr], changed_attributes[attr]]
+      end
+
+      def previous_attributes
+        @previous_attributes ||= ActiveSupport::HashWithIndifferentAccess.new
+      end
+    end
+  end
+end

data/lib/dinamo/model/errors.rb

@@ -0,0 +1,17 @@
+module Dinamo
+  class Model
+    class Errors < ::Hash
+      def add(attribute, message)
+        fetch(attribute) { self[attribute] = [] } << message
+      end
+
+      def count
+        values.inject(0) { |all, value| all + value.length }
+      end
+
+      def empty?
+        count.zero?
+      end
+    end
+  end
+end

data/lib/dinamo/model/persistence.rb

@@ -0,0 +1,144 @@
+module Dinamo
+  class Model
+    module Persistence
+      extend ActiveSupport::Concern
+
+      included do
+        after(:save) { @new_record = !errors.empty? }
+        after(:initialize) { |**opts| self.new_record = true }
+      end
+
+      module ClassMethods
+        def get(**keys)
+          get!(**keys) rescue nil
+        end
+
+        def get!(**keys)
+          item = adapter.get(**keys).item 
+          fail Exceptions::RecordNotFoundError,
+            "Corresponding record (%p) can not be found" % keys unless item
+          new(**symbolize(item))
+        end
+
+        def create(attributes = nil, &block)
+          object = new(**attributes, &block)
+          object.new_record = true
+          object.with_callback :create do
+            object.save
+            object
+          end
+        end
+
+        def create!(attributes = nil, &block)
+          object = new(**attributes, &block)
+          object.new_record = true
+          object.with_callback :create do
+            object.save!
+            object
+          end
+        end
+
+        def symbolize(attrs)
+          attrs.each_with_object({}) do |(key, val), new_attrs|
+            new_attrs[key.to_sym] = val
+          end
+        end
+      end
+
+      def new_record=(bool)
+        @new_record = bool
+      end
+
+      def new_record?
+        @new_record
+      end
+
+      def destroy
+        returned_value =
+          if persisted?
+            self.class.adapter.delete(primary_keys)
+            true
+          else
+            false
+          end
+        (@destroyed = true) && freeze
+        returned_value
+      end
+
+      def destroyed?
+        @destroyed
+      end
+
+      def persisted?
+        !(new_record? || destroyed?)
+      end
+
+      def save(*args)
+        !!save!(*args)
+      rescue Exceptions::ValidationError
+        false
+      end
+
+      def save!(*args)
+        with_callback :save, *args do
+          !!create_or_update(*args)
+        end
+      end
+
+      def create_or_update(*args)
+        new_record? ? create_record(*args) : update_record(*args)
+      end
+
+      def create_record(validate: true)
+        if !validate || valid?
+          self.class.adapter.insert(**self.class.symbolize(attributes))
+          self.new_record = false
+          self
+        else
+          fail Exceptions::ValidationError
+        end
+      end
+
+      def transaction(&block)
+        returned_value = block.call
+        unless returned_value
+          silent_assign(previous_attributes)
+          clear_previous_attributes
+        end
+        returned_value
+      end
+
+      def update(validate: false, **new_attributes)
+        transaction do
+          with_callback :update do
+            self.attributes = new_attributes
+            return save if changed?
+            true
+          end
+        end
+      rescue Exceptions::PrimaryKeyError
+        false
+      end
+
+      def update!(validate: false, **new_attributes)
+        transaction do
+          with_callback :update do
+            self.attributes = new_attributes
+            return save! if changed?
+            true
+          end
+        end
+      end
+
+      def update_record(validate: true)
+        if !validate || valid?
+          symbolized = self.class.symbolize(variable_attributes)
+          updated_object = self.class.adapter.update(primary_keys, **symbolized)
+          self.attributes = updated_object.attributes
+        else
+          fail Exceptions::ValidationError
+        end
+      end
+    end
+  end
+end

data/lib/dinamo/model/validation.rb

@@ -0,0 +1,51 @@
+require 'dinamo/model/errors'
+require 'dinamo/model/validator'
+
+module Dinamo
+  class Model
+    module Validation
+      extend ActiveSupport::Concern
+
+      def valid?
+        validate
+      end
+
+      def errors
+        @errors ||= Dinamo::Model::Errors.new
+      end
+
+      def validate
+        errors.clear
+        validate_unsupported_fields
+        validate_required_attributes
+        validate_by_using_validators
+        errors.empty?
+      end
+
+      private
+
+      def validate_by_using_validators
+        self.class.validators.each do |validator|
+          validator.validate(self)
+        end
+      end
+
+      def validate_unsupported_fields
+        supported_fields = self.class.supported_fields.map(&:name)
+        attributes.each do |(attr, _)|
+          unless supported_fields.include?(attr.to_s)
+            message =  "%p attribute is not supported" % [attr, self.class]
+            errors.add(attr, message)
+          end
+        end
+      end
+
+      def validate_required_attributes
+        self.class.required_fields.map(&:name).each do |attr|
+          message = "%p attribute is required" % attr
+          errors.add(attr, message) unless attributes.has_key?(attr)
+        end
+      end
+    end
+  end
+end

data/lib/dinamo/model/validations/presence.rb

@@ -0,0 +1,18 @@
+class Dinamo::Model
+  module Validation
+    class PresenceValidator < EachValidator
+      def validate_each(record, key, value)
+        #p record
+        #p key
+        #p value
+        record.errors.add(key, :blank) if value.blank?
+      end
+    end
+
+    module ClassMethods
+      def validates_presence_of(*args)
+        validates_with PresenceValidator, adjust_validator_options(*args)
+      end
+    end
+  end
+end

data/lib/dinamo/model/validator.rb

@@ -0,0 +1,78 @@
+require 'active_support/core_ext/array/extract_options'
+require 'active_support/core_ext/object/blank'
+
+class Dinamo::Model
+  module Validation
+    class Validator
+      attr_reader :options
+
+      def initialize(**options, &block)
+        @options = options || {}
+        @block = block
+      end
+
+      def validate(record)
+        raise NotImplementedError
+      end
+    end
+
+    class EachValidator < Validator
+      attr_reader :attributes
+
+      def initialize(attributes: [], **options)
+        @attributes = attributes
+        raise ArgumentError, ":attributes cannot be blank" if @attributes.empty?
+        super
+      end
+
+      def validate(record)
+        attributes.each do |key, val|
+          value = record[key]
+          next if (value.nil? && options[:allow_nil]) ||
+            (value.blank? && options[:allow_blank])
+          validate_each(record, key, value)
+        end
+      end
+
+      def validate_each(record, attribute, value)
+        raise NotImplementedError
+      end
+    end
+
+    module ClassMethods
+      def validates_with(*args, &block)
+        options = args.extract_options!
+        options[:class] = self
+
+        args.each do |validator_class|
+          validator = validator_class.new(options, &block)
+
+          if validator.respond_to?(:attributes) && !validator.attributes.empty?
+            validator.attributes.each do |attribute|
+              _validators[attribute.to_sym] << validator
+            end
+          else
+            _validators[nil] << validator
+          end
+        end
+      end
+
+      def validators
+        _validators.values.flatten.uniq
+      end
+
+      def _validators
+        @_validators ||= Hash.new { |hash, key| hash[key] = [] }
+      end
+
+      def adjust_validator_options(*args)
+        options = args.extract_options!.symbolize_keys
+        args.flatten!
+        options[:attributes] = args
+        options
+      end
+    end
+  end
+
+  require 'dinamo/model/validations/presence'
+end

data/lib/dinamo/model.rb

@@ -0,0 +1,57 @@
+require 'active_support/concern'
+require 'dinamo/adapter'
+require 'dinamo/exceptions'
+require 'dinamo/model/callback'
+require 'dinamo/model/validation'
+require 'dinamo/model/validator'
+require 'dinamo/model/attributes'
+require 'dinamo/model/persistence'
+require 'dinamo/model/dirty'
+
+module Dinamo
+  class Model
+    include Callback
+    include Validation
+    include Attributes
+    include Persistence
+    include Dirty
+
+    extend Dinamo::Adapter::Glue
+
+    class << self
+      def default_casters(&block)
+        @default_casters ||= block
+      end
+
+      def inherited(klass)
+        klass.callbacks.merge!(callbacks)
+        klass.class_eval &default_casters
+      end
+
+      def table_name
+        @table_name ||= self.name.split(/::/).last.underscore.pluralize
+      end
+
+      def table_name=(name)
+        @table_name = name
+      end
+    end
+
+    default_casters do
+      cast(:list)       { |v| Array(v)           }
+      cast(:string)     { |v| v.to_s             }
+      cast(:number)     { |v| v.to_i             }
+      cast(:binary)     { |v| Array(v).pack(?m)  }
+      cast(:boolean)    { |v| !!v                }
+      cast(:number_set) { |v| Array(v).map(&:to_i) }
+      cast(:string_set) { |v| Array(v).map(&:to_s) }
+      cast(:binary_set) { |v| Array(v).map { |t| Array(t.to_s).pack(?m) } }
+    end
+
+    def initialize(**attributes, &block)
+      with_callback :initialize, **attributes do
+        block.call(self) if block_given?
+      end
+    end
+  end
+end

data/lib/dinamo/version.rb

@@ -0,0 +1,3 @@
+module Dinamo
+  VERSION = "0.1.0"
+end

data/lib/dinamo.rb

@@ -0,0 +1,5 @@
+require 'active_support/core_ext/string/inflections'
+require "dinamo/exceptions"
+require "dinamo/adapter"
+require "dinamo/model"
+require "dinamo/version"

metadata

@@ -0,0 +1,168 @@
+--- !ruby/object:Gem::Specification
+name: dinamo
+version: !ruby/object:Gem::Version
+  version: 0.1.0
+platform: ruby
+authors:
+- namusyaka
+autorequire: 
+bindir: exe
+cert_chain: []
+date: 2015-12-14 00:00:00.000000000 Z
+dependencies:
+- !ruby/object:Gem::Dependency
+  name: activesupport
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - ~>
+      - !ruby/object:Gem::Version
+        version: 4.2.4
+  type: :runtime
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - ~>
+      - !ruby/object:Gem::Version
+        version: 4.2.4
+- !ruby/object:Gem::Dependency
+  name: aws-sdk
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - ~>
+      - !ruby/object:Gem::Version
+        version: 2.1.26
+  type: :runtime
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - ~>
+      - !ruby/object:Gem::Version
+        version: 2.1.26
+- !ruby/object:Gem::Dependency
+  name: bundler
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - ~>
+      - !ruby/object:Gem::Version
+        version: '1.10'
+  type: :development
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - ~>
+      - !ruby/object:Gem::Version
+        version: '1.10'
+- !ruby/object:Gem::Dependency
+  name: rake
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - ~>
+      - !ruby/object:Gem::Version
+        version: '10.0'
+  type: :development
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - ~>
+      - !ruby/object:Gem::Version
+        version: '10.0'
+- !ruby/object:Gem::Dependency
+  name: test-unit
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - '>='
+      - !ruby/object:Gem::Version
+        version: '0'
+  type: :development
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - '>='
+      - !ruby/object:Gem::Version
+        version: '0'
+- !ruby/object:Gem::Dependency
+  name: test-unit-rr
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - '>='
+      - !ruby/object:Gem::Version
+        version: '0'
+  type: :development
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - '>='
+      - !ruby/object:Gem::Version
+        version: '0'
+- !ruby/object:Gem::Dependency
+  name: test-unit-power_assert
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - '>='
+      - !ruby/object:Gem::Version
+        version: '0'
+  type: :development
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - '>='
+      - !ruby/object:Gem::Version
+        version: '0'
+description: DynamoDB ORM for Ruby
+email:
+- namusyaka@gmail.com
+executables: []
+extensions: []
+extra_rdoc_files: []
+files:
+- .gitignore
+- .rspec
+- .travis.yml
+- CODE_OF_CONDUCT.md
+- Gemfile
+- LICENSE.txt
+- README.md
+- Rakefile
+- bin/console
+- bin/setup
+- dinamo.gemspec
+- lib/dinamo.rb
+- lib/dinamo/adapter.rb
+- lib/dinamo/exceptions.rb
+- lib/dinamo/model.rb
+- lib/dinamo/model/attributes.rb
+- lib/dinamo/model/callback.rb
+- lib/dinamo/model/caster.rb
+- lib/dinamo/model/dirty.rb
+- lib/dinamo/model/errors.rb
+- lib/dinamo/model/persistence.rb
+- lib/dinamo/model/validation.rb
+- lib/dinamo/model/validations/presence.rb
+- lib/dinamo/model/validator.rb
+- lib/dinamo/version.rb
+homepage: https://github.com/namusyaka/dinamo
+licenses:
+- MIT
+metadata:
+  allowed_push_host: 'TODO: Set to ''http://mygemserver.com'''
+post_install_message: 
+rdoc_options: []
+require_paths:
+- lib
+required_ruby_version: !ruby/object:Gem::Requirement
+  requirements:
+  - - '>='
+    - !ruby/object:Gem::Version
+      version: '0'
+required_rubygems_version: !ruby/object:Gem::Requirement
+  requirements:
+  - - '>='
+    - !ruby/object:Gem::Version
+      version: '0'
+requirements: []
+rubyforge_project: 
+rubygems_version: 2.0.14
+signing_key: 
+specification_version: 4
+summary: DynamoDB ORM for Ruby
+test_files: []