reorm 0.1.0

data/lib/reorm/modules/database_modules.rb

@@ -0,0 +1,67 @@
+#! /usr/bin/env ruby
+# Copyright (c), 2015 Peter Wood
+# See the license.txt for details of the licensing of the code in this file.
+
+module Reorm
+  module ClassDatabaseSettings
+    @@class_db_settings = {}
+
+    def assign_table_defaults
+      @@class_db_settings[self] = {primary_key: :id,
+                                   table_name:  self.name.split("::").last.tableize}
+    end
+
+    def table_settings
+      assign_table_defaults if !@@class_db_settings.include?(self)
+      @@class_db_settings[self]
+    end
+  end
+
+  module PrimaryKeyedClassMethods
+    def primary_key(field=nil)
+      table_settings[:primary_key] = field if !field.nil?
+      table_settings[:primary_key]
+    end
+
+    def table_name(name=nil)
+      table_settings[:table_name] = name if !name.nil?
+      table_settings[:table_name]
+    end
+  end
+
+  module PrimaryKeyedInstanceMethods
+    def primary_key
+      self.class.primary_key
+    end
+
+    def table_name
+      self.class.table_name
+    end
+  end
+
+  # A module that defines the data and methods for a class that is backed on to
+  # a database table.
+  module TableBacked
+    def TableBacked.included(target)
+      target.extend(ClassDatabaseSettings)
+      target.extend(PrimaryKeyedClassMethods)
+      target.include(PrimaryKeyedInstanceMethods)
+    end
+  end
+
+  module Timestamped
+    def set_created_at
+      self.created_at = Time.now
+      self.updated_at = nil
+    end
+
+    def set_updated_at
+      self.updated_at = Time.now
+    end
+
+    def Timestamped.included(target)
+      target.before_create :set_created_at
+      target.before_update :set_updated_at
+    end
+  end
+end

data/lib/reorm/modules/event_modules.rb

@@ -0,0 +1,82 @@
+#! /usr/bin/env ruby
+# Copyright (c), 2015 Peter Wood
+# See the license.txt for details of the licensing of the code in this file.
+
+module Reorm
+  # A module that defines the class level data used for events.
+  module EventData
+    @@class_events = {}
+  end
+
+  # A module that defines the class level methods for setting event handlers.
+  module EventHandler
+    include EventData
+
+    def after_create(*methods)
+      store_event_handlers(:after_create, *methods)
+    end
+
+    def after_save(*methods)
+      store_event_handlers(:after_save, *methods)
+    end
+
+    def after_update(*methods)
+      store_event_handlers(:after_update, *methods)
+    end
+
+    def after_validate(*methods)
+      store_event_handlers(:after_validate, *methods)
+    end
+
+    def before_create(*methods)
+      store_event_handlers(:before_create, *methods)
+    end
+
+    def before_save(*methods)
+      store_event_handlers(:before_save, *methods)
+    end
+
+    def before_update(*methods)
+      store_event_handlers(:before_update, *methods)
+    end
+
+    def before_validate(*methods)
+      store_event_handlers(:before_validate, *methods)
+    end
+
+    def store_event_handlers(event, *methods)
+      if self.instance_of?(Class)
+        @@class_events[self] = {} if !@@class_events.include?(self)
+        @@class_events[self][event] = [] if !@@class_events[self].include?(event)
+        @@class_events[self][event] = @@class_events[self][event].concat(methods).uniq
+      else
+        self.class.store_event_handlers(event, *methods)
+      end
+    end
+  end
+
+  # A module that is used to provide the methods the create events.
+  module EventSource
+    include EventData
+
+    def fire_events(settings={})
+      events = settings[:events]
+      if events && !events.empty?
+        object   = (settings[:target] ? settings[:target] : self)
+        handlers = @@class_events[self.instance_of?(Class) ? self : self.class]
+        if handlers && !handlers.empty?
+          events.each do |event|
+            if handlers.include?(event)
+              handlers[event].each do |handler|
+                if !object.respond_to?(handler)
+                  raise Error, "Unable to locate a method called '#{event}' for an instance of the #{object.class.name} class."
+                end
+                object.__send__(handler)
+              end
+            end
+          end
+        end
+      end
+    end
+  end
+end

