couch_tomato 0.1.0

data/lib/couch_tomato/database.rb

@@ -0,0 +1,279 @@
+require 'couchrest'
+require 'pp'
+
+module CouchTomato
+  class Database
+
+    class ValidationsFailedError < ::StandardError; end
+
+    # Database
+    class_inheritable_accessor :prefix_string
+    class_inheritable_accessor :database_name
+    class_inheritable_accessor :database_server
+    class_inheritable_accessor :couchrest_db
+    class_inheritable_accessor :views
+
+    self.views = {}
+    self.prefix_string = ''
+
+    def self.database
+      return self.couchrest_db if self.couchrest_db
+      
+      self.prefix_string ||= ''
+
+      tmp_prefix = self.prefix_string + '_'  unless self.prefix_string.empty?
+      tmp_server = self.database_server + '/' unless self.database_server.match(/\/$/)
+      tmp_suffix = '_' + Rails.env  if defined?(Rails)
+
+      self.couchrest_db = CouchRest.database("#{tmp_server}#{tmp_prefix}#{self.database_name}#{tmp_suffix}")
+      begin
+        self.couchrest_db.info
+      rescue RestClient::ResourceNotFound
+        raise "Database '#{tmp_prefix}#{self.database_name}#{tmp_suffix}' does not exist."
+      end
+      
+      self.couchrest_db
+    end
+
+    def self.prefix (name)
+       self.prefix_string =  name || ''
+    end
+    def self.name (name)
+      raise 'You need to provide a database name' if name.nil?
+      self.database_name   = (name.class == Symbol)? name.to_s : name
+    end
+
+    # TODO: specify db=>host mapping in yaml, and allow to differ per environment
+    def self.server (route='http://127.0.0.1:5984/')
+      self.database_server = route
+      
+      # self.prefix_string ||= ''
+      # 
+      # tmp_prefix = self.prefix_string + '_'  unless self.prefix_string.empty?
+      # tmp_server = self.database_server + '/' unless self.database_server.match(/\/$/)
+      # tmp_suffix = '_' + Rails.env  if defined?(Rails)
+      # 
+      # 
+      # self.couchrest_db ||= CouchRest.database("#{tmp_server}#{tmp_prefix}#{self.database_name}#{tmp_suffix}")
+      # begin
+      #   self.couchrest_db.info
+      # rescue RestClient::ResourceNotFound
+      #   raise "Database '#{tmp_prefix}#{self.database_name}#{tmp_suffix}' does not exist."
+      # end
+
+    end
+
+
+    def self.view(name, options={})
+      raise 'A View nemonic must be specified' if name.nil?
+      self.views[name] = {}
+      self.views[name][:design_doc] = !options[:design_doc] ? self.database_name.to_sym : options.delete(:design_doc).to_sym
+      self.views[name][:view_name] = options.delete(:view_name) || name.to_s
+      self.views[name][:model] = options.delete(:model)
+      self.views[name][:couch_options] = options
+    end
+
+    def self.save_document(document)
+      # TODO: Need to place some protected block here to respond to an exception in case trying to save
+      #       a :raw document with an old _rev number
+
+      # return self.couchrest_db.save_doc(document) unless document.respond_to?(:dirty?)
+
+      # return true if document.respond_to?(:dirty?) && !document.dirty?
+
+      if document.new?
+        self.create_document document
+      else
+        self.update_document document
+      end
+    end
+
+    def self.save_document!(document)
+      save_document(document) || raise(ValidationsFailedError.new(document.errors.full_messages))
+    end
+
+    def self.bulk_save(documents)
+      doc_hashes = []
+
+      documents.each do |document|
+        document.run_callbacks :before_validation_on_save
+        document.run_callbacks(document.new? ? :before_validation_on_create : :before_validation_on_update)
+        return unless document.valid?
+        document.run_callbacks :before_save
+        document.run_callbacks(document.new? ? :before_create : :before_update)
+
+        doc_hashes << document.to_hash
+      end
+
+      res = self.couchrest_db.bulk_save(doc_hashes)
+
+      documents.each_with_index do |document, index|
+        is_new = document.new?
+        document._id = res[index]['id'] if is_new
+        document._rev = res[index]['rev']
+        document.run_callbacks :after_save
+        document.run_callbacks(is_new ? :after_create : :after_update)
+      end
+
+      true
+    end
+
+    def self.destroy_document(document)
+      document.run_callbacks :before_destroy
+      document._deleted = true
+      self.database.delete_doc document.to_hash
+      document.run_callbacks :after_destroy
+      document._id = nil
+      document._rev = nil
+    end
+
+    def self.load_document(id, options ={})
+      raise "Can't load a document without an id (got nil)" if id.nil?
+
+      begin
+        # json = self.couchrest_db.get(id)
+        # instance = Class.const_get(json['ruby_class']).json_create json
+        # # instance.database = self
+        # instance
+        json = self.database.get(id)
+        if options[:model] == :raw || !json['ruby_class']
+          {}.merge(json)
+        else
+          klass = class_from_string(json['ruby_class'])
+          instance = klass.json_create json
+          instance
+        end
+      rescue(RestClient::ResourceNotFound) #'Document not found'
+        nil
+      end
+    end
+
+    def self.inspect
+      super
+      puts 'Database name: ' + (self.database_name || 'nil')
+      puts 'Database server: ' + (self.database_server || 'nil')
+      puts 'Views:'
+      pp self.views
+    end
+
+    def self.query_view!(name, options={})
+      view = self.views[name]
+      raise 'View does not exist' unless view
+
+      begin
+        tmp_couch_opts = view[:couch_options] || {}
+        pr_options = options.merge(tmp_couch_opts)
+        results = self.query_view(name, pr_options)
+        self.process_results(name, results, pr_options)
+      rescue RestClient::ResourceNotFound# => e
+        raise
+      end
+    end
+
+    class << self
+      alias_method :save, :save_document
+      alias_method :save_doc, :save_document
+
+      alias_method :save!, :save_document!
+      alias_method :save_doc!, :save_document!
+
+      alias_method :destroy, :destroy_document
+      alias_method :destroy_doc, :destroy_document
+
+      alias_method :load, :load_document
+      alias_method :load_doc, :load_document
+    end
+
+    private
+
+    def self.create_document(document)
+      # document.database = self
+      document.run_callbacks :before_validation_on_save
+      document.run_callbacks :before_validation_on_create
+      return unless document.valid?
+      document.run_callbacks :before_save
+      document.run_callbacks :before_create
+      res = self.database.save_doc document.to_hash
+      document._rev = res['rev']
+      document._id = res['id']
+      document.run_callbacks :after_save
+      document.run_callbacks :after_create
+      true
+    end
+
+    def self.update_document(document)
+      document.run_callbacks :before_validation_on_save
+      document.run_callbacks :before_validation_on_update
+      return unless document.valid?
+      document.run_callbacks :before_save
+      document.run_callbacks :before_update
+      res = self.database.save_doc document.to_hash
+      document._rev = res['rev']
+      document.run_callbacks :after_save
+      document.run_callbacks :after_update
+      true
+    end
+
+    def self.query_view(name,parameters)
+      self.database.view "#{self.views[name][:design_doc]}/#{self.views[name][:view_name]}", parameters
+    end
+
+    def self.process_results(name, results, options ={})
+      # view = self.views[name]
+      options = self.views[name].merge(options)
+
+      couch_opts = options[:couch_options] || {}
+      return_raw = couch_opts[:reduce] || options[:model] == :raw
+
+      first_result = results['rows'][0]
+
+      if (first_result && first_result['doc'] && first_result['value'])
+        raise "View results contain doc and value keys. Don't pass `:include_docs => true` to a view that does not `emit(some_key,null)`"
+      end
+
+      field_to_read = first_result && first_result['doc'] ? 'doc' : 'value'
+
+      # TODO: This code looks like C (REVIEW)
+      results['rows'].map do |row|
+        next row[field_to_read] if return_raw
+
+        model = options[:model]
+        if model
+          model = model.kind_of?(String) ? class_from_string(model) : model
+          meta = {'id' => row['id']}.merge({'key' => row['key']})
+          model.json_create(row[field_to_read], meta)
+        else
+          if row[field_to_read]['ruby_class'].nil?
+            row[field_to_read]
+          else
+            meta = {'id' => row['id']}.merge({'key' => row['key']})
+            # Class.const_get(row[field_to_read]['ruby_class']).json_create(row[field_to_read], meta)
+            klass = class_from_string(row[field_to_read]['ruby_class'])
+            klass.json_create(row[field_to_read], meta)
+          end
+        end
+      end # results do
+    end
+
+    private
+
+    def self.class_from_string(string)
+      string.to_s.split('::').inject(Object){|a, m| a = a.const_get(m.to_sym)}
+    end
+
+  end # class
+end # module
+
+        # if return_raw
+        #   row[field_to_read]
+        # elsif options[:model].nil?
+        #   if row[field_to_read]['ruby_class'].nil?
+        #     row[field_to_read]
+        #   else
+        #     meta = {'id' => row['id']}.merge({'key' => row['key']})
+        #     Class.const_get(row[field_to_read]['ruby_class']).json_create(row[field_to_read], meta)
+        #   end
+        # else
+        #   meta = {'id' => row['id']}.merge({'key' => row['key']})
+        #   options[:model].json_create(row[field_to_read], meta)
+        # end

