mementus 0.1.2 → 0.1.3

checksums.yaml

@@ -1,15 +1,15 @@
 ---
 !binary "U0hBMQ==":
   metadata.gz: !binary |-
-    N2I2NmZkNjY1MGMwYWE0ZGI3ZmRmZjY0OGFlODI1YWQyZjhkMTU5OA==
+    MjM0MTczODAxNTlkNmQ3ODYwMzdlYWEzNzNjMGIyNTE1YWQ2NWZiMw==
   data.tar.gz: !binary |-
-    NDNhZGVhZjZlMWE5NzJmYmY5YjM0ODIxODA0ZDViZWZiNjZmNGExZg==
+    YTgyZDJmZjFlMTY0NjUwODNkMDI0OWZjYTIzYzBjYjZhOTUzMTc0Yw==
 SHA512:
   metadata.gz: !binary |-
-    OWYyMGY5NDc1ODdkNGQ2ZmQ5ZDExZTI2ODA4MjUxZWYyM2RmYmM5NTE3ZTAx
-    NmQ4ODNjZTgxODQyZjdkZjFhYjMzNTQ4YTA2MDQ0YTU4NGY1MjVmMWI2NzZk
-    NTQ4ZjBiNGZmN2I0ODYxN2U2N2RjZDdmZWE3ZTM2YTNhZGJhMGQ=
+    YjEwYWFhNmIwYWFhYjM3NWNmNDg2ZjY4MTMxZWI5ZDc0M2ZjOTk1ZDFkY2Mw
+    YzA0YTYzOTIyYTI4ODViY2U0ZDRhNTA4NDQ2YzIwOTA3ZTYxOWFjYmNhNmEz
+    OTcwYjFiODNhYjhmMjI5YTRlNDJlZDc4NjA3ODIwZGUyMWI3YWM=
   data.tar.gz: !binary |-
-    NTlhZTVmODY1OGQ1MDhmYzU3MWE1NWM0NWUyMmM1MTIwMjY1YmNjZDkyMGJk
-    YzU4MTk2ODA5MGYyMWRlODk4YjZkOGFlZTkzMGNjZGQyNGI3MGI3M2I2NTI4
-    NzFkMGYzNDA1ODFkMTczMGMxOTA0MzdjYTU1MmEwMTI0OTIzMTU=
+    MGM2ODcxNzYxMmViMjI1YjM5NjMyZmNjZDNiNDVhOWJhMjg4N2FmMjk4YTMz
+    ZjY4Y2QyNzgwZGFlODJlZjk5NTA5MjQyZTMzZTIxODFjMTdmZmIwZWM4MDFm
+    NTdlZDEzYTg5ZWU1M2RiZjAzZDQxMmRlOTY3M2RlOWJhYzUyNzg=

data/README.md

