sequel_dm 0.0.2

data/.gitignore

@@ -0,0 +1,5 @@
+vendor/
+tags
+.bundle
+.DS_Store
+pkg

data/.travis.yml

@@ -0,0 +1,3 @@
+rvm:
+- 2.0.0
+script: "bundle exec rspec spec/"

data/Gemfile

@@ -0,0 +1,9 @@
+source 'https://rubygems.org'
+
+# Specify your gem's dependencies in aggregate_builder.gemspec
+gemspec
+
+group :test do
+  gem 'rspec'
+  gem 'debugger'
+end

data/Gemfile.lock

@@ -0,0 +1,51 @@
+PATH
+  remote: .
+  specs:
+    sequel_dm (0.0.2)
+      activesupport
+      sequel (~> 4.6)
+
+GEM
+  remote: https://rubygems.org/
+  specs:
+    activesupport (4.0.2)
+      i18n (~> 0.6, >= 0.6.4)
+      minitest (~> 4.2)
+      multi_json (~> 1.3)
+      thread_safe (~> 0.1)
+      tzinfo (~> 0.3.37)
+    atomic (1.1.14)
+    columnize (0.3.6)
+    debugger (1.6.5)
+      columnize (>= 0.3.1)
+      debugger-linecache (~> 1.2.0)
+      debugger-ruby_core_source (~> 1.3.1)
+    debugger-linecache (1.2.0)
+    debugger-ruby_core_source (1.3.1)
+    diff-lcs (1.2.5)
+    i18n (0.6.9)
+    minitest (4.7.5)
+    multi_json (1.8.4)
+    rake (10.1.1)
+    rspec (2.14.1)
+      rspec-core (~> 2.14.0)
+      rspec-expectations (~> 2.14.0)
+      rspec-mocks (~> 2.14.0)
+    rspec-core (2.14.7)
+    rspec-expectations (2.14.4)
+      diff-lcs (>= 1.1.3, < 2.0)
+    rspec-mocks (2.14.4)
+    sequel (4.6.0)
+    thread_safe (0.1.3)
+      atomic
+    tzinfo (0.3.38)
+
+PLATFORMS
+  ruby
+
+DEPENDENCIES
+  bundler (~> 1.3)
+  debugger
+  rake
+  rspec
+  sequel_dm!

data/LICENSE.txt

@@ -0,0 +1,22 @@
+Copyright (c) 2013 Albert Gazizov
+
+MIT License
+
+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,26 @@
+# SequelDM [![Build Status](https://travis-ci.org/AlbertGazizov/sequel_dm.png)](https://travis-ci.org/AlbertGazizov/sequel_dm) [![Code Climate](https://codeclimate.com/github/AlbertGazizov/sequel_dm.png)](https://codeclimate.com/github/AlbertGazizov/sequel_dm)
+
+
+
+SequelDM is a Sequel based Data Mapper pattern implementation
+
+NOTE: This gem is not production ready, it needs a lot of work!
+
+## Installation
+
+Add this line to your application's Gemfile:
+
+    gem 'sequel_dm', github: 'AlbertGazizov/sequel_dm'
+
+And then execute:
+
+    $ bundle
+
+## Contributing
+
+1. Fork it
+2. Create your feature branch (`git checkout -b my-new-feature`)
+3. Commit your changes (`git commit -am 'Add some feature'`)
+4. Push to the branch (`git push origin my-new-feature`)
+5. Create new Pull Request
+

data/Rakefile

@@ -0,0 +1 @@
+require "bundler/gem_tasks"

data/lib/sequel_dm/args_validator.rb