data/lib/couch_tomato/js_view_source.rb

@@ -0,0 +1,182 @@
+require 'digest/sha1'
+
+module CouchTomato
+  class JsViewSource
+    # todo: provide a 'dirty?' method that can be called in an initializer and warn the developer that view are out of sync
+    # todo: provide more granular information about which views are being modified
+    # todo: limitation (bug?) where if you remove a database's views entirely from the file system, view's will not be removed from the database as may be expected
+    def self.push(silent=false)
+      fs_database_names.each do |database_name|
+        db = database!(database_name)
+
+        fs_docs = fs_design_docs(database_name)
+        db_docs = db_design_docs(db)
+        
+        fs_docs.each do |design_name, fs_doc|
+          db_doc = db_docs[design_name]
+
+          if db_doc
+            fs_doc['_id'] = db_doc['_id']
+            fs_doc['_rev'] = db_doc['_rev']
+          end
+
+          if fs_doc['views'].empty?
+            next unless fs_doc['_rev']
+            puts "DELETE #{fs_doc['_id']}" unless silent
+            db.delete_doc(fs_doc)
+          else
+            if changed_views?(fs_doc, db_doc)
+              puts "UPDATE #{fs_doc['_id']}" unless silent
+              db.save_doc(fs_doc)
+            end
+          end
+        end
+      end
+    end
+
+    def self.changed_views?(fs_doc, db_doc)
+      return true if db_doc.nil?
+
+      fs_doc['views'].each do |name, fs_view|
+        db_view = db_doc['views'][name]
+        %w(map reduce).each do |method|
+          return true if db_view.nil? || db_view["sha1-#{method}"] != fs_view["sha1-#{method}"]
+        end
+      end
+
+      return false
+    end
+
+    def self.diff
+      fs_database_names.each do |database_name|
+        db = database!(database_name)
+
+        fs_docs = fs_design_docs(database_name)
+        db_docs = db_design_docs(db)
+
+        # design docs on fs but not in db
+        (fs_docs.keys - db_docs.keys).each do |design_name|
+          unless fs_docs[design_name]['views'].empty?
+            puts "    NEW: #{database_name}/_#{design_name}: #{fs_docs[design_name]['views'].keys.join(', ')}"
+          end
+        end
+
+        # design docs in db but not on fs
+        (db_docs.keys - fs_docs.keys).each do |design_name|
+          puts "REMOVED: #{database_name}/_#{design_name}"
+        end
+
+        # design docs in both db and fs
+        (fs_docs.keys & db_docs.keys).each do |design_name|
+          common_view_keys = (fs_docs[design_name]['views'].keys & db_docs[design_name]['views'].keys)
+          fs_only_view_keys = fs_docs[design_name]['views'].keys - common_view_keys
+          db_only_view_keys = db_docs[design_name]['views'].keys - common_view_keys
+
+          unless fs_only_view_keys.empty?
+            methods = fs_only_view_keys.map do |key|
+              %w(map reduce).map {|method| fs_docs[design_name]['views'][key][method].nil? ? nil : "#{key}.#{method}()"}.compact
+            end.flatten
+            puts "  ADDED: #{database_name}/_#{design_name}: #{methods.join(', ')}"
+          end
+
+          unless db_only_view_keys.empty?
+            methods = db_only_view_keys.map do |key|
+              %w(map reduce).map {|method| db_docs[design_name]['views'][key][method] ? "#{key}.#{method}()" : nil}.compact
+            end
+            puts "REMOVED: #{database_name}/_#{design_name}: #{methods.join(', ')}"
+          end
+
+          common_view_keys.each do |common_key|
+            # are the sha's the same?
+            # map reduce sha1
+            fs_view = fs_docs[design_name]['views'][common_key]
+            db_view = db_docs[design_name]['views'][common_key]
+
+            # has either the map or reduce been added or removed
+            %w(map reduce).each do |method|
+              if db_view[method] && !fs_view[method]
+                puts "REMOVED: #{database_name}/_#{design_name}:#{method}()" and next
+              end
+
+              if fs_view[method] && !db_view[method]
+                puts "  ADDED: #{database_name}/_#{design_name}:#{method}()" and next
+              end
+
+              if fs_view["sha1-#{method}"] != db_view["sha1-#{method}"]
+                puts "OUTDATED: #{database_name}/_#{design_name}:#{method}()" and next
+              end
+            end
+          end
+        end
+
+      end
+    end
+
+    private
+
+    def self.path(db_name="")
+      "#{Rails.root}/db/views/#{db_name}" if Rails
+    end
+
+    def self.fs_database_names
+      Dir[path + "/**"].map {|path| path.split('/').last}
+    end
+
+    def self.db_design_docs(db)
+      design_docs = db.get("_all_docs", {:startkey => "_design/", :endkey => "_design0", :include_docs => true})['rows']
+      design_docs.inject({}) do |res, row|
+        doc = row['doc']
+        design_name = doc['_id'].split('/').last
+        res[design_name.to_sym] = doc#['views']
+        res
+      end
+    end
+
+    # :clicks => {'by_date' => {'map' => ..., 'reduce' => ..., sha1-map => ..., sha1-reduce => ...} }
+    def self.fs_design_docs(db_name)
+      design_docs = {}
+
+      path = "#{RAILS_ROOT}/couchdb/views/#{db_name}"
+      Dir[path + "/**"].each do |file|
+        throw "Invalid filename '#{File.basename(file)}': expecting '-map.js' or '-reduce.js' suffix" unless file.match(/-((map)|(reduce))\.js$/)
+
+        design_name = db_name.to_sym
+        design_docs[design_name] ||= {'_id' => "_design/#{db_name}", 'views' => {}}
+        fs_view(design_docs[design_name], file)
+      end
+
+      design_docs.each do |db, design|
+        design["views"].each do |view, functions|
+          if !functions["reduce"].nil?
+            raise "#{view}-reduce was found without a corresponding map function." if functions["map"].nil?
+          end
+        end
+      end
+
+      design_docs
+    end
+
+    def self.fs_view(design_doc, view_path)
+      filename = view_path.split('/').last.split('.').first
+      name, type = filename.split('-')
+
+      file = open(view_path)
+      content = file.read
+      file.close
+
+      sha1 = Digest::SHA1.hexdigest(content)
+
+      design_doc['views'][name] ||= {}
+      design_doc['views'][name][type] = content
+      design_doc['views'][name]["sha1-#{type}"] = sha1
+      design_doc
+    end
+
+    # todo: don't depend on "proprietary" APP_CONFIG
+    def self.database!(database_name)
+      CouchRest.database!("http://" + APP_CONFIG["couchdb_address"] + ":" + APP_CONFIG["couchdb_port"].to_s \
+       + "/" + APP_CONFIG["couchdb_basename"] + "_" + database_name + "_" + RAILS_ENV)
+    end
+
+  end
+end

