tyrion 0.2.0 → 0.3.0

data/README.markdown

@@ -16,6 +16,8 @@ Each file is an array of homogeneous documents (much like collections).
 ```
 
 ### Document
+It supports validations from ActiveModel::Validations.
+
 ``` ruby
   class Post
     include Tyrion::Document
@@ -23,18 +25,19 @@ Each file is an array of homogeneous documents (much like collections).
     field :title
     field :body
     field :rank
+    
+    validates_presence_of :title, :body, :rank
   end
 ```
 
 ### Persistence
 #### Save
 ``` ruby
-  post = Post.create :title => "Hello", :body => "Hi there, ..."
+  post = Post.new :title => "Hello", :body => "Hi there, ..."
   post.save
 ```
 ``` ruby
-  # Insta-save with !
-  Post.create! :title => "Hello", :body => "Hi there, ..."
+  Post.create :title => "Hello", :body => "Hi there, ..."
 ```
 
 #### Delete
@@ -43,22 +46,57 @@ Each file is an array of homogeneous documents (much like collections).
   post.delete
 ```
 ``` ruby
-  Post.delete_all # You get the idea
+  Post.delete_all
 ```
+
+### Querying
+Chainable querying is allowed.  
+First called is first executed and an enumerable is returned.
+
+`where`: all matching documents
+
 ``` ruby
-  Post.delete :title => /^Hello/
+  Post.where :title => 'Hello', :rank => 3
 ```
 
-### Querying
-`find_by_attribute`: just the first match
+`limit`: limits returned documents
 
 ``` ruby
-  Post.find_by_title "Hello"
-  Post.find_by_body /^Hi there/i
+  Post.limit(5)
 ```
 