@@ -0,0 +1,76 @@
+# Helper class for arguments validation
+module SequelDM::ArgsValidator
+  class << self
+
+    # Checks that specifid +obj+ is a symbol
+    # @param obj some object
+    # @param obj_name object's name, used to clarify error causer in exception
+    def is_symbol!(obj, obj_name)
+      unless obj.is_a?(Symbol)
+        raise ArgumentError, "#{obj_name} should be a Symbol"
+      end
+    end
+
+    # Checks that specifid +obj+ is an Array
+    # @param obj some object
+    # @param obj_name object's name, used to clarify error causer in exception
+    def is_array!(obj, obj_name)
+      unless obj.is_a?(Array)
+        raise ArgumentError, "#{obj_name} should be an Array"
+      end
+    end
+
+    # Checks that specifid +obj+ is a Hash
+    # @param obj some object
+    # @param obj_name object's name, used to clarify error causer in exception
+    def is_hash!(obj, obj_name)
+      unless obj.is_a?(Hash)
+        raise ArgumentError, "#{obj_name} should be a Hash"
+      end
+    end
+
+    # Checks that specifid +obj+ is a Class
+    # @param obj some object
+    # @param obj_name object's name, used to clarify error causer in exception
+    def is_class!(obj, obj_name)
+      unless obj.is_a?(Class)
+        raise ArgumentError, "#{obj_name} should be a Class"
+      end
+    end
+
+    # Checks that specifid +obj+ is a Proc
+    # @param obj some object
+    # @param obj_name object's name, used to clarify error causer in exception
+    def is_proc!(obj, obj_name)
+      unless obj.is_a?(Proc)
+        raise ArgumentError, "#{obj_name} should be a Proc"
+      end
+    end
+
+    # Checks that specifid +obj+ is a symbol or Class
+    # @param obj some object
+    # @param obj_name object's name, used to clarify error causer in exception
+    def is_symbol_or_class!(obj, obj_name)
+      if !obj.is_a?(Symbol) && !obj.is_a?(Class)
+        raise ArgumentError, "#{obj_name} should be a Symbol or Class"
+      end
+    end
+
+    # Checks that specifid +hash+ has a specified +key+
+    # @param hash some hash
+    # @param key hash's key
+    def has_key!(hash, key)
+      unless hash.has_key?(key)
+        raise ArgumentError, "#{hash} should has #{key} key"
+      end
+    end
+
+    # Checks that specified +block+ is given
+    # @param block some block
+    def block_given!(block)
+      unless block
+        raise ArgumentError, "Block should be given"
+      end
+    end
+  end
+end

data/lib/sequel_dm/dao.rb

