mattly-exegesis 0.0.10 → 0.2.0

data/LICENSE

@@ -0,0 +1,22 @@
+(The MIT License)
+
+Copyright (c) 2009 Matthew Lyon
+
+Permission is hereby granted, free of charge, to any person obtaining
+a copy of this software and associated documentation files (the
+'Software'), to deal in the Software without restriction, including
+without limitation the rights to use, copy, modify, merge, publish,
+distribute, sublicense, and/or sell copies of the Software, and to
+permit persons to whom the Software is furnished to do so, subject to
+the following conditions:
+
+The above copyright notice and this permission notice shall be
+included in all copies or substantial portions of the Software.
+
+THE SOFTWARE IS PROVIDED 'AS IS', WITHOUT WARRANTY OF ANY KIND,
+EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF
+MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT.
+IN NO EVENT SHALL THE AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY
+CLAIM, DAMAGES OR OTHER LIABILITY, WHETHER IN AN ACTION OF CONTRACT,
+TORT OR OTHERWISE, ARISING FROM, OUT OF OR IN CONNECTION WITH THE
+SOFTWARE OR THE USE OR OTHER DEALINGS IN THE SOFTWARE.

data/README.rdoc

@@ -1,19 +1,63 @@
 = exegesis
 
+by Matthew Lyon <matt@flowerpowered.com>
 * http://github.com/mattly/exegesis
 
-== DESCRIPTION:
+== Description:
 
-An ODM (Object/Document Mapper) for Couchdb. Still very much a work in progress
+A CouchDB ODM (Object/Document Mapper) in Ruby.
 
-== FEATURES/PROBLEMS:
+== Features:
 
-* Encourages Per-"Account" databases. This is both a feature and a problem, since classes cannot know which database to pull from you cannot do f.e. "Article.find('foo')" as Article doesn't know what database to use.
-* Does not provide it's own validators or callbacks. I have a solution in mind for this involving state machines.
+Encourages per-"Account" databases. Actually, does not even currently provide a way to do a 
+"singleton" or global database, however this is planned. Since a given class (say, "Article") 
+cannot know what database it is supposed to get/search from you cannot do classical class-based 
+finders such as "Article.find('value')".
 
-== REQUIREMENTS:
+CouchDB is table-less, and Exegesis's design reflects this. In CouchDB, Documents are retrieved 
+by their unique id, or can be queried from a view function in a design document. Exegesis provides
+tools to aid this. Additionally, since view functions can be used for map/reduce computations against
+your documents, Exegesis helps you get non-document data out of your views.
 
-* Johnson (and Spidermonkey, if you have CouchDB you have Spidermonkey)
+== Examples:
+
+    class Account
+      include Exegesis::Database
+      
+      # declares the existence of a design document named 'articles'
+      # view functions will be loaded from 'views/articles/:viewname/*.js
+      design :articles do
+        docs :by_author
+        docs :at_path
+        docs :tagged_with
+        hash :tags_count, :view => :tagged_with
+      end
+    end
+    
+    @account.articles.by_author('user-mattly')
+    # performs GET '/_design/articles/_view/by_author?key="user-mattly"&include_docs=true&reduce=false'
+    @account.articles.at_path('blog/2009'..'blog/2009/04/04')
+    # transforms the range into startkey/endkey
+    # performs GET '/_design/articles/_view/at_path?startkey="blog/2009"&endkey="blog/2009/04/04"
+    #               &include_docs=true&reduce=false'
+    @account.articles.tags_count('couchdb')
+    # performs GET '/_design/articles/_view/tagged_with?key="couchdb"&group=true'
+    
+    class Article
+      include Exegesis::Document
+      
+      # defines readers, writers for given attributes
+      expose :path, :title, :body, :tags
+      expose :published_at, :writer => false, :as => Time
+      timestamps!
+      
+      # will load the document at the id referenced by doc['author']; does not yet set writer.
+      expose :author, :as => :reference
+    end
+
+== Requirements:
+
+* RestClient
 
 For running the tests:
 

data/VERSION.yml

