rmodel 0.4.0.dev → 1.0.0

data/lib/rmodel/base/repository_ext/timestampable.rb

@@ -1,19 +0,0 @@
-module Rmodel::Base
-  module RepositoryExt
-    module Timestampable
-      def insert(object)
-        if object.respond_to?(:created_at) && object.respond_to?(:created_at=)
-          object.created_at ||= Time.now
-        end
-        super
-      end
-
-      def update(object)
-        if object.respond_to?(:updated_at) && object.respond_to?(:updated_at=)
-          object.updated_at = Time.now
-        end
-        super
-      end
-    end
-  end
-end

data/lib/rmodel/mongo/repository.rb

@@ -1,62 +0,0 @@
-require 'mongo'
-require 'rmodel/base/repository'
-require 'active_support/inflector'
-require 'rmodel/mongo/repository_ext/queryable'
-
-module Rmodel::Mongo
-  class Repository < Rmodel::Base::Repository
-    include RepositoryExt::Queryable
-
-    def initialize(client = nil, collection = nil, factory = nil)
-      @client = client || Rmodel.setup.establish_mongo_client(self.class.client_name || :default) or
-                raise ArgumentError.new('Client driver is not setup')
-
-      @collection = collection || self.class.setting_collection ||
-                    self.class.collection_by_convention or
-                    raise ArgumentError.new('Collection can not be guessed')
-
-      @factory = factory || self.class.setting_factory or
-                 raise ArgumentError.new('Factory can not be guessed')
-    end
-
-    def find(id)
-      result = @client[@collection].find(_id: id).first
-      result && @factory.fromHash(result)
-    end
-
-    def insert(object)
-      object.id ||= BSON::ObjectId.new
-      @client[@collection].insert_one(@factory.toHash(object, true))
-    end
-
-    def update(object)
-      @client[@collection].find(_id: object.id).update_one(@factory.toHash(object, false))
-    end
-
-    def remove(object)
-      @client[@collection].find(_id: object.id).delete_one
-    end
-
-    class << self
-      attr_reader :client_name, :setting_collection, :setting_factory
-
-      def client(name)
-        @client_name = name
-      end
-
-      def collection(name)
-        @setting_collection = name
-      end
-
-      def collection_by_convention
-        if name =~ /(.*)Repository$/
-          ActiveSupport::Inflector.tableize($1).to_sym
-        end
-      end
-
-      def simple_factory(klass, *attributes, &block)
-        @setting_factory = SimpleFactory.new(klass, *attributes, &block)
-      end
-    end
-  end
-end

data/lib/rmodel/mongo/repository_ext/query.rb

@@ -1,34 +0,0 @@
-require 'origin'
-
-module Rmodel::Mongo
-  module RepositoryExt
-    class Query
-      include Enumerable
-
-      class Queryable
-        include Origin::Queryable
-      end
-
-      def initialize(repo, queryable = nil)
-        @repo = repo
-        @queryable = queryable || Queryable.new
-      end
-
-      def each(&block)
-        @repo.find_by_query(@queryable.selector, @queryable.options).each(&block)
-        self
-      end
-
-      def remove
-        @repo.execute_query(@queryable.selector, @queryable.options).delete_many
-      end
-
-      def self.define_scope(name, &block)
-        define_method name do |*args|
-          new_queryable = @queryable.instance_exec(*args, &block)
-          self.class.new(@repo, new_queryable)
-        end
-      end
-    end
-  end
-end

data/lib/rmodel/mongo/repository_ext/queryable.rb

@@ -1,34 +0,0 @@
-require 'rmodel/mongo/repository_ext/query'
-
-module Rmodel::Mongo
-  module RepositoryExt
-    module Queryable
-      def self.included(base)
-        base.extend ClassMethods
-      end
-
-      def query
-        (self.class.query_klass ||= Class.new(Query)).new(self)
-      end
-
-      def find_by_query(selector, options)
-        execute_query(selector, options).map do |hash|
-          @factory.fromHash(hash)
-        end
-      end
-
-      def execute_query(selector, options)
-        @client[@collection].find(selector, options)
-      end
-
-      module ClassMethods
-        attr_accessor :query_klass
-
-        def scope(name, &block)
-          self.query_klass ||= Class.new(Query)
-          self.query_klass.define_scope(name, &block)
-        end
-      end
-    end
-  end
-end