data/lib/reorm/modules/validation_modules.rb

@@ -0,0 +1,29 @@
+#! /usr/bin/env ruby
+# Copyright (c), 2015 Peter Wood
+# See the license.txt for details of the licensing of the code in this file.
+
+module Reorm
+  module Validations
+    def validate_presence_of(field)
+      PresenceValidator.new(*field).validate(self)
+    end
+
+    def validate_length_of(field, options={})
+      if options.include?(:minimum)
+        MinimumLengthValidator.new(options[:minimum], *field).validate(self)
+      end
+
+      if options.include?(:maximum)
+        MaximumLengthValidator.new(options[:maximum], *field).validate(self)
+      end
+    end
+
+    def validate_inclusion_of(field, *values)
+      InclusionValidator.new(values, *field).validate(self)
+    end
+
+    def validate_exclusion_of(field, *values)
+      ExclusionValidator.new(values, *field).validate(self)
+    end
+  end
+end

data/lib/reorm/modules.rb

@@ -0,0 +1,7 @@
+#! /usr/bin/env ruby
+# Copyright (c), 2015 Peter Wood
+# See the license.txt for details of the licensing of the code in this file.
+
+require "reorm/modules/database_modules"
+require "reorm/modules/event_modules"
+require "reorm/modules/validation_modules"

data/lib/reorm/property_errors.rb

@@ -0,0 +1,53 @@
+#! /usr/bin/env ruby
+# Copyright (c), 2015 Peter Wood
+# See the license.txt for details of the licensing of the code in this file.
+
+module Reorm
+	class PropertyErrors
+		def initialize
+			@errors = {}
+		end
+
+		def clear?
+			@errors.empty?
+		end
+
+		def reset
+			@errors = {}
+		end
+
+		def include?(property)
+			@errors.include?(property.to_sym)
+		end
+
+		def add(property, message)
+			if ![nil, ""].include?(message)
+				@errors[property.to_sym] = [] if !@errors.include?(property.to_sym)
+				@errors[property.to_sym] << message
+			end
+			self
+		end
+
+    def properties
+			@errors.keys
+		end
+
+		def messages(property)
+			[].concat(@errors.fetch(property.to_sym, []))
+		end
+
+		def each
+			@errors.each {|property, messages| yield(property, messages)}
+		end
+
+		def to_s
+			text = StringIO.new
+			@errors.each do |property, messages|
+				messages.each do |message|
+					text << "#{text.size > 0 ? "\n" : ""}#{property} #{message}"
+				end
+			end
+			text.string
+		end
+	end
+end

data/lib/reorm/validators/exclusion_validator.rb

@@ -0,0 +1,18 @@
+#! /usr/bin/env ruby
+# Copyright (c), 2015 Peter Wood
+# See the license.txt for details of the licensing of the code in this file.
+
+module Reorm
+  class ExclusionValidator < Validator
+    def initialize(values, *field)
+      super("is set to an unpermitted value.", *field)
+      @values = [].concat(values)
+    end
+
+    def validate(object)
+      if @values.include?(field.value(object))
+        object.errors.add(field.to_s, message)
+      end
+    end
+  end
+end

data/lib/reorm/validators/inclusion_validator.rb

@@ -0,0 +1,18 @@
+#! /usr/bin/env ruby
+# Copyright (c), 2015 Peter Wood
+# See the license.txt for details of the licensing of the code in this file.
+
+module Reorm
+  class InclusionValidator < Validator
+    def initialize(values, *field)
+      super("is not set to one of its permitted values.", *field)
+      @values = values
+    end
+
+    def validate(object)
+      if !@values.include?(field.value(object))
+        object.errors.add(field.to_s, message)
+      end
+    end
+  end
+end

data/lib/reorm/validators/maximum_length_validator.rb

@@ -0,0 +1,19 @@
+#! /usr/bin/env ruby
+# Copyright (c), 2015 Peter Wood
+# See the license.txt for details of the licensing of the code in this file.
+
+module Reorm
+  class MaximumLengthValidator < Validator
+    def initialize(length, *field)
+      super("is too long (maximum length is #{length} characters).", *field)
+      @length = length
+    end
+
+    def validate(object)
+      value = field.value(object)
+      if value && value.to_s.length > @length
+        object.errors.add field.to_s, message
+      end
+    end
+  end
+end

