perpetuity 0.1

data/lib/perpetuity/retrieval.rb

@@ -0,0 +1,82 @@
+require 'perpetuity/data_injectable'
+require 'perpetuity/mapper'
+
+module Perpetuity
+  class Retrieval
+    include DataInjectable
+    include Enumerable
+    attr_accessor :sort_attribute, :sort_direction, :result_limit, :result_page, :quantity_per_page
+
+    def initialize klass, criteria, data_source = Perpetuity.configuration.data_source
+      @class = klass
+      @criteria = criteria
+      @data_source = data_source
+    end
+    
+    def sort attribute=:name
+      retrieval = clone
+      retrieval.sort_attribute = attribute
+      retrieval.sort_direction = :ascending
+
+      retrieval
+    end
+
+    def reverse
+      retrieval = clone
+      retrieval.sort_direction = retrieval.sort_direction == :descending ? :ascending : :descending
+
+      retrieval
+    end
+
+    def page page
+      retrieval = clone
+      retrieval.result_page = page
+      retrieval.quantity_per_page = 20
+      retrieval
+    end
+
+    def per_page per
+      retrieval = clone
+      retrieval.quantity_per_page = per
+      retrieval
+    end
+
+    def each &block
+      to_a.each(&block)
+    end
+
+    def to_a
+      options = {
+        attribute: sort_attribute,
+        direction: sort_direction,
+        limit: result_limit || quantity_per_page,
+        page: result_page
+      }
+      results = @data_source.retrieve(@class, @criteria, options)
+      objects = []
+      results.each do |result|
+        object = @class.new
+        inject_data object, Mapper.new.unserialize(result)
+
+        objects << object
+      end
+
+      objects
+    end
+
+    def [] index
+      to_a[index]
+    end
+
+    def empty?
+      to_a.empty?
+    end
+    
+    def limit lim
+      retrieval = clone
+      retrieval.result_limit = lim
+      
+      retrieval
+    end
+  end
+end

data/lib/perpetuity/validations/length.rb

@@ -0,0 +1,36 @@
+module Perpetuity
+  module Validations
+    class Length
+      def initialize attribute, options
+        @attribute = attribute
+        @at_least  = nil
+        @at_most   = nil
+        options.each do |option, value|
+          send option, value
+        end
+      end
+
+      def pass? object
+        length = object.send(@attribute).length
+
+        return false unless @at_least.nil? or @at_least <= length
+        return false unless @at_most.nil? or @at_most >= length
+
+        true
+      end
+
+      def at_least value
+        @at_least = value
+      end
+
+      def at_most value
+        @at_most = value
+      end
+
+      def between range
+        at_least range.min
+        at_most range.max
+      end
+    end
+  end
+end

data/lib/perpetuity/validations/presence.rb

@@ -0,0 +1,14 @@
+module Perpetuity
+  module Validations
+    class Presence
+      def initialize attribute
+        @attribute = attribute
+      end
+
+      def pass? object
+        !object.send(@attribute).nil? &&
+        object.send(@attribute).strip != ''
+      end
+    end
+  end
+end

data/lib/perpetuity/validations/validation_set.rb

@@ -0,0 +1,27 @@
+require 'perpetuity/validations/length'
+require 'perpetuity/validations/presence'
+
+module Perpetuity
+  class ValidationSet < Set
+
+    def valid? object
+      each do |validation|
+        return false unless validation.pass?(object)
+      end
+
+      true
+    end
+
+    def invalid? object
+      !valid? object
+    end
+
+    def present attribute
+      self << Perpetuity::Validations::Presence.new(attribute)
+    end
+
+    def length attribute, options = {}
+      self << Perpetuity::Validations::Length.new(attribute, options)
+    end
+  end
+end

data/lib/perpetuity/validations.rb

@@ -0,0 +1 @@
+require 'perpetuity/validations/validation_set'

data/lib/perpetuity/version.rb

@@ -0,0 +1,3 @@
+module Perpetuity
+  VERSION = "0.1"
+end