@@ -0,0 +1,353 @@
+require 'sequel_dm/extensions/select_fields'
+
+SequelDM::DAO = Class.new(Sequel::Model)
+module SequelDM
+  def self.DAO(source)
+    Class.new(SequelDM::DAO).set_dataset(source)
+  end
+
+  class DAO
+    class_attribute :mapper
+
+    dataset_module do
+      include SequelDM::Extensions::SelectFields
+    end
+
+    class << self
+      def def_one_to_many(opts)
+        one_to_one = opts[:type] == :one_to_one
+        name = opts[:name]
+        model = self
+        key = (opts[:key] ||= opts.default_key)
+        km = opts[:key_method] ||= opts[:key]
+        cks = opts[:keys] = Array(key)
+        opts[:key_methods] = Array(opts[:key_method])
+        primary_key = (opts[:primary_key] ||= self.primary_key)
+        opts[:eager_loader_key] = primary_key unless opts.has_key?(:eager_loader_key)
+        cpks = opts[:primary_keys] = Array(primary_key)
+        pkc = opts[:primary_key_column] ||= primary_key
+        pkcs = opts[:primary_key_columns] ||= Array(pkc)
+        raise(Error, "mismatched number of keys: #{cks.inspect} vs #{cpks.inspect}") unless cks.length == cpks.length
+        uses_cks = opts[:uses_composite_keys] = cks.length > 1
+        slice_range = opts.slice_range
+        opts[:dataset] ||= proc do
+          opts.associated_dataset.where(opts.predicate_keys.zip(cpks.map{|k| send(k)}))
+        end
+        opts[:eager_loader] = proc do |eo|
+          h = eo[:id_map]
+          rows = eo[:rows]
+          reciprocal = opts.reciprocal
+          klass = opts.associated_class
+          filter_keys = opts.predicate_key
+          ds = model.eager_loading_dataset(opts, klass.where(filter_keys=>h.keys), nil, eo[:associations], eo)
+          assign_singular = true if one_to_one
+          case opts.eager_limit_strategy
+          when :distinct_on
+            ds = ds.distinct(*filter_keys).order_prepend(*filter_keys)
+          when :window_function
+            delete_rn = true
+            rn = ds.row_number_column
+            ds = apply_window_function_eager_limit_strategy(ds, opts)
+          when :ruby
+            assign_singular = false if one_to_one && slice_range
+          end
+          ds.all do |assoc_record|
+            assoc_record.values.delete(rn) if delete_rn
+            hash_key = uses_cks ? km.map{|k| assoc_record.send(k)} : assoc_record.send(km)
+            next unless objects = h[hash_key]
+            if assign_singular
+              objects.each do |object|
+                unless object.send(name)
+                  # TODO: add persistance_associations update here
+                  object.send("#{name}=", assoc_record)
+                  assoc_record.send("#{reciprocal}=", object) if reciprocal
+                end
+              end
+            else
+              objects.each do |object|
+                add_to_associations_state(object, name, assoc_record)
+                object.send(name).push(assoc_record)
+                assoc_record.send("#{reciprocal}=", object) if reciprocal
+              end
+            end
+          end
+          if opts.eager_limit_strategy == :ruby
+            if one_to_one
+              if slice_range
+                rows.each{|o| o.associations[name] = o.associations[name][slice_range.begin]}
+              end
+            else
+              rows.each{|o| o.associations[name] = o.associations[name][slice_range] || []}
+            end
+          end
+        end
+        super
+      end
+
+      def set_dataset_row_proc(ds)
+        ds.row_proc = Proc.new do |raw|
+          raise StandardError, "Mapper should be specified" if !self.mapper
+          entity = self.mapper.to_entity(raw)
+          save_state(entity, raw)
+          entity
+        end
+      end
+
+      def set_mapper(mapper)
+        SequelDM::ArgsValidator.is_class!(mapper, :mapper)
+        self.mapper = mapper
+      end
+
+      # Database methods
+
+      def insert(entity, root = nil)
+        raw = mapper.to_hash(entity, root)
+        key = dataset.insert(raw)
+        set_entity_primary_key(entity, raw, key)
+        save_state(entity, raw)
+        insert_associations(entity)
+        entity
+      end
+
+      def insert_all(entities, root = nil)
+        entities.each do |entity|
+          insert(entity, root)
+        end
+      end
+
+      def update(entity, root = nil)
+        raw = mapper.to_hash(entity, root)
+        raw = select_only_changed_values(entity, raw)
+
+        unless raw.empty?
+          update_state(entity, raw)
+
+          key_condition = prepare_key_condition_from_entity(entity)
+          dataset.where(key_condition).update(raw)
+        end
+
+        insert_or_update_associations(entity)
+        entity
+      end
+
+      def update_all(entities, root = nil)
+        entities.each do |entity|
+          update(entity, root)
+        end
+      end
+
+      def save(entity, root = nil)
+        if has_persistance_state?(entity)
+          update(entity, root)
+        else
+          insert(entity, root)
+        end
+      end
+
+      def save_all(entities, root = nil)
+        entities.each do |entity|
+          save(entity, root)
+        end
+      end
+
+      def delete(entity)
+        key_condition = prepare_key_condition_from_entity(entity)
+        dataset.where(key_condition).delete
+        delete_associations(entity)
+      end
+
+      # TODO: refactor
+      def delete_all(entities)
+        entity_ids = entities.map(&:id)
+        dataset.where(id: entity_ids).delete
+        unless association_reflections.empty?
+          association_reflections.each do |association, options|
+            association_dao = options[:class]
+            conditions = (options[:conditions] || {}).merge(options[:key] => entity_ids)
+            association_dao.where(conditions).delete
+          end
+        end
+      end
+
+      private
+
+      def select_only_changed_values(entity, hash)
+        changes = {}
+        return hash unless entity.instance_variable_defined?(:@persistance_state)
+
+        persistance_state = entity.instance_variable_get(:@persistance_state)
+        hash.each do |column, value|
+          previous_column_value = persistance_state[column]
+          if persistance_state.has_key?(column) && column_value_changed?(previous_column_value, value)
+            changes[column] = value
+          end
+        end
+        changes
+      end
+
+      def column_value_changed?(previous_value, new_value)
+        previous_value != new_value
+      end
+
+      def save_state(entity, raw)
+        if !entity.is_a?(Integer) && !entity.is_a?(Symbol)
+          entity.instance_variable_set(:@persistance_state, raw)
+        end
+      end
+
+      def update_state(entity, raw)
+        persistance_state = entity.instance_variable_get(:@persistance_state)
+        if persistance_state
+          persistance_state.merge!(raw)
+        end
+      end
+
+      def has_persistance_state?(entity)
+        !!entity.instance_variable_get(:@persistance_state)
+      end
+
+      def set_associations_state(entity, association_name, associations)
+        persistance_associations = entity.instance_variable_get(:@persistance_associations) || {}
+        persistance_associations[association_name] ||= []
+        persistance_associations[association_name] |= associations
+        entity.instance_variable_set(:@persistance_associations, persistance_associations)
+      end
+
+      def add_to_associations_state(entity, association_name, association)
+        persistance_associations = entity.instance_variable_get(:@persistance_associations) || {}
+        persistance_associations[association_name] ||= []
+        persistance_associations[association_name] << association
+        entity.instance_variable_set(:@persistance_associations, persistance_associations)
+      end
+
+      def prepare_key_condition_from_entity(entity)
+        key_condition = {}
+        if primary_key.is_a?(Array)
+          primary_key.each do |key_part|
+            key_part_value = entity.send(key_part)
+            raise ArgumentError, "entity's primary key can't be nil, got nil for #{key_part}" unless key_part_value
+            key_condition[key_part] = key_part_value
+          end
+        elsif primary_key.is_a?(Symbol)
+          key_value = entity.send(primary_key)
+          raise ArgumentError, "entity's primary key can't be nil, got nil for #{primary_key}" unless key_value
+          key_condition[primary_key] = key_value
+        else
+          raise StandardError, "primary key should be array or symbol"
+        end
+        key_condition
+      end
+
+      def set_entity_primary_key(entity, raw, key)
+        if key && !primary_key.is_a?(Array)
+          entity.instance_variable_set("@#{primary_key}", key)
+          raw[primary_key] = key
+        end
+      end
+
+      def insert_associations(entity)
+        unless association_reflections.empty?
+          association_reflections.each do |association_name, options|
+            association_dao = options[:class]
+            if entity.respond_to?(association_name)
+              children = association_dao.insert_all(entity.send(association_name), entity)
+              set_associations_state(entity, association_name, children)
+            end
+          end
+        end
+      end
+
+      def insert_or_update_associations(entity)
+        unless association_reflections.empty?
+          association_reflections.each do |association_name, options|
+            association_dao = options[:class]
+            raise ArgumentError, "class option should be specified for #{association_name}" unless association_dao
+
+            delete_dissapeared_children(entity, association_name, options)
+
+            children = entity.send(association_name)
+            association_dao.save_all(children, entity)
+            set_associations_state(entity, association_name, children)
+          end
+        end
+      end
+
+      def delete_associations(entity)
+        unless association_reflections.empty?
+          association_reflections.each do |association, options|
+            if options[:delete]
+              association_dao = options[:class]
+              conditions = (options[:conditions] || {}).merge(options[:key] => entity.send(primary_key))
+              association_dao.where(conditions).delete
+            end
+          end
+        end
+      end
+
+      def delete_dissapeared_children(entity, association, options)
+        association_dao = options[:class]
+        unless options[:key]
+          raise ArgumentError, "key option should be specified for #{association}"
+        end
+        if options[:key].is_a?(Symbol)
+          conditions = (options[:conditions] || {}).merge(options[:key] => entity.send(primary_key))
+        elsif options[:key].is_a?(Array)
+          conditions = options[:key].inject(options[:conditions] || {}) { |result, key| result[key] = entity.send(key); result }
+        else
+          raise ArgumentError, "key should be symbol or array"
+        end
+
+        # get ids of removed children
+        association_objects = get_association_objects(entity, association)
+        dissapeared_objects = association_objects - entity.send(association)
+
+        scope_key = options[:scope_key] || association_dao.primary_key
+        if scope_key.is_a?(Symbol)
+          child_keys = { scope_key => [] }
+          dissapeared_objects.each do |child_object|
+            key = child_object.send(scope_key)
+            child_keys[scope_key] << key
+          end
+
+          if !child_keys[scope_key].empty?
+            association_dao.where(conditions).where(child_keys).delete
+          end
+        elsif scope_key.is_a?(Array)
+          child_keys = []
+          dissapeared_objects.each do |child_object|
+            child_keys << scope_key.inject({}) do |condition, key|
+              condition[key] = child_object.send(key)
+              condition
+            end
+          end
+          if !child_keys.empty?
+            child_keys.each { |keys| keys.merge!(conditions) }
+            association_dao.where(Sequel.|(*child_keys)).delete
+          end
+        elsif scope_key.is_a?(Proc)
+          child_keys = []
+          dissapeared_objects.each do |child_object|
+            child_keys << scope_key.call(child_object)
+          end
+          if !child_keys.empty?
+            child_keys.each { |keys| keys.merge!(conditions) }
+            association_dao.where(Sequel.|(*child_keys)).delete
+          end
+        else
+          raise StandardError, "scope key should be array or symbol"
+        end
+      end
+
+      def get_association_objects(entity, association)
+        persistance_associations = entity.instance_variable_get(:@persistance_associations)
+        if persistance_associations
+          persistance_associations[association] || []
+        else
+          []
+        end
+      end
+
+    end
+  end
+
+end