@@ -2,24 +2,22 @@
 
 [![Build Status](https://travis-ci.org/maetl/mementus.svg?branch=master)](https://travis-ci.org/maetl/mementus)
 
-Proof of concept for a toy ORM that combines some aspects of the ActiveRecord API with an in-memory query model based on the Axiom relational algebra API.
+Mementus is a transient ORM for creating and querying in-memory object models.
 
 ## Installation
 
-Add this line to your application's Gemfile:
+Add this line to your application's Gemfile and `bundle` or `bundle update`:
 
     gem 'mementus'
 
-And then execute:
-
-    $ bundle
-
-Or install it yourself as:
+Or install with your local Rubygems:
 
     $ gem install mementus
 
 ## Usage
 
+### Defining model classes
+
 To define model classes, inherit from the `Mementus::Model` base class and add attributes using the [Virtus API](https://github.com/solnic/virtus):
 
 ```ruby
@@ -29,6 +27,8 @@ class Book < Mementus::Model
 end
 ```
 
+### Creating objects
+
 Create new instances by passing data through the constructor or assigning attributes directly:
 
 ```ruby
@@ -53,18 +53,43 @@ book3 = Book.new(
 book3.create
 ```
 
-The query API is currently being worked on. Right now to test it out, you can access the relational collection for each model through the `collection` method, and execute basic matching queries using the `where` method:
-
-```ruby
-Book.collection.count
+### Matching queries
 
-Book.collection.first
+Basic match queries can be constructed by passing a predicate hash to the `where` method:
 
+```ruby
 Book.where(author: "Doris Lessing")
 
 Book.where(title: "Crash")
 ```
 
+### Scoped queries
+
+Reusable query shortcuts can be constructed on the model class by defining a `scope`:
+
+```ruby
+class Book < Mementus::Model
+  attribute :title, String
+  attribute :author, String
+  attribute :genre, String
+  scope :scifi, genre: 'scifi'
+  scope :romance, genre: 'romance'
+end 
+```
+
+These defined scopes become class methods on the model:
+
+```ruby
+scifi_books = Book.scifi
+romance_books = Book.romance
+```
+
+## Roadmap
+
+- 0.2: Query API
+- 0.3: Relationships API
+- 0.4: Value objects
+
 ## Contributing
 
 1. Fork it

data/lib/mementus/model.rb

@@ -1,6 +1,5 @@
 require 'virtus'
 require 'axiom-memory-adapter'
-require 'mini_cache'
  
 module Mementus
  
@@ -9,7 +8,12 @@ module Mementus
   # relational algebra API.
   #
   class Model
- 
+
+    def self.inherited(concrete_model)
+      concrete_model.send(:include, Virtus.model)
+      concrete_model.send(:extend, Relation::ClassMethods)
+    end
+
     @@local_storage = nil
     @@model_registry = {}
  
@@ -46,10 +50,6 @@ module Mementus
       tuple
     end
  
-    def self.inherited(concrete_model)
-      concrete_model.send(:include, Virtus.model)
-    end
- 
     # Create only writes to memory. It's required in order to
     # index the object's attributes in the query model.
     #
@@ -85,46 +85,19 @@ module Mementus
       @@local_storage[name_to_sym]
     end
 
-    def self.all
-      self.collection.inject([]) do |list, relation|
-        list << self.cache_get(relation[:__cache_key])
+    # TODO: fix incomplete scope chaining
+    def self.scope(name, conditions)
+      if conditions.is_a? Hash
+        scope_method = lambda { self.where(conditions) }
+      elsif conditions.is_a? Proc
+        scope_method = conditions
       end
-    end
- 
-    # The where operation restricts the collection based on the
-    # passed in constraints.
-    #
-    # Pass in a key-value hash to restrict based on matching attributes by equality.
-    #
-    # Pass in a block to construct a more specialised predicate match.
-    # 
-    def self.where(constraints)
-      self.collection.restrict(constraints).inject([]) do |list, relation|
-        list << self.cache_get(relation[:__cache_key])
-      end
-    end
 
-    # Order the collection by attribute and direction
-    # TODO: pass relations as scopes
-    def self.order(constraints)
-      ordered_relations = self.collection.sort_by do |relation|
-        constraints.keys.inject([]) do |list, constraint|
-          direction = constraints[constraint].to_sym
-          direction = :asc unless direction == :desc
-          list << relation.send(constraint.to_sym).send(direction)
-        end
-      end
-      self.materialize(ordered_relations)
+      define_singleton_method(name, &scope_method)
     end
 
     private
 
-    def self.materialize(collection)
-      collection.inject([]) do |list, relation|
-        list << self.cache_get(relation[:__cache_key])
-      end
-    end
-
     def self.cache
       @@cache ||= {}
     end

data/lib/mementus/relation.rb

@@ -0,0 +1,56 @@
+module Mementus
+  module Relation
+    module ClassMethods
+
+      def where(constraints)
+        Query.new(self.collection, self.cache).where(constraints)
+      end
+
+      def all
+        Query.new(self.collection, self.cache).all
+      end
+
+      def order(constraints)
+        Query.new(self.collection, self.cache).order(constraints)
+      end
+
+    end
+
+    # Chainable query object that delegates to the given relation.
+    class Query
+
+      def initialize(relation, cache)
+        @relation = relation
+        @cache = cache
+      end
+
+      # Filters the collection based on the given constraints.
+      #
+      # - Pass in a key-value hash to filter based on matching attributes by equality.
+      # - Pass in a block to construct a more specialised predicate match.
+      def where(constraints)
+        Query.new(@relation.restrict(constraints), @cache)
+      end
+
+      # Order the collection by attribute and direction
+      def order(constraints)
+        ordered_relation = @relation.sort_by do |relation|
+          constraints.keys.inject([]) do |list, constraint|
+            direction = constraints[constraint].to_sym
+            direction = :asc unless direction == :desc
+            list << relation.send(constraint.to_sym).send(direction)
+          end
+        end
+        Query.new(ordered_relation, @cache)
+      end
+
+      # Materializes the relation to an array of model objects.
+      def all
+        @relation.inject([]) do |list, relation|
+          list << @cache[relation[:__cache_key]]
+        end
+      end
+
+    end
+  end
+end

data/lib/mementus/version.rb

@@ -1,3 +1,3 @@
 module Mementus
-  VERSION = "0.1.2"
+  VERSION = "0.1.3"
 end

data/lib/mementus.rb

@@ -2,4 +2,6 @@ require 'virtus'
 require 'axiom-memory-adapter'
 
 require_relative 'mementus/version'
+require_relative 'mementus/relation'
 require_relative 'mementus/model'
+

data/spec/collection_spec.rb

@@ -28,12 +28,13 @@ describe Mementus::Model do
     end
 
     it "finds item by equality match" do
-      expect(Item.where(order: 10).count).to eq 1
-      expect(Item.where(order: 10).first.name).to eq "Item: 9"
+      collection = Item.where(order: 10).all
+      expect(collection.count).to eq 1
+      expect(collection.first.name).to eq "Item: 9"
     end
 
     it "finds items by predicate match" do
-      collection = Item.order(order: :desc)
+      collection = Item.order(order: :desc).all
       expect(collection.count).to eq 20
       expect(collection.first.name).to eq "Item: 19"
       expect(collection.last.name).to eq "Item: 0"

data/spec/scopes_spec.rb

@@ -0,0 +1,30 @@
+require 'spec_helper'
+
+describe Mementus::Model do
+
+  class CuteThing < Mementus::Model
+    attribute :name, String
+    attribute :category, String
+    scope :cats, category: "cats"
+    scope :dogs, category: "dogs"
+  end
+
+  before(:all) do
+    20.times do |i|
+      thing = CuteThing.new
+      thing.name = rand(36**12).to_s(36)
+      thing.category = (i % 2) == 0 ? "dogs" : "cats"
+      thing.create
+    end
+  end
+
+  describe "#scope" do
+
+    it "can execute named scopes" do
+      expect(CuteThing.cats.all.count).to eq 10
+      expect(CuteThing.dogs.all.count).to eq 10
+    end
+
+  end
+
+end

metadata

@@ -1,14 +1,14 @@
 --- !ruby/object:Gem::Specification
 name: mementus
 version: !ruby/object:Gem::Version
-  version: 0.1.2
+  version: 0.1.3
 platform: ruby
 authors:
 - maetl
 autorequire: 
 bindir: bin
 cert_chain: []
-date: 2014-07-07 00:00:00.000000000 Z
+date: 2014-11-10 00:00:00.000000000 Z
 dependencies:
 - !ruby/object:Gem::Dependency
   name: virtus
@@ -95,11 +95,13 @@ files:
 - Rakefile
 - lib/mementus.rb
 - lib/mementus/model.rb
+- lib/mementus/relation.rb
 - lib/mementus/version.rb
 - mementus.gemspec
 - spec/attribute_spec.rb
 - spec/collection_spec.rb
 - spec/mapping_spec.rb
+- spec/scopes_spec.rb
 - spec/spec_helper.rb
 homepage: https://github.com/maetl/mementus
 licenses:
@@ -129,4 +131,5 @@ test_files:
 - spec/attribute_spec.rb
 - spec/collection_spec.rb
 - spec/mapping_spec.rb
+- spec/scopes_spec.rb
 - spec/spec_helper.rb