data/lib/rmodel/mongo/setup.rb

@@ -1,17 +0,0 @@
-module Rmodel::Mongo
-  module Setup
-    def establish_mongo_client(name)
-      config = @clients_config[name]
-      if config
-        options = config.dup
-        options.delete :hosts
-
-        establish_client(name) { Mongo::Client.new(config[:hosts], options) }
-      end
-    end
-  end
-end
-
-class Rmodel::Setup
-  include Rmodel::Mongo::Setup
-end

data/lib/rmodel/mongo/simple_factory.rb

@@ -1,78 +0,0 @@
-module Rmodel::Mongo
-  class SimpleFactory
-    def initialize(klass, *attributes, &block)
-      @klass = klass
-      @attributes = attributes
-      @embeds_many = {}
-      @embeds_one = {}
-      instance_eval(&block) if block
-    end
-
-    def fromHash(hash)
-      object = @klass.new
-      object.id = hash['_id']
-      @attributes.each do |attribute|
-        object.public_send "#{attribute}=", hash[attribute.to_s]
-      end
-      @embeds_many.each do |attribute, factory|
-        if hash[attribute.to_s]
-          object.public_send "#{attribute}=", []
-          hash[attribute.to_s].each do |sub_hash|
-            object.public_send(attribute) << factory.fromHash(sub_hash)
-          end
-        end
-      end
-      @embeds_one.each do |attribute, factory|
-        sub_hash = hash[attribute.to_s]
-        if sub_hash
-          object.public_send "#{attribute}=", factory.fromHash(sub_hash)
-        end
-      end
-      object
-    end
-
-    def toHash(object, id_included)
-      hash = {}
-      @attributes.each do |attribute|
-        hash[attribute.to_s] = object.public_send(attribute)
-      end
-      if id_included
-        hash['_id'] = object.id
-      end
-      @embeds_many.each do |attribute, factory|
-        hash[attribute.to_s] = []
-        sub_objects = object.public_send(attribute)
-        if sub_objects
-          sub_objects.each do |sub_object|
-            sub_object.id ||= BSON::ObjectId.new
-            hash[attribute.to_s] << factory.toHash(sub_object, true)
-          end
-        end
-      end
-      @embeds_one.each do |attribute, factory|
-        sub_object = object.public_send(attribute)
-        if sub_object
-          sub_object.id ||= BSON::ObjectId.new
-          hash[attribute.to_s] = factory.toHash(sub_object, true)
-        end
-      end
-      hash
-    end
-
-    private
-
-    def embeds_many(attribute, factory, &block)
-      factory.instance_eval(&block) if block
-      @embeds_many[attribute.to_sym] = factory
-    end
-
-    def embeds_one(attribute, factory, &block)
-      factory.instance_eval(&block) if block
-      @embeds_one[attribute.to_sym] = factory
-    end
-
-    def simple_factory(klass, *attributes, &block)
-      self.class.new(klass, *attributes, &block)
-    end
-  end
-end

data/lib/rmodel/sequel/repository.rb

@@ -1,61 +0,0 @@
-require 'sequel'
-require 'rmodel/base/repository'
-require 'rmodel/sequel/repository_ext/queryable'
-
-module Rmodel::Sequel
-  class Repository < Rmodel::Base::Repository
-    include RepositoryExt::Queryable
-
-    def initialize(client = nil, table = nil, factory = nil)
-      @client = client || Rmodel.setup.establish_sequel_client(self.class.client_name || :default) or
-                raise ArgumentError.new('Client driver is not setup')
-
-      @table = table || self.class.setting_table ||
-               self.class.table_by_convention or
-               raise ArgumentError.new('Table can not be guessed')
-
-      @factory = factory || self.class.setting_factory or
-                 raise ArgumentError.new('Factory can not be guessed')
-    end
-
-    def find(id)
-      result = @client[@table].where(id: id).first
-      result && @factory.fromHash(result)
-    end
-
-    def insert(object)
-      id = @client[@table].insert(@factory.toHash(object, true))
-      object.id ||= id
-    end
-
-    def update(object)
-      @client[@table].where(id: object.id).update(@factory.toHash(object, false))
-    end
-
-    def remove(object)
-      @client[@table].where(id: object.id).delete
-    end
-
-    class << self
-      attr_reader :client_name, :setting_table, :setting_factory
-
-      def client(name)
-        @client_name = name
-      end
-
-      def table(name)
-        @setting_table = name
-      end
-
-      def table_by_convention
-        if name =~ /(.*)Repository$/
-          ActiveSupport::Inflector.tableize($1).to_sym
-        end
-      end
-
-      def simple_factory(klass, *attributes)
-        @setting_factory = SimpleFactory.new(klass, *attributes)
-      end
-    end
-  end
-end