data/lib/perpetuity.rb

@@ -0,0 +1,23 @@
+require "perpetuity/version"
+require "perpetuity/retrieval"
+require "perpetuity/mongodb"
+require "perpetuity/config"
+require "perpetuity/mapper"
+
+module Perpetuity
+  def self.configure &block
+    configuration.instance_exec(&block)
+  end
+  
+  def self.configuration
+    @@configuration ||= Configuration.new
+  end
+
+  def self.generate_mapper_for klass, &block
+    Mapper.generate_for klass, &block
+  end
+
+  def self.[] klass
+    Mapper[klass]
+  end
+end

data/perpetuity.gemspec

@@ -0,0 +1,25 @@
+# -*- encoding: utf-8 -*-
+$:.push File.expand_path("../lib", __FILE__)
+require "perpetuity/version"
+
+Gem::Specification.new do |s|
+  s.name        = "perpetuity"
+  s.version     = Perpetuity::VERSION
+  s.authors     = ["Jamie Gaskins"]
+  s.email       = ["jgaskins@gmail.com"]
+  s.homepage    = "https://github.com/jgaskins/perpetuity.git"
+  s.summary     = %q{Persistence library allowing persistence of Ruby objects}
+  s.description = %q{Persistence library allowing persistence of Ruby objects without adding persistence concerns to domain objects.}
+
+  s.files         = `git ls-files`.split("\n")
+  s.test_files    = `git ls-files -- {test,spec,features}/*`.split("\n")
+  s.executables   = `git ls-files -- bin/*`.split("\n").map{ |f| File.basename(f) }
+  s.require_paths = ["lib"]
+
+  # specify any dependencies here; for example:
+  s.add_development_dependency "rake"
+  s.add_development_dependency "rspec", "~> 2.8.0"
+  s.add_development_dependency "guard-rspec"
+  s.add_runtime_dependency "mongo"
+  s.add_runtime_dependency "bson_ext"
+end

data/spec/perpetuity/attribute_set_spec.rb

@@ -0,0 +1,19 @@
+require 'perpetuity/attribute_set'
+
+module Perpetuity
+  describe AttributeSet do
+    it 'contains attributes' do
+      attribute = double('Attribute')
+      subject << attribute
+
+      subject.first.should eq attribute
+    end
+
+    it 'can access attributes by name' do
+      user_attribute = double('Attribute', name: :user)
+      subject << user_attribute
+
+      subject[:user].should eq user_attribute
+    end
+  end
+end

data/spec/perpetuity/attribute_spec.rb

@@ -0,0 +1,19 @@
+require 'perpetuity/attribute'
+
+module Perpetuity
+  describe Attribute do
+    subject { Attribute.new :article, Object }
+    it 'has a name' do
+      subject.name.should == :article
+    end
+
+    it 'has a type' do
+      subject.type.should == Object
+    end
+
+    it 'can be embedded' do
+      attribute = Attribute.new :article, Object, embedded: true
+      attribute.should be_embedded
+    end
+  end
+end

data/spec/perpetuity/config_spec.rb

@@ -0,0 +1,13 @@
+require 'perpetuity/config'
+
+module Perpetuity
+  describe Configuration do
+    let(:config) { Configuration.new }
+
+    it 'sets a data source' do
+      db = double('db')
+      config.data_source db
+      config.data_source.should == db
+    end
+  end
+end

data/spec/perpetuity/data_injectable_spec.rb

@@ -0,0 +1,26 @@
+require 'perpetuity/data_injectable'
+
+module Perpetuity
+  describe DataInjectable do
+    let(:klass) { Class.new }
+    let(:object) { klass.new }
+
+    before { klass.extend DataInjectable }
+
+    it 'injects data into an object' do
+      klass.inject_data object, { a: 1, b: 2 }
+      object.instance_variable_get(:@a).should eq 1
+      object.instance_variable_get(:@b).should eq 2
+    end
+
+    it 'injects an id' do
+      klass.inject_data object, { id: 1 }
+      object.id.should eq 1
+    end
+
+    it 'injects a specified id' do
+      klass.give_id_to object, 2
+      object.id.should eq 2
+    end
+  end
+end

