rmodel 0.4.0.dev → 1.0.0

data/Rakefile

@@ -1,2 +1 @@
-require "bundler/gem_tasks"
-
+require 'bundler/gem_tasks'

data/examples/mongo_embedded.rb

@@ -1,33 +1,39 @@
 require 'rmodel'
 
-Rmodel.setup do
-  client :default, { hosts: [ 'localhost'], database: 'test' }
-end
+DB = Mongo::Client.new(['localhost'], database: 'test')
+source = Rmodel::Mongo::Source.new(DB, :flats)
 
-Owner = Struct.new(:id, :first_name, :last_name)
-Room = Struct.new(:id, :name, :square, :bed)
+Owner = Struct.new(:first_name, :last_name)
+Bed = Struct.new(:type)
+Room = Struct.new(:name, :square, :bed)
 Flat = Struct.new(:id, :address, :rooms, :owner)
-Bed = Struct.new(:id, :type)
-
-class FlatRepository < Rmodel::Mongo::Repository
-  simple_factory Flat, :address do
-    embeds_many :rooms, simple_factory(Room, :name, :square) do
-      embeds_one :bed, simple_factory(Bed, :type)
-    end
-    embeds_one :owner, simple_factory(Owner, :first_name, :last_name)
-  end
-end
-repo = FlatRepository.new
-repo.query.remove
+
+owner_mapper = Rmodel::Mongo::Mapper.new(Owner)
+                                    .define_attributes(:first_name, :last_name)
+
+bed_mapper = Rmodel::Mongo::Mapper.new(Bed).define_attribute(:type)
+
+room_mapper = Rmodel::Mongo::Mapper.new(Room)
+                                   .define_attributes(:name, :square)
+                                   .define_attribute(:bed, bed_mapper)
+
+rooms_mapper = Rmodel::ArrayMapper.new(room_mapper)
+flat_mapper =  Rmodel::Mongo::Mapper.new(Flat)
+                                    .define_attribute(:address)
+                                    .define_attribute(:rooms, rooms_mapper)
+                                    .define_attribute(:owner, owner_mapper)
+
+repo = Rmodel::Repository.new(source, flat_mapper)
+repo.delete_all
 
 flat = Flat.new
 flat.address = 'Googleplex, Mountain View, California, U.S'
 flat.rooms = [
-  Room.new(nil, 'dining room', 150),
-  Room.new(nil, 'sleeping room #1', 50, Bed.new(nil, 'single')),
-  Room.new(nil, 'sleeping room #2', 20, Bed.new(nil, 'king-size'))
+  Room.new('dining room', 150),
+  Room.new('sleeping room #1', 50, Bed.new('single')),
+  Room.new('sleeping room #2', 20, Bed.new('king-size'))
 ]
-flat.owner = Owner.new(nil, 'John', 'Doe')
+flat.owner = Owner.new('John', 'Doe')
 
 repo.insert(flat)
 p repo.find(flat.id)

data/examples/scopes.rb

@@ -0,0 +1,28 @@
+require 'rmodel'
+
+DB = Mongo::Client.new(['localhost'], database: 'test')
+source = Rmodel::Mongo::Source.new(DB, :users)
+
+User = Struct.new(:id, :name, :email)
+mapper = Rmodel::Mongo::Mapper.new(User).define_attributes(:name, :email)
+
+class UserRepository < Rmodel::Repository
+  scope :have_email do
+    where(email: { '$exists' => true })
+  end
+
+  scope :start_with do |letter|
+    where(name: { '$regex' => "^#{letter}", '$options' => 'i' })
+  end
+end
+
+repo = UserRepository.new(source, mapper)
+repo.delete_all
+
+repo.insert(User.new(nil, 'John', 'john@example.com'))
+repo.insert(User.new(nil, 'Bill', 'bill@example.com'))
+repo.insert(User.new(nil, 'Bob'))
+
+p repo.fetch.start_with('b').to_a
+p repo.fetch.start_with('b').have_email.to_a
+p repo.fetch.count

data/examples/sql_repository.rb

@@ -1,42 +1,30 @@
 require 'rmodel'
 
-Rmodel.setup do
-  # see more examples of connection options
-  # http://sequel.jeremyevans.net/rdoc/files/doc/opening_databases_rdoc.html#label-Passing+a+block+to+either+method
-  client :default, { adapter: 'sqlite', database: 'rmodel_test.sqlite3' }
-end
+DB = Sequel.connect(adapter: 'sqlite', database: 'rmodel_test.sqlite3')
+source = Rmodel::Sequel::Source.new(DB, :things)
 
-client = Rmodel.setup.establish_sequel_client(:default)
-client.drop_table? :things
-client.create_table :things do
+DB.drop_table? :things
+DB.create_table :things do
   primary_key :id
   String :name
   Float :price
 end
 
-class Thing
-  attr_accessor :id, :name, :price
-
-  def initialize(name = nil, price = nil)
-    self.name = name
-    self.price = price
-  end
-end
-
-class ThingRepository < Rmodel::Sequel::Repository
-  simple_factory Thing, :name, :price
+Thing = Struct.new(:id, :name, :price)
+mapper = Rmodel::Sequel::Mapper.new(Thing)
+                               .define_attributes(:name, :price)
 