data/lib/sequel_dm/extensions/select_fields.rb

@@ -0,0 +1,47 @@
+module SequelDM
+  module Extensions
+    module SelectFields
+      def select_fields(fields)
+        if fields.empty?
+          if !model.association_reflections.empty?
+            eager(model.association_reflections.keys)
+          else
+            self
+          end
+        else
+          eager_associations = {}
+          fields.each do |association, columns|
+            next if association == :fields
+            if columns && !columns.is_a?(Array)
+              columns = get_columns_from_mapper(association)
+            end
+            if columns
+              table_name = model.association_reflections[association][:class].table_name
+              columns = columns.map { |column| :"#{table_name}__#{column}___#{column}" }
+              eager_associations[association] = proc{|ds| ds.select(*columns) }
+            end
+          end
+
+          if fields[:fields].is_a?(Array)
+            columns = fields[:fields]
+          else
+            columns = model.mapper.mappings.keys
+          end
+          columns = columns.map { |column| :"#{model.table_name}__#{column}___#{column}" }
+          eager(eager_associations).select(*columns)
+        end
+      end
+
+      private
+
+      def get_columns_from_mapper(association)
+        reflection = model.association_reflections[association]
+        raise ArgumentError, "association with name #{association} is not defined in dao" unless reflection
+        association_dao = reflection[:class]
+        raise ArgumentError, "association #{association} should have class option" unless association_dao
+        association_dao.mapper.mappings.keys
+      end
+
+    end
+  end
+end