data/spec/perpetuity/mapper_spec.rb

@@ -0,0 +1,51 @@
+require 'perpetuity/mapper'
+
+module Perpetuity
+  describe Mapper do
+    let(:mapper) do
+      Mapper.new do
+      end
+    end
+
+    subject { mapper }
+
+    it { should be_a Mapper }
+
+    it 'has correct attributes' do
+      Mapper.new { attribute :name, String }.attributes.should eq [:name]
+    end
+
+    it 'returns an empty attribute list when no attributes have been assigned' do
+      Mapper.new.attributes.should be_empty
+    end
+
+    it 'can have embedded attributes' do
+      mapper_with_embedded_attrs = Mapper.new { attribute :comments, Array, embedded: true }
+      mapper_with_embedded_attrs.attribute_set[:comments].should be_embedded
+    end
+
+    its(:mapped_class) { should eq Object }
+
+    context 'with unserializable attributes' do
+      let(:unserializable_object) { 1.to_c }
+      let(:serialized_attrs) do
+        [ Marshal.dump(unserializable_object) ]
+      end
+
+      it 'serializes attributes' do
+        object = Object.new
+        object.stub(sub_objects: [unserializable_object])
+        mapper.attribute :sub_objects, Array, embedded: true
+        mapper.attributes_for(object)[:sub_objects].should eq serialized_attrs
+      end
+
+      describe 'unserializes attributes' do
+        let(:comments) { mapper.unserialize(serialized_attrs)  }
+        subject { comments.first }
+
+        it { should be_a Complex }
+        it { should eq unserializable_object }
+      end
+    end
+  end
+end

data/spec/perpetuity/mongodb/query_attribute_spec.rb

@@ -0,0 +1,42 @@
+require 'perpetuity/mongodb/query_attribute'
+
+module Perpetuity
+  describe MongoDB::QueryAttribute do
+    let(:attribute) { MongoDB::QueryAttribute.new :attribute_name }
+    subject { attribute }
+
+    its(:name) { should == :attribute_name }
+
+    it 'checks for equality' do
+      (attribute == 1).should be_a MongoDB::QueryExpression
+    end
+
+    it 'checks for less than' do
+      (attribute < 1).should be_a MongoDB::QueryExpression
+    end
+
+    it 'checks for <=' do
+      (attribute <= 1).should be_a MongoDB::QueryExpression
+    end
+
+    it 'checks for greater than' do
+      (attribute > 1).should be_a MongoDB::QueryExpression
+    end
+
+    it 'checks for >=' do
+      (attribute >= 1).should be_a MongoDB::QueryExpression
+    end
+
+    it 'checks for inequality' do
+      attribute.not_equal?(1).should be_a MongoDB::QueryExpression
+    end
+
+    it 'checks for regexp matches' do
+      (attribute =~ /value/).should be_a MongoDB::QueryExpression
+    end
+
+    it 'checks for inclusion' do
+      (attribute.in [1, 2, 3]).should be_a MongoDB::QueryExpression
+    end
+  end
+end

data/spec/perpetuity/mongodb/query_expression_spec.rb