+class ThingRepository < Rmodel::Repository
   scope :worth_more_than do |amount|
     # use Sequel dataset filtering http://sequel.jeremyevans.net/rdoc/files/doc/dataset_filtering_rdoc.html
     where { price >= amount }
   end
 end
 
-repo = ThingRepository.new
-repo.insert Thing.new('iPod', 200)
-repo.insert Thing.new('iPhone', 300)
-repo.insert Thing.new('iPad', 500)
+repo = ThingRepository.new(source, mapper)
+repo.insert Thing.new(nil, 'iPod', 200)
+repo.insert Thing.new(nil, 'iPhone', 300)
+repo.insert Thing.new(nil, 'iPad', 500)
 
-p repo.query.count # 3
-p repo.query.worth_more_than(400).count # 1
-p repo.query.worth_more_than(400).to_sql
+p repo.fetch.count # 3
+p repo.fetch.worth_more_than(400).count # 1

data/examples/timestamps.rb

@@ -1,17 +1,14 @@
 require 'rmodel'
 
-Rmodel.setup do
-  client :default, { hosts: [ 'localhost' ], database: 'test' }
-end
+DB = Mongo::Client.new(['localhost'], database: 'test')
+source = Rmodel::Mongo::Source.new(DB, :things)
 
-class Thing
-  attr_accessor :id, :name, :created_at, :updated_at
-end
+Thing = Struct.new(:id, :name, :created_at, :updated_at)
+mapper = Rmodel::Mongo::Mapper.new(Thing)
+                              .define_attribute(:name)
+                              .define_timestamps
 
-class ThingRepository < Rmodel::Mongo::Repository
-  simple_factory Thing, :name, :created_at, :updated_at
-end
-repo = ThingRepository.new
+repo = Rmodel::Repository.new(source, mapper)
 
 thing = Thing.new
 thing.name = 'chair'

data/examples/webapp/models/task.rb

@@ -0,0 +1,9 @@
+require 'active_model'
+
+class Task
+  include ActiveModel::Validations
+
+  attr_accessor :id, :title, :created_at, :updated_at
+
+  validates :title, presence: true
+end

data/examples/webapp/repositories/task_repository.rb

@@ -0,0 +1,14 @@
+class TaskRepository < Rmodel::Repository
+  scope(:by_title) { order_by(:title.asc) }
+  scope(:by_recency) { order_by(:created_at.desc) }
+
+  def sorted(sort_by)
+    if sort_by == 'title'
+      fetch.by_title
+    elsif sort_by == 'recency'
+      fetch.by_recency
+    else
+      fetch.by_title
+    end
+  end
+end

data/examples/webapp/server.rb

@@ -0,0 +1,25 @@
+require 'sinatra'
+require './lib/rmodel'
+require './examples/webapp/models/task'
+require './examples/webapp/repositories/task_repository'
+require './examples/webapp/support/repositories'
+
+include Repositories
+
+get '/' do
+  tasks = task_repo.sorted(params[:sort_by])
+  erb :index, locals: { tasks: tasks }
+end
+
+post '/' do
+  task = Task.new
+  task.title = params[:title]
+
+  if task.valid?
+    task_repo.save(task)
+    redirect to "/?sort_by=#{params[:sort_by]}"
+  else
+    tasks = task_repo.sorted(params[:sort_by])
+    erb :index, locals: { tasks: tasks }
+  end
+end

data/examples/webapp/support/mappers.rb

@@ -0,0 +1,11 @@
+require 'lazy_injector'
+
+module Mappers
+  include LazyInjector
+
+  register :task_mapper do
+    Rmodel::Mongo::Mapper.new(Task)
+                         .define_attribute(:title)
+                         .define_timestamps
+  end
+end

data/examples/webapp/support/repositories.rb

@@ -0,0 +1,12 @@
+require './examples/webapp/support/sources'
+require './examples/webapp/support/mappers'
+
+module Repositories
+  include LazyInjector
+  include Sources
+  include Mappers
+
+  register :task_repo do
+    TaskRepository.new(task_source, task_mapper)
+  end
+end

data/examples/webapp/support/sources.rb

@@ -0,0 +1,13 @@
+require 'lazy_injector'
+
+module Sources
+  include LazyInjector
+
+  register :db do
+    Mongo::Client.new(['localhost'], database: 'test')
+  end
+
+  register :task_source do
+    Rmodel::Mongo::Source.new(db, :tasks)
+  end
+end

data/examples/webapp/views/index.erb

@@ -0,0 +1,20 @@
+<div>
+  sort by
+  <a href="/?sort_by=title">title</a>
+  <a href="/?sort_by=recency">recency</a>
+</div>
+
+<ol>
+  <% tasks.each do |task| %>
+    <li>
+      <%= task.title %>
+      (created at <%= task.created_at %>)
+    </li>
+  <% end %>
+</ol>
+
+<form action="/" method="post">
+  <input type="hidden" name="sort_by" value="<%= params[:sort_by] %>" />
+  <input type="text" placeholder="New Task" name="title" />
+  <input type="submit" />
+</form>