data/lib/sequel_dm/mapper.rb

@@ -0,0 +1,54 @@
+require 'sequel_dm/args_validator'
+require 'sequel_dm/mappings_dsl'
+
+module SequelDM::Mapper
+  extend ActiveSupport::Concern
+
+  included do
+    class_attribute :entity_class, :mappings
+  end
+
+  module ClassMethods
+    def map(entity_class, &mappings_proc)
+      SequelDM::ArgsValidator.is_class!(entity_class, :entity_class)
+      self.entity_class = entity_class
+      self.mappings     = SequelDM::MappingsDSL.new(&mappings_proc).mappings
+    end
+
+    def to_entity(hash)
+      attributes = {}
+      entity = self.entity_class.new
+      hash.each do |key, value|
+        if mapping = self.mappings[key]
+          entity.instance_variable_set(:"@#{mapping.entity_field}", to_attribute(hash, value, mapping)) if mapping.set_field?
+        end
+      end
+      entity
+    end
+
+    def to_hash(entity, *args)
+      hash = {}
+
+      entity_mappings = self.mappings
+      entity_mappings.each do |column, mapping|
+        value = to_column(entity, mapping, *args)
+        hash[column] = value if mapping.set_column?
+      end
+
+      hash
+    end
+
+    private
+
+    def to_attribute(hash, value, mapping)
+      mapping.load? ? mapping.load(hash) : value
+    end
+
+    def to_column(entity, mapping, *args)
+      mapping.dump? ? mapping.dump(entity, *args) : entity.send(mapping.entity_field)
+    end
+
+  end
+
+end
+