@@ -0,0 +1,49 @@
+require 'perpetuity/mongodb/query_expression'
+
+module Perpetuity
+  describe MongoDB::QueryExpression do
+    let(:expression) { MongoDB::QueryExpression.new :attribute, :equals, :value }
+    subject { expression }
+
+    describe 'translation to Mongo expressions' do
+      it 'equality expression' do
+        expression.to_db.should == { attribute: :value }
+      end
+
+      it 'less-than expression' do
+        expression.comparator = :less_than
+        expression.to_db.should == { attribute: { '$lt' => :value } }
+      end
+
+      it 'less-than-or-equal-to expression' do
+        expression.comparator = :lte
+        expression.to_db.should == { attribute: { '$lte' => :value } }
+      end
+
+      it 'greater-than expression' do
+        expression.comparator = :greater_than
+        expression.to_db.should == { attribute: { '$gt' => :value } }
+      end
+
+      it 'greater-than-or-equal-to expression' do
+        expression.comparator = :gte
+        expression.to_db.should == { attribute: { '$gte' => :value } }
+      end
+
+      it 'not-equal' do
+        expression.comparator = :not_equal
+        expression.to_db.should == { attribute: { '$ne' => :value } }
+      end
+
+      it 'checks for inclusion' do
+        expression.comparator = :in
+        expression.to_db.should == { attribute: { '$in' => :value } }
+      end
+
+      it 'checks for regexp matching' do
+        expression.comparator = :matches
+        expression.to_db.should == { attribute: :value }
+      end
+    end
+  end
+end

data/spec/perpetuity/mongodb/query_spec.rb

@@ -0,0 +1,37 @@
+require 'perpetuity/mongodb/query'
+
+module Perpetuity
+  describe MongoDB::Query do
+    let(:query) { MongoDB::Query }
+
+    it 'generates Mongo equality expressions' do
+      query.new{name == 'Jamie'}.to_db.should == {name: 'Jamie'}
+    end
+
+    it 'generates Mongo less-than expressions' do
+      query.new{quantity < 10}.to_db.should == {quantity: { '$lt' => 10}}
+    end
+
+    it 'generates Mongo less-than-or-equal expressions' do
+      query.new{quantity <= 10}.to_db.should == {quantity: { '$lte' => 10}}
+    end
+
+    it 'generates Mongo greater-than expressions' do
+      query.new{quantity > 10}.to_db.should == {quantity: { '$gt' => 10}}
+    end
+
+    it 'generates Mongo greater-than-or-equal expressions' do
+      query.new{quantity >= 10}.to_db.should == {quantity: { '$gte' => 10}}
+    end
+
+    it 'generates Mongo inequality expressions' do
+      query.new{name.not_equal? 'Jamie'}.to_db.should == {
+        name: {'$ne' => 'Jamie'}
+      }
+    end
+
+    it 'generates Mongo regexp expressions' do
+      query.new{name =~ /Jamie/}.to_db.should == {name: /Jamie/}
+    end
+  end
+end

data/spec/perpetuity/mongodb_spec.rb

@@ -0,0 +1,91 @@
+require 'perpetuity/mongodb'
+
+module Perpetuity
+  describe MongoDB do
+    let(:mongo) { MongoDB.new db: 'perpetuity_gem_test' }
+    let(:klass) { String }
+    subject { mongo }
+
+    it 'is not connected when instantiated' do
+      mongo.should_not be_connected
+    end
+
+    it 'connects to its host' do
+      connection = double('connection')
+      Mongo::Connection.stub(new: connection)
+      mongo.connect
+      mongo.should be_connected
+      mongo.connection.should == connection
+    end
+
+    it 'connects automatically when accessing the database' do
+      mongo.database
+      mongo.should be_connected
+    end
+
+    describe 'initialization params' do
+      let(:host)      { double('host') }
+      let(:port)      { double('port') }
+      let(:db)        { double('db') }
+      let(:pool_size) { double('pool size') }
+      let(:username)  { double('username') }
+      let(:password)  { double('password') }
+      let(:mongo) do
+        MongoDB.new(
+          host:      host,
+          port:      port,
+          db:        db,
+          pool_size: pool_size,
+          username:  username,
+          password:  password
+        )
+      end
+      subject { mongo }
+
+      its(:host)      { should == host }
+      its(:port)      { should == port }
+      its(:db)        { should == db }
+      its(:pool_size) { should == pool_size }
+      its(:username)  { should == username }
+      its(:password)  { should == password }
+    end
+
+    it 'uses the selected database' do
+      mongo.database.name.should == 'perpetuity_gem_test'
+    end
+
+    it 'removes all documents from a collection' do
+      mongo.insert klass, {}
+      mongo.delete_all klass
+      mongo.count(klass).should == 0
+    end
+
+    it 'counts the documents in a collection' do
+      mongo.delete_all klass
+      3.times do
+        mongo.insert klass, {}
+      end
+      mongo.count(klass).should == 3
+    end
+
+    it 'gets the first document in a collection' do
+      value = {value: 1}
+      mongo.insert klass, value
+      mongo.first(klass)[:hypothetical_value].should == value['value']
+    end
+
+    it 'gets all of the documents in a collection' do
+      values = [{value: 1}, {value: 2}]
+      mongo.should_receive(:retrieve).with(Object, {}, {})
+           .and_return(values)
+      mongo.all(Object).should == values
+    end
+
+    it 'retrieves by id if the id is a string' do
+      time = Time.now.utc
+      id = mongo.insert Article, {inserted: time}
+      objects = mongo.retrieve(Article, id: id.to_s).to_a
+      objects.map{|i| i["inserted"].to_f}.first.should be_within(0.001).of time.to_f
+    end
+  end
+end