data/lib/reorm/validators/minimum_length_validator.rb

@@ -0,0 +1,19 @@
+#! /usr/bin/env ruby
+# Copyright (c), 2015 Peter Wood
+# See the license.txt for details of the licensing of the code in this file.
+
+module Reorm
+  class MinimumLengthValidator < Validator
+    def initialize(length, *field)
+      super("is too short (minimum length is #{length} characters).", *field)
+      @length = length
+    end
+
+    def validate(object)
+      value = field.value(object)
+      if [nil, ""].include?(value) || value.to_s.length < @length
+        object.errors.add field.to_s, message
+      end
+    end
+  end
+end

data/lib/reorm/validators/presence_validator.rb

@@ -0,0 +1,17 @@
+#! /usr/bin/env ruby
+# Copyright (c), 2015 Peter Wood
+# See the license.txt for details of the licensing of the code in this file.
+
+module Reorm
+  class PresenceValidator < Validator
+    def initialize(*field)
+      super("cannot be blank.", *field)
+    end
+
+    def validate(object)
+      if !field.exists?(object) || [nil, ""].include?(field.value(object))
+        object.errors.add(field.to_s, message)
+      end
+    end
+  end
+end

data/lib/reorm/validators/validator.rb

@@ -0,0 +1,13 @@
+#! /usr/bin/env ruby
+# Copyright (c), 2015 Peter Wood
+# See the license.txt for details of the licensing of the code in this file.
+
+module Reorm
+  class Validator
+    def initialize(message, *field)
+      @field   = FieldPath.new(*field)
+      @message = message
+    end
+    attr_reader :field, :message
+  end
+end

data/lib/reorm/validators.rb

@@ -0,0 +1,10 @@
+#! /usr/bin/env ruby
+# Copyright (c), 2015 Peter Wood
+# See the license.txt for details of the licensing of the code in this file.
+
+require "reorm/validators/validator"
+require "reorm/validators/presence_validator"
+require "reorm/validators/minimum_length_validator"
+require "reorm/validators/maximum_length_validator"
+require "reorm/validators/inclusion_validator"
+require "reorm/validators/exclusion_validator"

data/lib/reorm/version.rb

@@ -0,0 +1,6 @@
+module Reorm
+  MAJOR_VERSION              = 0
+  MINOR_VERSION              = 1
+  BUILD_VERSION              = 0
+  VERSION                    = "#{MAJOR_VERSION}.#{MINOR_VERSION}.#{BUILD_VERSION}"
+end

data/lib/reorm.rb

@@ -0,0 +1,47 @@
+#! /usr/bin/env ruby
+# Copyright (c), 2015 Peter Wood
+# See the license.txt for details of the licensing of the code in this file.
+
+require "active_support/inflector"
+require "configurative"
+require "connection_pool"
+require "logjam"
+require "rethinkdb"
+require "stringio"
+require "reorm/version"
+require "reorm/exceptions"
+require "reorm/configuration"
+require "reorm/field_path"
+require "reorm/modules"
+require "reorm/validators"
+require "reorm/model"
+require "reorm/property_errors"
+require "reorm/cursor"
+
+include RethinkDB::Shortcuts
+
+module Reorm
+  # Constants used with Rethinkdb connections.
+  DEFAULT_SIZE               = 5
+  DEFAULT_TIMEOUT            = 5
+  SETTINGS_NAMES             = [:host, :port, :db, :auth_key, :timeout]
+
+  # Module property containing the connection pool.
+  @@reorm_connections = ConnectionPool.new(size:    Configuration.fetch(:size, DEFAULT_SIZE),
+                                             timeout: Configuration.fetch(:timeout, DEFAULT_TIMEOUT)) do
+                            settings = Configuration.instance.to_h.inject({}) do |store, entry|
+                                         store[entry[0]] = entry[1] if SETTINGS_NAMES.include?(entry[0])
+                                         store
+                                       end
+                            r.connect(settings)
+                          end
+
+  # A method for obtaining a connection from the module connection pool. The
+  # intended usage is that you call this method with a block that will be passed
+  # the connection as a parameter.
+  def self.connection
+    @@reorm_connections.with do |connection|
+      yield connection
+    end
+  end
+end