data/lib/sequel_dm/mappings_dsl.rb

@@ -0,0 +1,69 @@
+class SequelDM::MappingsDSL
+  attr_reader :mappings
+  def initialize(&dsl_block)
+    @mappings = {}
+    instance_exec(&dsl_block)
+  end
+
+  def column(column_name, options = {})
+    SequelDM::ArgsValidator.is_symbol!(column_name, :column_name)
+    SequelDM::ArgsValidator.is_hash!(options, :column_options)
+    SequelDM::ArgsValidator.is_symbol!(options[:to], :to) if options[:to]
+    SequelDM::ArgsValidator.is_proc!(options[:load], :load) if options[:load]
+    SequelDM::ArgsValidator.is_proc!(options[:dump], :dump) if options[:dump]
+
+    set_field  = options[:set_field] == false ? false : true
+    set_column = options[:set_column] == false ? false : true
+    mappings[column_name] = Mapping.new(
+      column_name,
+      options[:to] || column_name,
+      options[:load],
+      options[:dump],
+      set_field,
+      set_column,
+    )
+  end
+
+  def columns(*column_names)
+    SequelDM::ArgsValidator.is_array!(column_names, :column_names)
+    column_names.each { |column_name| column(column_name) }
+  end
+
+  class Mapping
+    attr_accessor :column_name, :entity_field, :load, :dump
+
+    def initialize(column_name, entity_field, load = nil, dump = nil, set_field = true, set_column = true)
+      @column_name   = column_name
+      @entity_field  = entity_field
+      @load          = load
+      @dump          = dump
+      @set_field     = set_field
+      @set_column    = set_column
+    end
+
+    def set_field?
+      @set_field
+    end
+
+    def set_column?
+      @set_column
+    end
+
+    def load?
+      !!@load
+    end
+
+    def dump?
+      !!@dump
+    end
+
+    def load(value)
+      @load.call(value)
+    end
+
+    def dump(value, *args)
+      @dump.call(value, *args)
+    end
+  end
+end
+

data/lib/sequel_dm/version.rb

@@ -0,0 +1,3 @@
+module SequelDM
+  VERSION = "0.0.2"
+end

data/lib/sequel_dm.rb

@@ -0,0 +1,6 @@
+require 'active_support/concern'
+require 'active_support/core_ext/class/attribute'
+require 'sequel'
+require 'sequel_dm/version'
+require 'sequel_dm/mapper'
+require 'sequel_dm/dao'

data/sequel_dm.gemspec