-`where`: all matching documents
+`skip`: offsets returned documents
+
+``` ruby
+  Post.skip(5)
+```
+
+`asc`: sorts ascendingly according to passed keys
 
 ``` ruby
-  Post.where :title => /^Hello/, :rank => 3
-```
+  Post.asc(:rank, :title)
+```
+
+`desc`: sorts discendingly according to passed keys
+
+``` ruby
+  Post.desc(:rank, :title)
+```
+
+#### Fancy chains
+``` ruby
+  Post.where(:rank => 5).desc(:title, :body).skip(5).limit(5)
+```
+And since it delegates to an enumerable...
+
+``` ruby
+  Post.where(:rank => 5).count
+  Post.where(:rank => 10).each{ |doc| ... }
+```
+
+## ToDos
+
+* Modifiers on criterias (delete, update, ...)
+* Default values for attributes
+* Embedded documents
+* Keys (_id?)

data/lib/tyrion.rb

@@ -6,9 +6,9 @@ require 'tyrion/connection'
 
 require 'tyrion/attributes'
 require 'tyrion/persistence'
+require 'tyrion/criteria'
 require 'tyrion/querying'
 require 'tyrion/storage'
-require 'tyrion/components'
 require 'tyrion/validations'
 
 require 'tyrion/document'

data/lib/tyrion/attributes.rb

@@ -1,42 +1,54 @@
 module Tyrion
-  module Attributes    
+  module Attributes
     def self.included(receiver)
       receiver.extend ClassMethods
       receiver.send :include, InstanceMethods
     end
-    
+
     module ClassMethods
       def field(name, type = String)
         name = name.to_s
-        
+
         define_method("#{name}"){ attributes[name] }
         define_method("#{name}="){ |value| attributes[name] = value }
       end
     end
-    
+
     module InstanceMethods
       attr_reader :attributes
-      
+
+      def initialize(attrs = {})
+        @attributes = attrs.stringify_keys
+      end
+
       def method_missing(name, *args)
         attr = name.to_s
         return super unless attributes.has_key? attr.gsub("=", "")
-        
+
         if attr =~ /=$/
           write_attribute(attr[0..-2], args.shift || raise("BOOM"))
         else
           read_attribute(attr)
         end
       end
-      
-      protected
-      
+
+      # Checks for equality.
+      # @example Compare two objects
+      #   object == other
+      # @param [Object] The other object to compare with
+      # @return [true, false] True if objects' attributes are the same, false otherwise.
+      def == other
+        return false unless other.is_a?(Tyrion::Document)
+        other.attributes == attributes
+      end
+
       def read_attribute(name)
         attributes[name.to_s]
       end
-      
+
       def write_attribute(name, arg)
         attributes[name.to_s] = arg
       end
     end
   end
-end
+end

data/lib/tyrion/connection.rb

@@ -1,11 +1,11 @@
 module Tyrion
   module Connection
     extend self
-    
+
     def path= folder_path
       @folder_path = folder_path
     end
-    
+
     def path
       @folder_path || raise("No path set!")
     end

data/lib/tyrion/criteria.rb

@@ -0,0 +1,94 @@
+module Tyrion
+  class Criteria
+    include Enumerable
+
+    attr_reader :klass
+
+    def initialize(storage, klass)
+      @storage = storage
+      @klass = klass
+      @constraints = []
+    end
+
+    def all
+      self
+    end
+
+    def where(params = {})
+      @constraints << [:where, params]
+      self
+    end
+
+    def limit(n)
+      @constraints << [:limit, n]
+      self
+    end
+
+    def skip(n)
+      @constraints << [:skip, n]
+      self
+    end
+
+    def asc(*keys)
+      @constraints << [:sort, [keys, true]]
+      self
+    end
+
+    def desc(*keys)
+      @constraints << [:sort, [keys, false]]
+      self
+    end
+
+    def inspect
+      "<Criteria:0x#{__id__.to_s(16)}\n" +
+      " Model:#{@klass.capitalize},\n" +
+      " Constraints: " + @constraints.inspect[1..-2] + ">"
+    end
+
+    def each(&block)
+      fetch_documents if not @data
+      @data.each{ |c| block.call(c) }
+    end
+
+    def last
+      to_a.last
+    end
+
+    private
+
+    def fetch_documents
+      @data = @storage.dup
+
+      @constraints.each do |con|
+        type, args = con
+
+        case type
+        when :where
+          @data = @data.select do |doc|
+            args.each_pair.map do |k, v|
+              doc.read_attribute(k) == v
+            end.inject(&:&)
+          end
+        when :limit
+          @data = @data.take(args)
+        when :skip
+          @data = Array(@data[args..-1])
+        when :sort
+          keys, dir = args
+          if @data.respond_to? :sort_by!
+            @data.sort_by! do |doc|
+              keys.map{|s| doc.read_attribute(s) }
+            end
+          else
+            @data.sort! do |a, b|
+              first = keys.map{|s| a.read_attribute(s) }
+              second = keys.map{|s| b.read_attribute(s) }
+              first <=> second
+            end
+          end
+          @data.reverse! unless dir
+        end
+      end
+    end
+  end
+end

data/lib/tyrion/document.rb

@@ -1,42 +1,31 @@
 module Tyrion
-  
+
   # Base module to persist objects.
   module Document
     def self.included(receiver)
       receiver.extend ClassMethods
-      
+
       receiver.class_eval do
-        include Tyrion::Components
+        include Tyrion::Attributes
+        include Tyrion::Querying
+        include Tyrion::Validations
+        include Tyrion::Persistence
+        include Tyrion::Storage
         include InstanceMethods
       end
     end
-    
+
     module ClassMethods
-      protected
-      
+      private
+
       def klass_name
         to_s.downcase
       end
     end
-    
+
     module InstanceMethods
-      
-      # Checks for equality.
-      # @example Compare two objects
-      #   object == other
-      # @param [Object] The other object to compare with
-      # @return [true, false] True if objects' attributes are the same, false otherwise.
-      def == other
-        other.attributes == attributes
-      end
-      
-      def initialize(attrs = {})
-        @attributes = attrs.stringify_keys
-        @new_document = true
-      end
-      
       private
-      
+
       def klass_name
         self.class.to_s.downcase
       end

data/lib/tyrion/persistence.rb

@@ -4,47 +4,43 @@ module Tyrion
       receiver.extend ClassMethods
       receiver.send :include, InstanceMethods
     end
-    
+
     module ClassMethods
-      def create attributes = {}
-        new(attributes).tap do |n|
-          attributes.each_pair{ |k, v| n.send(:write_attribute, k.to_s, v) }
-        end
-      end
-      
-      def create! attributes = {}
-        create(attributes).tap{ |doc| doc.save }
+      def create(*args)
+        new(*args).tap{ |doc| doc.save }
       end
-      
+
       def delete_all
         storage[klass_name].clear
-      end
-      
-      def delete attributes = {}
-        where(attributes).each(&:delete)
+        save_storage(klass_name)
       end
     end
-    
-    module InstanceMethods      
+
+    module InstanceMethods
+      def initialize(*args)
+        super(*args)
+        @persisted = false
+      end
+
       def save
         if valid?
           self.class.storage[klass_name] << self
           self.class.save_storage klass_name
-          @new_document = false
-          
+          @persisted = true
+
           true
         else
           false
         end
       end
-      
+
       def delete
         self.class.storage[klass_name].delete_if{ |doc| self == doc }
-        self.class.save_storage klass_name
+        self.class.save_storage(klass_name)
       end
-      
-      def new_document?
-        @new_document
+
+      def persisted?
+        @persisted
       end
     end
   end

data/lib/tyrion/querying.rb

@@ -1,50 +1,26 @@
+require 'forwardable'
+
 module Tyrion
   module Querying
     def self.included(receiver)
       receiver.extend ClassMethods
     end
-    
+
     module ClassMethods
-      def all
-        storage[klass_name].dup
+      extend Forwardable
+
+      def_delegators :new_criteria, :all, :where, :first, :last, :limit,
+                                    :skip, :asc, :desc
+
+      def count
+        storage[klass_name].count
       end
-      
-      def where attributes = {}
-        all.map do |doc|
-          match = attributes.each_pair.map do |k, v|
-            operator = if v.is_a? Regexp
-              :=~
-            else
-              :==
-            end
-            
-            true if doc.send(:read_attribute, k.to_s).send(operator, v)
-          end.compact
-          
-          doc if match.count == attributes.count
-        end.compact
-      end
-      
-      def method_missing(method, *args)
-        if method.to_s =~ /^find_by_(.+)$/
-          attr = $1
-          arg = args.shift || raise("Provide at least one argument!")
-          
-          all.each do |doc|
-            operator = if arg.is_a? Regexp
-              :=~
-            else
-              :==
-            end
-            
-            return doc if doc.attributes[attr].send(operator, arg)
-          end
-          
-          nil
-        else
-          super
-        end
+
+      private
+
+      def new_criteria
+        Criteria.new(storage[klass_name], klass_name)
       end
     end
   end
-end
+end

data/lib/tyrion/storage.rb

@@ -1,38 +1,38 @@
 module Tyrion
-  module Storage    
+  module Storage
     def self.included(receiver)
       receiver.extend ClassMethods
-      
-      receiver.reload unless receiver == Tyrion::Components
+
+      receiver.reload unless receiver == Tyrion::Document
     end
-    
+
     module ClassMethods
       def storage
         @storage ||= {}
       end
-    
+
       def reload
         klass_name = to_s.downcase
         path = klass_filepath klass_name
-        
+
         if File.exists?(path)
           raw_file = File.read(path)
-          storage[klass_name] = MultiJson.decode(raw_file).map{ |doc| create doc }
+          storage[klass_name] = MultiJson.decode(raw_file).map{ |doc| new(doc) }
         else
           storage[klass_name] = []
         end
       end
-    
+
       def save_storage klass_name
         path = klass_filepath klass_name
-        
+
         File.open(path, 'w') do |f|
           f.puts MultiJson.encode(storage[klass_name].map &:attributes)
         end
       end
-      
+
       protected
-      
+
       def klass_filepath klass_name
         File.join(Connection.path, klass_name + ".json")
       end

data/lib/tyrion/version.rb

@@ -1,3 +1,3 @@
 module Tyrion #:nodoc:
-  VERSION = '0.2.0'
+  VERSION = '0.3.0'
 end

metadata

@@ -1,7 +1,7 @@
 --- !ruby/object:Gem::Specification
 name: tyrion
 version: !ruby/object:Gem::Version
-  version: 0.2.0
+  version: 0.3.0
   prerelease: 
 platform: ruby
 authors:
@@ -9,11 +9,11 @@ authors:
 autorequire: 
 bindir: bin
 cert_chain: []
-date: 2011-12-29 00:00:00.000000000 Z
+date: 2012-01-01 00:00:00.000000000 Z
 dependencies:
 - !ruby/object:Gem::Dependency
   name: multi_json
-  requirement: &70281257801860 !ruby/object:Gem::Requirement
+  requirement: &70231390612120 !ruby/object:Gem::Requirement
     none: false
     requirements:
     - - ! '>='
@@ -21,10 +21,10 @@ dependencies:
         version: '0'
   type: :runtime
   prerelease: false
-  version_requirements: *70281257801860
+  version_requirements: *70231390612120
 - !ruby/object:Gem::Dependency
   name: json_pure
-  requirement: &70281257801040 !ruby/object:Gem::Requirement
+  requirement: &70231390611420 !ruby/object:Gem::Requirement
     none: false
     requirements:
     - - ! '>='
@@ -32,10 +32,10 @@ dependencies:
         version: '0'
   type: :runtime
   prerelease: false
-  version_requirements: *70281257801040
+  version_requirements: *70231390611420
 - !ruby/object:Gem::Dependency
   name: activemodel
-  requirement: &70281257816640 !ruby/object:Gem::Requirement
+  requirement: &70231390610660 !ruby/object:Gem::Requirement
     none: false
     requirements:
     - - ~>
@@ -43,10 +43,10 @@ dependencies:
         version: 3.1.0
   type: :runtime
   prerelease: false
-  version_requirements: *70281257816640
+  version_requirements: *70231390610660
 - !ruby/object:Gem::Dependency
   name: rspec
-  requirement: &70281257815820 !ruby/object:Gem::Requirement
+  requirement: &70231390626300 !ruby/object:Gem::Requirement
     none: false
     requirements:
     - - ! '>='
@@ -54,10 +54,21 @@ dependencies:
         version: '0'
   type: :development
   prerelease: false
-  version_requirements: *70281257815820
+  version_requirements: *70231390626300
+- !ruby/object:Gem::Dependency
+  name: pry
+  requirement: &70231390625480 !ruby/object:Gem::Requirement
+    none: false
+    requirements:
+    - - ! '>='
+      - !ruby/object:Gem::Version
+        version: '0'
+  type: :development
+  prerelease: false
+  version_requirements: *70231390625480
 - !ruby/object:Gem::Dependency
   name: simplecov
-  requirement: &70281257814980 !ruby/object:Gem::Requirement
+  requirement: &70231390624840 !ruby/object:Gem::Requirement
     none: false
     requirements:
     - - ! '>='
@@ -65,7 +76,7 @@ dependencies:
         version: '0'
   type: :development
   prerelease: false
-  version_requirements: *70281257814980
+  version_requirements: *70231390624840
 description: Tyrion's goal is to provide a fast (as in _easy to setup_) and dirty
   unstructured document store.
 email:
@@ -75,8 +86,8 @@ extensions: []
 extra_rdoc_files: []
 files:
 - lib/tyrion/attributes.rb
-- lib/tyrion/components.rb
 - lib/tyrion/connection.rb
+- lib/tyrion/criteria.rb
 - lib/tyrion/document.rb
 - lib/tyrion/persistence.rb
 - lib/tyrion/querying.rb

data/lib/tyrion/components.rb

@@ -1,13 +0,0 @@
-module Tyrion
-  module Components
-    def self.included(receiver)
-      receiver.class_eval do
-        include Tyrion::Attributes
-        include Tyrion::Validations
-        include Tyrion::Persistence
-        include Tyrion::Querying
-        include Tyrion::Storage
-      end
-    end
-  end
-end