data/spec/perpetuity/retrieval_spec.rb

@@ -0,0 +1,58 @@
+require 'perpetuity/retrieval'
+
+module Perpetuity
+  describe Retrieval do
+    let(:data_source) { double('data_source') }
+    let(:retrieval) { Perpetuity::Retrieval.new Object, {}, data_source }
+    subject { retrieval }
+
+    it "sorts the results" do
+      sorted = retrieval.sort(:name)
+      sorted.sort_attribute.should == :name
+    end
+
+    it "reverses the sort order of the results" do
+      sorted = retrieval.sort(:name).reverse
+      sorted.sort_direction.should == :descending
+    end
+    
+    it "limits the result set" do
+      retrieval.limit(1).result_limit.should == 1
+    end
+
+    it 'indicates whether it includes a specific item' do
+      subject.stub(to_a: [1])
+      subject.should include 1
+    end
+
+    it 'can be empty' do
+      retrieval.stub(to_a: [])
+      retrieval.should be_empty
+    end
+
+    describe 'pagination' do
+      let(:paginated) { retrieval.page(2) }
+      it 'paginates data' do
+        paginated.result_page.should == 2
+      end
+
+      it 'defaults to 20 items per page' do
+        paginated.quantity_per_page.should == 20
+      end
+
+      it 'sets the number of items per page' do
+        paginated.per_page(50).quantity_per_page.should == 50
+      end
+    end
+
+    it 'retrieves data from the data source' do
+      return_data = { id: 0, a: 1, b: 2 }
+      options = { attribute: nil, direction: nil, limit: nil, page: nil }
+      data_source.should_receive(:retrieve).with(Object, {}, options).
+                  and_return([return_data])
+      results = retrieval.to_a
+
+      results.map(&:id).should == [0]
+    end
+  end
+end

data/spec/perpetuity/validations/length_spec.rb

@@ -0,0 +1,53 @@
+require 'perpetuity/validations/length'
+
+module Perpetuity
+  module Validations
+    describe Length do
+      let(:length) { Length.new :to_s, {}}
+
+      describe 'minimum length' do
+        before { length.at_least 4 }
+
+        it 'invalidates' do
+          length.pass?('abc').should be false
+        end
+
+        it 'validates' do
+          length.pass?('abcd').should be true
+        end
+      end
+
+      describe 'maximum length' do
+        before { length.at_most 4 }
+
+        it 'validates' do
+          length.pass?('abcd').should be true
+        end
+
+        it 'invalidates' do
+          length.pass?('abcde').should be false
+        end
+      end
+
+      describe 'ranges' do
+        before { length.between 4..5 }
+
+        it 'invalidates values too short' do
+          length.pass?('abc').should be false
+        end
+
+        it 'validates lengths at the low end' do
+          length.pass?('abcd').should be true
+        end
+
+        it 'validates lengths at the high end' do
+          length.pass?('abcde').should be true
+        end
+
+        it 'invalidates values too long' do
+          length.pass?('abcdef').should be false
+        end
+      end
+    end
+  end
+end