@@ -1,4 +1,4 @@
 --- 
 :major: 0
-:minor: 0
-:patch: 10
+:minor: 2
+:patch: 0

data/lib/exegesis.rb

@@ -1,43 +1,36 @@
 require 'time'
 require 'pathname'
-
-require 'couchrest'
+require 'restclient'
+require 'json'
 
 $:.unshift File.dirname(__FILE__) unless $:.include?(File.dirname(__FILE__)) || $:.include?(File.expand_path(File.dirname(__FILE__)))
 
+require 'monkeypatches/time'
+
 module Exegesis
-  autoload :Document,   'exegesis/document'
-  autoload :Design,     'exegesis/design'
-  
-  extend self
-  
-  def designs_directory= dir
-    @designs_directory = Pathname.new(dir)
-  end
-  
-  def designs_directory
-    @designs_directory ||= Pathname.new(ENV["PWD"])
-    @designs_directory
-  end
+  autoload :Http,         'exegesis/utils/http'
+
+  autoload :Server,       'exegesis/server'
+  autoload :Database,     'exegesis/database'
+
+  autoload :Model,        'exegesis/model'
+  autoload :Document,     'exegesis/document'
   
-  def design_file name
-    File.read(designs_directory + name)
-  end
+  autoload :Designs,      'exegesis/designs'
+  autoload :Design,       'exegesis/design'
   
-  def database_template= template
-    @db_template = template
-  end
-  
-  def database_template
-    @db_template ||= "http://localhost:5984/%s"
-  end
+  extend self
   
-  def database_for name
-    database_template % name
+  def model_classes
+    @model_classes ||= {}
   end
   
-  def document_classes
-    @document_classes ||= Hash.new(Exegesis::Document)
+  def instantiate hash, database=nil
+    return nil if hash.nil?
+    klass = model_classes[hash['class']]
+    obj = klass.nil? ? hash : klass.new(hash)
+    obj.database = database if obj.respond_to?(:database=)
+    obj
   end
   
 end

data/lib/exegesis/database.rb