data/reorm.gemspec

@@ -0,0 +1,30 @@
+# coding: utf-8
+lib = File.expand_path('../lib', __FILE__)
+$LOAD_PATH.unshift(lib) unless $LOAD_PATH.include?(lib)
+require 'reorm/version'
+
+Gem::Specification.new do |spec|
+  spec.name          = "reorm"
+  spec.version       = Reorm::VERSION
+  spec.authors       = ["Peter Wood"]
+  spec.email         = ["peter.wood@longboat.com"]
+  spec.summary       = %q{A library for use with the RethinkDB application.}
+  spec.description   = %q{A library the wraps RQL and provides a basic model class for the RethinkDB system.}
+  spec.homepage      = "https://github.com/free-beer/reorm"
+  spec.license       = "MIT"
+
+  spec.files         = `git ls-files -z`.split("\x0")
+  spec.executables   = spec.files.grep(%r{^bin/}) { |f| File.basename(f) }
+  spec.test_files    = spec.files.grep(%r{^(test|spec|features)/})
+  spec.require_paths = ["lib"]
+
+  spec.add_development_dependency "bundler", "~> 1.7"
+  spec.add_development_dependency "rake", "~> 10.0"
+  spec.add_development_dependency "rspec", "~> 3.3"
+
+  spec.add_dependency "activesupport", "~> 4.2"
+  spec.add_dependency "configurative", "~> 0.1"
+  spec.add_dependency "connection_pool", "~> 2.2"
+  spec.add_dependency "logjam", "~> 1.2"
+  spec.add_dependency "rethinkdb", "~> 2.0"
+end

data/spec/catwalk/modules/timestamped_spec.rb

@@ -0,0 +1,17 @@
+require "spec_helper"
+
+class TimestampedTestClass < Reorm::Model
+	extend Reorm::Timestamped
+end
+
+describe Reorm::Timestamped do
+	subject {
+		TimestampedTestClass
+	}
+
+	it "set the timestamp fields when a record is created" do
+		record = subject.create(label: "First")
+		expect(record.created_at).not_to be_nil
+		expect(record.updated_at).to be_nil
+	end
+end

data/spec/reorm/cursor_spec.rb