data/lib/couch_tomato/migration.rb

@@ -0,0 +1,52 @@
+module CouchTomato
+  class Migration
+    class << self
+      # Execute this migration in the named direction
+      def migrate(direction, db)
+        return unless respond_to?(direction)
+
+        case direction
+          when :up   then announce "migrating"
+          when :down then announce "reverting"
+        end
+
+        time = Benchmark.measure do
+          docs = db.get('_all_docs', :include_docs => true)['rows']
+          docs.each do |doc|
+            next if /^_design/ =~ doc['id']
+            send(direction, doc['doc'])
+            db.save_doc(doc['doc'])
+          end
+        end
+
+        case direction
+          when :up   then announce "migrated (%.4fs)" % time.real; write
+          when :down then announce "reverted (%.4fs)" % time.real; write
+        end
+      end
+
+      def write(text="")
+        puts(text)
+      end
+
+      def announce(message)
+        text = "#{@version} #{name}: #{message}"
+        length = [0, 75 - text.length].max
+        write "== %s %s" % [text, "=" * length]
+      end
+
+      def say(message, subitem=false)
+        write "#{subitem ? "   ->" : "--"} #{message}"
+      end
+
+      def say_with_time(message)
+        say(message)
+        result = nil
+        time = Benchmark.measure { result = yield }
+        say "%.4fs" % time.real, :subitem
+        say("#{result} rows", :subitem) if result.is_a?(Integer)
+        result
+      end
+    end
+  end
+end