data/lib/rmodel.rb

@@ -1,13 +1,16 @@
+require 'active_support/inflector'
 require 'rmodel/version'
-require 'rmodel/setup'
 require 'rmodel/errors'
-require 'rmodel/mongo/setup'
-require 'rmodel/mongo/simple_factory'
-require 'rmodel/mongo/repository'
-require 'rmodel/sequel/setup'
-require 'rmodel/sequel/simple_factory'
-require 'rmodel/sequel/repository'
+require 'rmodel/scope'
+require 'rmodel/repository'
+require 'rmodel/uni_hash'
+require 'rmodel/base_mapper'
+require 'rmodel/array_mapper'
+require 'rmodel/dummy_mapper'
+require 'rmodel/mongo/source'
+require 'rmodel/mongo/mapper'
+require 'rmodel/sequel/source'
+require 'rmodel/sequel/mapper'
 
 module Rmodel
-
 end

data/lib/rmodel/array_mapper.rb

@@ -0,0 +1,23 @@
+module Rmodel
+  class ArrayMapper
+    def initialize(mapper)
+      @mapper = mapper
+    end
+
+    def serialize(objects, id_included)
+      if objects.nil?
+        nil
+      else
+        objects.map { |object| @mapper.serialize(object, id_included) }
+      end
+    end
+
+    def deserialize(array)
+      if array.nil?
+        nil
+      else
+        array.map { |entry| @mapper.deserialize(entry) }
+      end
+    end
+  end
+end

data/lib/rmodel/base_mapper.rb

@@ -0,0 +1,56 @@
+module Rmodel
+  class BaseMapper
+    def initialize(model)
+      @model = model
+      self.primary_key = :id
+      self.key_op = :to_sym
+      @attributes = {}
+    end
+
+    def define_attribute(attr, mapper = DummyMapper.instance)
+      @attributes[attr] = mapper
+      self
+    end
+
+    def define_attributes(*attributes)
+      attributes.each { |attr| define_attribute(attr) }
+      self
+    end
+
+    def define_timestamps
+      define_attributes :created_at, :updated_at
+    end
+
+    def deserialize(hash)
+      return nil if hash.nil?
+
+      uni_hash = UniHash.new(hash, key_op)
+
+      object = @model.new
+      object.id = uni_hash[primary_key] if object.respond_to?(:id)
+      @attributes.each do |attr, mapper|
+        deserialized = mapper.deserialize(uni_hash[attr])
+        object.public_send "#{attr}=", deserialized
+      end
+      object
+    end
+
+    def serialize(object, id_included)
+      return nil if object.nil?
+
+      uni_hash = UniHash.new({}, key_op)
+      @attributes.each do |attr, mapper|
+        serialized = mapper.serialize(object.public_send(attr), id_included)
+        uni_hash[attr] = serialized
+      end
+      if id_included && object.respond_to?(:id)
+        uni_hash[primary_key] = object.id
+      end
+      uni_hash.to_hash
+    end
+
+    private
+
+    attr_accessor :primary_key, :key_op
+  end
+end

data/lib/rmodel/dummy_mapper.rb

@@ -0,0 +1,15 @@
+require 'singleton'
+
+module Rmodel
+  class DummyMapper
+    include Singleton
+
+    def serialize(arg, _id_included)
+      arg
+    end
+
+    def deserialize(arg)
+      arg
+    end
+  end
+end

data/lib/rmodel/mongo/mapper.rb

@@ -0,0 +1,11 @@
+module Rmodel
+  module Mongo
+    class Mapper < Rmodel::BaseMapper
+      def initialize(model)
+        super
+        self.primary_key = '_id'
+        self.key_op = :to_s
+      end
+    end
+  end
+end

data/lib/rmodel/mongo/source.rb

@@ -0,0 +1,50 @@
+require 'origin'
+require 'mongo'
+
+module Rmodel
+  module Mongo
+    class Source
+      class Query
+        include Origin::Queryable
+      end
+
+      def initialize(connection, collection)
+        @connection = connection
+        raise ArgumentError, 'Connection is not setup' unless @connection
+
+        @collection = collection
+        raise ArgumentError, 'Collection can not be guessed' unless @collection
+      end
+
+      def find(id)
+        @connection[@collection].find('_id' => id).first
+      end
+
+      def insert(doc)
+        doc = doc.merge('_id' => BSON::ObjectId.new) if doc['_id'].nil?
+        @connection[@collection].insert_one(doc)
+        doc['_id']
+      end
+
+      def update(id, doc)
+        @connection[@collection].find(_id: id).update_one(doc)
+      end
+
+      def delete(id)
+        @connection[@collection].find(_id: id).delete_one
+      end
+
+      def build_query
+        Query.new
+      end
+
+      def exec_query(query)
+        @connection[@collection].find(query.selector, query.options)
+      end
+
+      def delete_by_query(query)
+        exec_query(query).delete_many
+      end
+    end
+  end
+end