@@ -0,0 +1,109 @@
+require 'pathname'
+module Exegesis
+  module Database
+    
+    VALID_NAME_PATTERN = '[-a-z0-9_\$\(\)\+\/]+'
+    
+    def self.included base
+      base.send :attr_accessor, :server, :uri
+      base.send :include, InstanceMethods
+      base.extend ClassMethods
+    end
+    
+    module ClassMethods
+      def designs_directory dir=nil
+        if dir
+          @designs_directory = Pathname.new(dir)
+        else
+          @designs_directory ||= Pathname.new('designs')
+        end
+      end
+      
+      # A hash mapping design names to class names.
+      def designs
+        @designs ||= {}
+      end
+      
+      # declare a design document for this database. Creates a new class and yields a given block to the class to
+      # configure the design document and declare views; See Class methods for Exegesis::Design
+      def design design_name, opts={}, &block
+        klass_name = "#{design_name.to_s.capitalize}Design"
+        klass = const_set(klass_name, Class.new(Exegesis::Design))
+        designs[design_name] = klass
+        klass.design_directory = opts[:directory] || self.designs_directory + design_name.to_s
+        klass.design_name = opts[:name] || design_name.to_s
+        klass.compose_canonical
+        klass.class_eval &block
+        define_method design_name do
+          @designs ||= {}
+          @designs[design_name] ||= klass.new(self)
+        end
+      end
+    end
+    
+    module InstanceMethods
+      # Create a Database adapter for the given server and database name. Will raise 
+      # RestClient::ResourceNotFound if the database does not exist.
+      def initialize server, database_name=nil
+        if database_name.nil?
+          if server.match(/\A(https?:\/\/[-0-9a-z\.]+(?::\d+))\/(#{Exegesis::Database::VALID_NAME_PATTERN})\Z/)
+            @server = Exegesis::Server.new($1)
+            database_name = $2
+          elsif server.match(/\A#{Exegesis::Database::VALID_NAME_PATTERN}\Z/)
+            @server = Exegesis::Server.new #localhost
+            database_name = server
+          else
+            raise "Not a valid database url or name"
+          end
+        else
+          @server = server
+        end
+        @uri = "#{@server.uri}/#{database_name}"
+        @server.get @uri # raise RestClient::ResourceNotFound if the database does not exist
+      end
+      
+      def raw_get id, options={}
+        keys = options.delete(:keys)
+        url = Exegesis::Http.format_url "#{@uri}/#{id}", options
+        if id.match(%r{^_design/.*/_view/.*$}) && keys
+          Exegesis::Http.post url, {:keys => keys}
+        else
+          Exegesis::Http.get url
+        end
+      end
+      
+      # GETs a document with the given id from the database
+      def get id, opts={}
+        Exegesis.instantiate raw_get(id), self
+      end
+      
+      # saves a document or collection thereof
+      def save docs
+        if docs.is_a?(Array)
+          post "_bulk_docs", { 'docs' => docs }
+        else
+          result = docs['_id'].nil? ? post(docs) : put(docs['_id'], docs)
+          if result['ok']
+            docs['_id'] = result['id']
+            docs['_rev'] = result['rev']
+          end
+          docs
+        end
+      end
+      
+      # PUTs the body to the given id in the database
+      def put id, body
+        Exegesis::Http.put "#{@uri}/#{id}", body
+      end
+      
+      # POSTs the body to the database
+      def post url, body={}
+        if body.is_a?(Hash) && body.empty?
+          body = url
+          url = ''
+        end
+        Exegesis::Http.post "#{@uri}/#{url}", body
+      end
+    end
+  end
+end

data/lib/exegesis/design.rb

@@ -1,83 +1,154 @@
-$:.unshift File.dirname(__FILE__)
-require 'design/design_docs'
-
+require 'pathname'
 module Exegesis
   class Design
-    include Exegesis::Design::DesignDocs
+    include Exegesis::Document
     
-    attr_accessor :database
+    def self.design_directory= dir
+      @design_directory = Pathname.new(dir)
+    end
     
-    def initialize(db)
-      @database = db
+    def self.design_directory
+      @design_directory ||= Pathname.new("designs/#{design_name}")
     end
     
-    def self.use_design_doc_name name
-      @design_doc_name = name.to_s
+    def self.design_name= n
+      @design_name = n.to_s
     end
     
-    def self.design_doc_name
-      @design_doc_name ||= name.to_s.sub(/(Design)$/,'').downcase
+    def self.design_name
+      @design_name ||= name.scan(/^(?:[A-Za-z0-9\:]+::)([A-Za-z0-9]+)Design$/).first.first.downcase
     end
     
-    def design_doc_name
-      self.class.design_doc_name
+    def self.compose_canonical
+      Dir[design_directory + 'views' + '**/*.js'].each do |view_func|
+        path = view_func.split('/')
+        func = path.pop.sub(/\.js$/,'')
+        name = path.pop
+        canonical_design['views'][name] ||= {}
+        canonical_design['views'][name][func] = File.read(view_func)
+      end
     end
     
-    def get(id)
-      doc = Exegesis::Document.instantiate database.get(id)
-      doc.database = self.database
-      doc
+    def self.canonical_design
+      @canonical_design ||= {
+        '_id' => "_design/#{design_name}",
+        'views' => {}
+      }
     end
     
-    def parse_opts(opts={})
-      if opts[:key]
-        case opts[:key]
-        when Range
-          range = opts.delete(:key)
-          opts.update({:startkey => range.first, :endkey => range.last})
-        when Array
-          if opts[:key].any?{|v| v.kind_of?(Range) }
-            key = opts.delete(:key)
-            opts[:startkey] = key.map {|v| v.kind_of?(Range) ? v.first : v }
-            opts[:endkey]   = key.map {|v| v.kind_of?(Range) ? v.last : v }
+    def self.view name, default_options={}
+      define_method name do |key, *opts|
+        view name, key, opts.first, default_options
+      end
+    end
+    
+    def self.docs name, default_options={}
+      default_options = {:include_docs => true, :reduce => false}.merge(default_options)
+      define_method name do |*opts|
+        key = opts.shift
+        options = parse_opts key, opts.first, default_options
+        response = call_view name, options
+        ids = []
+        response.inject([]) do |memo, doc|
+          unless ids.include?(doc['id'])
+            ids << doc['id']
+            memo << Exegesis.instantiate(doc['doc'], database)
           end
+          memo
         end
-      elsif opts[:keys] && opts[:keys].empty?
-        opts.delete(:keys)
       end
-
-      opts
     end
     
-    def view view_name, opts={}
-      opts = parse_opts opts
-      return [] unless opts[:key] || opts[:startkey] || opts[:keys] || opts[:all]
-      opts.delete(:all)
-      database.view("#{design_doc_name}/#{view_name}", opts)['rows']
+    def self.hash name, default_options={}
+      default_options = {:group => true}.merge(default_options)
+      view_name = default_options.delete(:view) || name
+      define_method name do |*opts|
+        key = opts.shift
+        options = parse_opts key, opts.first, default_options
+        options.delete(:group) if options[:key]
+        
+        response = call_view view_name, options
+        if response.size == 1 && response.first['key'].nil?
+          response.first['value']
+        else
+          response.inject({}) do |memo, row|
+            if ! memo.has_key?(row['key'])
+              memo[row['key']] = row['value']
+            end
+            memo
+          end
+        end
+      end
     end
     
-    def docs_for view_name, opts={}
-      response = view view_name, opts.update({:include_docs => true})
-      response.map do |doc| 
-        model = Exegesis::Document.instantiate doc['doc']
-        model.database = database
-        model
+    
+    def initialize db
+      begin
+        super db.get("_design/#{design_name}"), db
+      rescue RestClient::ResourceNotFound
+        db.put("_design/#{design_name}", self.class.canonical_design)
+        retry
       end
+      unless self['views'] == self.class.canonical_design['views']
+        self['views'].update(self.class.canonical_design['views'])
+        save
+      end
+    end
+    
+    def view name, key=nil, opts={}
+      call_view name, parse_opts(key, opts)
     end
     
-    def values_for view_name, opts={}
-      response = view view_name, opts
-      response.map {|row| row['value'] }
+    def call_view name, opts={}
+      url = "_design/#{design_name}/_view/#{name}"
+      database.raw_get(url, opts)['rows']
     end
     
-    def keys_for view_name, opts={}
-      response = view view_name, opts
-      response.map {|row| row['key'] }
+    def design_name
+      self.class.design_name
     end
     
-    def ids_for view_name, opts={}
-      response = view view_name, opts
-      response.map {|row| row['id'] }
+    def parse_opts key, opts={}, defaults={}
+      opts = straighten_args key, opts, defaults
+      parse_key opts
+      parse_keys opts
+      parse_range opts
+      opts
+    end
+    
+    private
+    
+    def straighten_args key, opts, defaults
+      opts ||= {}
+      if key.is_a?(Hash)
+        opts = key
+      elsif ! key.nil?
+        opts[:key] = key
+      end
+      defaults.merge(opts)
+    end
+    
+    def parse_key opts
+      if opts[:key]
+        if opts[:key].is_a?(Range)
+          range = opts.delete(:key)
+          opts.update({:startkey => range.first, :endkey => range.last})
+        elsif opts[:key].is_a?(Array) && opts[:key].any?{|v| v.kind_of?(Range) }
+          key = opts.delete(:key)
+          opts[:startkey] = key.map {|v| v.kind_of?(Range) ? v.first : v }
+          opts[:endkey]   = key.map {|v| v.kind_of?(Range) ? v.last : v }
+        end
+      end
+    end
+    
+    def parse_keys opts
+      opts.delete(:keys) if opts[:keys] && opts[:keys].empty?
+    end
+    
+    def parse_range opts
+      if opts[:startkey] || opts[:endkey]
+        raise ArgumentError, "both a startkey and endkey must be specified if either is" unless opts[:startkey] && opts[:endkey]
+      end
     end
     
   end