@@ -0,0 +1,214 @@
+require "spec_helper"
+
+class CursorTestModel < Reorm::Model
+end
+
+describe Reorm::Cursor do
+  subject {
+    Reorm::Cursor.new(CursorTestModel, r.table(CursorTestModel.table_name))
+  }
+
+  before do
+    CursorTestModel.create(index: 1)
+    CursorTestModel.create(index: 2)
+    CursorTestModel.create(index: 3)
+    CursorTestModel.create(index: 4)
+    CursorTestModel.create(index: 5)
+  end
+
+  describe "#close" do
+    it "silently does nothing if the internal cursor isn't open" do
+      expect {
+        subject.close
+      }.not_to raise_exception
+    end
+
+    it "cleans up where the internal cursor is open" do
+      expect(subject.next).not_to be_nil
+      expect {
+        subject.close
+      }.not_to raise_exception
+    end
+  end
+
+  describe "#count()" do
+    it "returns a count of the number of rows that the cursor will iterate across" do
+      expect(subject.count).to eq(5)
+    end
+  end
+
+  describe "#exhausted?()" do
+    it "returns false if the internal cursor isn't open" do
+      expect(subject.exhausted?).to eq(false)
+    end
+
+    it "returns false if the internal cursor is open but there are rows remaining" do
+      expect(subject.next).not_to be_nil
+      expect(subject.exhausted?).to eq(false)
+    end
+
+    it "returns true if the internal cursor is open and there are no more rows remaining" do
+      subject.count.times {expect(subject.next).not_to be_nil}
+      expect(subject.exhausted?).to eq(true)
+    end
+  end
+
+  describe "#find()" do
+    it "returns the first row that matches the search block" do
+      model = subject.find {|record| record.index == 3}
+      expect(model).not_to be_nil
+      expect(model.class).to eq(CursorTestModel)
+    end
+
+    it "returns nil if a matching record cannot be found" do
+      model = subject.find {|record| record.index == 3000}
+      expect(model).to be_nil
+    end
+  end
+
+  describe "#next()" do
+    describe "when used without an order by clause" do
+      it "returns the next record from the cursor" do
+        (1..5).each do |index|
+          model = subject.next
+          expect(model).not_to be_nil
+          expect((1..5)).to include(model.index)
+        end
+      end
+
+      it "raises an exception if called on an exhausted cursor" do
+        5.times {subject.next}
+        expect {
+          subject.next
+        }.to raise_exception(Reorm::Error, "There are no more matching records.")
+      end
+    end
+
+    describe "when used with an order by clause" do
+      subject {
+        Reorm::Cursor.new(CursorTestModel, r.table(CursorTestModel.table_name)).order_by(:index)
+      }
+
+      it "returns the next record from the cursor" do
+        (1..5).each do |index|
+          model = subject.next
+          expect(model).not_to be_nil
+          expect((1..5)).to include(model.index)
+        end
+      end
+
+      it "raises an exception if called on an exhausted cursor" do
+        5.times {subject.next}
+        expect {
+          subject.next
+        }.to raise_exception(Reorm::Error, "There are no more matching records.")
+      end
+    end
+  end
+
+  describe "#each()" do
+    describe "when an order by clause hasn't been applied" do
+      it "yields each available record to the specified block" do
+        indices = [1, 2, 3, 4, 5]
+        subject.each do |record|
+          indices.delete(record.index)
+        end
+        expect(indices.empty?).to eq(true)
+      end
+    end
+
+    describe "when an order by clause has been applied" do
+      subject {
+        Reorm::Cursor.new(CursorTestModel, r.table(CursorTestModel.table_name)).order_by(:index)
+      }
+
+      it "yields each available record to the specified block" do
+        indices = [1, 2, 3, 4, 5]
+        subject.each do |record|
+          indices.delete(record.index)
+        end
+        expect(indices.empty?).to eq(true)
+      end
+    end
+  end
+
+  describe "#inject()" do
+    it "yields each available record to the specified block" do
+      output = subject.inject([]) {|list, record| list << record.index}
+      expect(output).to include(1)
+      expect(output).to include(2)
+      expect(output).to include(3)
+      expect(output).to include(4)
+      expect(output).to include(5)
+    end
+  end
+
+  describe "#nth()" do
+    it "returns the record at the specified offset" do
+      expect(subject.nth(2).index).to eq(subject.to_a[2].index)
+    end
+
+    it "returns nil if an invalid offset is specified" do
+      expect(subject.nth(1000)).to be_nil
+      expect(subject.nth(-1)).to be_nil
+    end
+  end
+
+  describe "#first()" do
+    let(:first) {
+      subject.nth(0)
+    }
+
+    it "returns the first matching record from the cursor" do
+      expect(subject.first.index).to eq(first.index)
+    end
+  end
+
+  describe "#last()" do
+    let(:last) {
+      subject.nth(4)
+    }
+
+    it "returns the last matching record from the cursor" do
+      expect(subject.last.index).to eq(last.index)
+    end
+  end
+
+  describe "#to_a()" do
+    it "returns an array containing all of the matching records from the cursor" do
+      array = subject.to_a
+      expect(array).not_to be_nil
+      expect(array.class).to eq(Array)
+      expect(array.size).to eq(5)
+      expect(array.inject([]) {|list, model| list << model.index}.sort).to eq([1, 2, 3, 4, 5])
+    end
+  end
+
+  describe "#filter()" do
+    it "returns a Cursor object" do
+      output = subject.filter({index: 4})
+      expect(output).not_to be_nil
+      expect(output.class).to eq(Reorm::Cursor)
+    end
+
+    it "applies a filter to the cursor records" do
+      cursor = subject.filter({index: 4})
+      expect(cursor.count).to eq(1)
+      expect(cursor.first.index).to eq(4)
+    end
+  end
+
+  describe "#order_by()" do
+    it "returns a Cursor object" do
+      output = subject.order_by(:index)
+      expect(output).not_to be_nil
+      expect(output.class).to eq(Reorm::Cursor)
+    end
+
+    it "applies an ordering to the cursor records" do
+      cursor  = subject.order_by(r.desc(:index))
+      indices = cursor.inject([]) {|list, record| list << record.index}
+      expect(indices).to eq([5, 4, 3, 2, 1])
+    end
+  end
+end