@@ -0,0 +1,25 @@
+# coding: utf-8
+lib = File.expand_path('../lib', __FILE__)
+$LOAD_PATH.unshift(lib) unless $LOAD_PATH.include?(lib)
+require 'sequel_dm/version'
+
+Gem::Specification.new do |spec|
+  spec.name          = "sequel_dm"
+  spec.version       = SequelDM::VERSION
+  spec.authors       = ["Albert Gazizov", "Ruslan Gatiyatov"]
+  spec.email         = ["deeper4k@gmail.com", "ruslan.gatiyatov@gmail.com"]
+  spec.description   = %q{Sequel based Data Mapper implementation}
+  spec.summary       = %q{Sequel based Data Mapper implementation}
+  spec.homepage      = "http://github.com/deeper4k/sequel_dm"
+  spec.license       = "MIT"
+
+  spec.files         = `git ls-files`.split($/)
+  spec.executables   = spec.files.grep(%r{^bin/}) { |f| File.basename(f) }
+  spec.test_files    = spec.files.grep(%r{^(spec)/})
+  spec.require_paths = ["lib"]
+
+  spec.add_dependency "activesupport"
+  spec.add_development_dependency "bundler", "~> 1.3"
+  spec.add_development_dependency "rake"
+  spec.add_dependency "sequel", "~> 4.6"
+end

data/spec/sequel_dm/dao_spec.rb

@@ -0,0 +1,21 @@
+require 'spec_helper'
+require 'sequel_dm'
+
+describe "SequelDM::DAO" do
+  class Entity
+  end
+
+  class Mapper
+    def self.to_entity(hash)
+      Entity.new
+    end
+  end
+
+  describe ".dataset.row_proc" do
+    it "should return entity" do
+      dao = Class.new(SequelDM::DAO(:items))
+      dao.mapper = Mapper
+      dao.dataset.row_proc.call({}).should be_instance_of(Entity)
+    end
+  end
+end

data/spec/sequel_dm/mapper_spec.rb

@@ -0,0 +1,63 @@
+require 'spec_helper'
+
+describe SequelDM::Mapper do
+  module MapperTest
+
+    class Event
+      attr_accessor :name, :description, :when, :settings
+
+      def initialize(attrs = {})
+        @name        = attrs[:name]
+        @description = attrs[:description]
+        @when        = attrs[:when]
+        @settings    = attrs[:settings ]
+      end
+    end
+
+    class EventMapper
+      include SequelDM::Mapper
+
+      map MapperTest::Event do
+        column :subject, to: :name
+        column :description
+        column :settings, load: ->(hash) { YAML.load(hash[:settings]) }, dump: ->(event) { YAML.dump(event.settings) }
+      end
+    end
+  end
+
+  describe ".to_entity" do
+    it "should build Event instance from hash using mappings" do
+      tomorrow = Time.now + 24*60*60
+      event = MapperTest::EventMapper.to_entity({
+        subject:     "Meet parents",
+        description: "I need to meet them",
+        when:        tomorrow,
+        settings:    "---\n:important: true\n",
+        occurrences_number: 2,
+      })
+      event.should be_instance_of(MapperTest::Event)
+
+      event.name.should        == "Meet parents"
+      event.description.should == "I need to meet them"
+      event.when.should        == nil # unlisted column
+      event.settings.should    == { important: true }
+    end
+  end
+
+  describe ".to_hash" do
+    it "should convert entity to hash" do
+      event = MapperTest::Event.new({
+        name: "Event",
+        description: "Description",
+        when: Time.now,
+        settings: { important: true },
+      })
+      MapperTest::EventMapper.to_hash(event).should == {
+        description: "Description",
+        settings: "---\n:important: true\n",
+        subject: "Event"
+      }
+    end
+  end
+end
+

data/spec/spec_helper.rb