data/lib/rmodel/sequel/repository_ext/query.rb

@@ -1,34 +0,0 @@
-require 'origin'
-
-module Rmodel::Sequel
-  module RepositoryExt
-    class Query
-      include Enumerable
-
-      def initialize(repo, dataset)
-        @repo = repo
-        @dataset = dataset
-      end
-
-      def each(&block)
-        @repo.find_by_query(@dataset).each(&block)
-        self
-      end
-
-      def remove
-        @dataset.delete
-      end
-
-      def to_sql
-        @dataset.sql
-      end
-
-      def self.define_scope(name, &block)
-        define_method name do |*args|
-          new_dataset = @dataset.instance_exec(*args, &block)
-          self.class.new(@repo, new_dataset)
-        end
-      end
-    end
-  end
-end

data/lib/rmodel/sequel/repository_ext/queryable.rb

@@ -1,30 +0,0 @@
-require 'rmodel/sequel/repository_ext/query'
-
-module Rmodel::Sequel
-  module RepositoryExt
-    module Queryable
-      def self.included(base)
-        base.extend ClassMethods
-      end
-
-      def query
-        (self.class.query_klass ||= Class.new(Query)).new(self, @client[@table])
-      end
-
-      def find_by_query(dataset)
-        dataset.map do |hash|
-          @factory.fromHash(hash)
-        end
-      end
-
-      module ClassMethods
-        attr_accessor :query_klass
-
-        def scope(name, &block)
-          self.query_klass ||= Class.new(Query)
-          self.query_klass.define_scope(name, &block)
-        end
-      end
-    end
-  end
-end

data/lib/rmodel/sequel/setup.rb

@@ -1,12 +0,0 @@
-module Rmodel::Sequel
-  module Setup
-    def establish_sequel_client(name)
-      config = @clients_config[name]
-      config && establish_client(name) { Sequel.connect(config) }
-    end
-  end
-end
-
-class Rmodel::Setup
-  include Rmodel::Sequel::Setup
-end

data/lib/rmodel/sequel/simple_factory.rb

@@ -1,28 +0,0 @@
-module Rmodel::Sequel
-  class SimpleFactory
-    def initialize(klass, *attributes)
-      @klass = klass
-      @attributes = attributes
-    end
-
-    def fromHash(hash)
-      object = @klass.new
-      object.id = hash[:id]
-      @attributes.each do |attribute|
-        object.public_send "#{attribute}=", hash[attribute.to_sym]
-      end
-      object
-    end
-
-    def toHash(object, id_included)
-      hash = {}
-      @attributes.each do |attribute|
-        hash[attribute.to_sym] = object.public_send(attribute)
-      end
-      if id_included
-        hash[:id] = object.id
-      end
-      hash
-    end
-  end
-end

data/lib/rmodel/setup.rb

@@ -1,34 +0,0 @@
-require 'singleton'
-
-module Rmodel
-  class Setup
-    include Singleton
-
-    def initialize
-      @clients_config = {}
-      @established_clients = {}
-    end
-
-    def client(name, config)
-      @clients_config[name] = config
-    end
-
-    def clear
-      @clients_config.clear
-      @established_clients.clear
-    end
-
-    private
-
-    def establish_client(name)
-      @established_clients[name] ||= yield
-    end
-  end
-
-  def self.setup(&block)
-    if block
-      Setup.instance.instance_eval &block
-    end
-    Setup.instance
-  end
-end