@@ -0,0 +1,15 @@
+require 'rubygems'
+require 'bundler/setup'
+require 'debugger'
+require 'sequel'
+require 'sequel_dm'
+
+RSpec.configure do |config|
+  config.color_enabled = true
+
+  db = Sequel.mock(:fetch=>{:id => 1, :x => 1}, :numrows=>1, :autoid=>proc{|sql| 10})
+  def db.schema(*) [[:id, {:primary_key=>true}]] end
+  def db.reset() sqls end
+  def db.supports_schema_parsing?() true end
+  Sequel::Model.db = DB = db
+end

metadata

@@ -0,0 +1,139 @@
+--- !ruby/object:Gem::Specification
+name: sequel_dm
+version: !ruby/object:Gem::Version
+  prerelease: 
+  version: 0.0.2
+platform: ruby
+authors:
+- Albert Gazizov
+- Ruslan Gatiyatov
+autorequire: 
+bindir: bin
+cert_chain: []
+date: 2014-04-08 00:00:00.000000000 Z
+dependencies:
+- !ruby/object:Gem::Dependency
+  prerelease: false
+  name: activesupport
+  type: :runtime
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - ! '>='
+      - !ruby/object:Gem::Version
+        version: '0'
+    none: false
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - ! '>='
+      - !ruby/object:Gem::Version
+        version: '0'
+    none: false
+- !ruby/object:Gem::Dependency
+  prerelease: false
+  name: bundler
+  type: :development
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - ~>
+      - !ruby/object:Gem::Version
+        version: '1.3'
+    none: false
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - ~>
+      - !ruby/object:Gem::Version
+        version: '1.3'
+    none: false
+- !ruby/object:Gem::Dependency
+  prerelease: false
+  name: rake
+  type: :development
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - ! '>='
+      - !ruby/object:Gem::Version
+        version: '0'
+    none: false
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - ! '>='
+      - !ruby/object:Gem::Version
+        version: '0'
+    none: false
+- !ruby/object:Gem::Dependency
+  prerelease: false
+  name: sequel
+  type: :runtime
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - ~>
+      - !ruby/object:Gem::Version
+        version: '4.6'
+    none: false
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - ~>
+      - !ruby/object:Gem::Version
+        version: '4.6'
+    none: false
+description: Sequel based Data Mapper implementation
+email:
+- deeper4k@gmail.com
+- ruslan.gatiyatov@gmail.com
+executables: []
+extensions: []
+extra_rdoc_files: []
+files:
+- .gitignore
+- .travis.yml
+- Gemfile
+- Gemfile.lock
+- LICENSE.txt
+- README.md
+- Rakefile
+- lib/sequel_dm.rb
+- lib/sequel_dm/args_validator.rb
+- lib/sequel_dm/dao.rb
+- lib/sequel_dm/extensions/select_fields.rb
+- lib/sequel_dm/mapper.rb
+- lib/sequel_dm/mappings_dsl.rb
+- lib/sequel_dm/version.rb
+- sequel_dm.gemspec
+- spec/sequel_dm/dao_spec.rb
+- spec/sequel_dm/mapper_spec.rb
+- spec/spec_helper.rb
+homepage: http://github.com/deeper4k/sequel_dm
+licenses:
+- MIT
+post_install_message: 
+rdoc_options: []
+require_paths:
+- lib
+required_ruby_version: !ruby/object:Gem::Requirement
+  requirements:
+  - - ! '>='
+    - !ruby/object:Gem::Version
+      segments:
+      - 0
+      hash: -3775447022657045354
+      version: '0'
+  none: false
+required_rubygems_version: !ruby/object:Gem::Requirement
+  requirements:
+  - - ! '>='
+    - !ruby/object:Gem::Version
+      segments:
+      - 0
+      hash: -3775447022657045354
+      version: '0'
+  none: false
+requirements: []
+rubyforge_project: 
+rubygems_version: 1.8.23
+signing_key: 
+specification_version: 3
+summary: Sequel based Data Mapper implementation
+test_files:
+- spec/sequel_dm/dao_spec.rb
+- spec/sequel_dm/mapper_spec.rb
+- spec/spec_helper.rb