relaxdb 0.3.5

data/lib/relaxdb/extlib.rb

@@ -0,0 +1,24 @@
+class Errors < Hash
+  alias_method :on, :[]
+  alias_method :count, :size
+
+  def full_messages
+    full_messages = []
+    each_key do |attr|
+      full_messages << attr.to_s + ": " + self[attr]
+    end
+    full_messages
+  end
+end
+
+class Time
+
+  # Ensure that all Times are stored as UTC
+  # Times in the following format may be passed directly to
+  # Date.new in a JavaScript runtime
+  def to_json
+    utc
+    %Q("#{strftime "%Y/%m/%d %H:%M:%S +0000"}")
+  end
+
+end

data/lib/relaxdb/has_many_proxy.rb

@@ -0,0 +1,101 @@
+module RelaxDB
+
+  class HasManyProxy
+
+    include Enumerable
+    
+    attr_reader :children
+  
+    def initialize(client, relationship, opts)
+      @client = client 
+      @relationship = relationship
+      @opts = opts
+
+      @target_class = opts[:class] 
+      @relationship_as_viewed_by_target = (opts[:known_as] || client.class.name.snake_case).to_s
+
+      @children = load_children
+    end
+
+    def <<(obj)
+      return false if @children.include?(obj)
+
+      obj.send("#{@relationship_as_viewed_by_target}=".to_sym, @client)
+      if obj.save
+        @children << obj
+        self
+      else
+        false
+      end
+    end
+  
+    def clear
+      @children.each do |c|
+        break_back_link c
+      end
+      @children.clear
+    end
+  
+    def delete(obj)
+      obj = @children.delete(obj)
+      break_back_link(obj) if obj
+    end
+  
+    def break_back_link(obj)
+      if obj
+        obj.send("#{@relationship_as_viewed_by_target}=".to_sym, nil)
+        obj.save
+      end
+    end
+  
+    def empty?
+      @children.empty?
+    end
+  
+    def size
+      @children.size
+    end
+  
+    def [](*args)
+      @children[*args]
+    end
+    
+    def first
+      @children[0]
+    end
+    
+    def last
+      @children[size-1]
+    end
+  
+    def each(&blk)
+      @children.each(&blk)
+    end
+  
+    def reload
+      @children = load_children
+    end
+  
+    def load_children
+      view_name = "#{@client.class}_#{@relationship}"
+      @children = RelaxDB.view(view_name, :key => @client._id)
+    end
+    
+    def children=(children)
+      children.each do |obj|
+        obj.send("#{@relationship_as_viewed_by_target}=".to_sym, @client)
+      end
+      @children = children
+    end
+  
+    def inspect
+      @children.inspect
+    end
+    
+    # Play nice with Merb partials - [ obj ].flatten invokes
+    # obj.to_ary if it responds to to_ary
+    alias_method :to_ary, :to_a
+  
+  end
+
+end

data/lib/relaxdb/has_one_proxy.rb

@@ -0,0 +1,42 @@
+module RelaxDB
+
+  class HasOneProxy
+  
+    def initialize(client, relationship)
+      @client = client
+      @relationship = relationship
+      @target_class = @relationship.to_s.camel_case      
+      @relationship_as_viewed_by_target = client.class.name.snake_case
+      
+      @target = nil
+    end
+    
+    def target
+      return @target if @target    
+      @target = load_target
+    end
+  
+    # All database changes performed by this method would ideally be done in a transaction
+    def target=(new_target)
+      # Nullify any existing relationship on assignment
+      old_target = target
+      if old_target
+        old_target.send("#{@relationship_as_viewed_by_target}=".to_sym, nil)
+        old_target.save
+      end
+    
+      @target = new_target
+      unless @target.nil?
+        @target.send("#{@relationship_as_viewed_by_target}=".to_sym, @client)
+        @target.save
+      end
+    end
+  
+    def load_target
+      view_name = "#{@client.class}_#{@relationship}"
+      RelaxDB.view(view_name, :key => @client._id).first
+    end
+        
+  end
+
+end

data/lib/relaxdb/migration.rb

@@ -0,0 +1,40 @@
+module RelaxDB
+  
+  class Migration
+                
+    def self.run klass, limit = 1000
+      query = lambda do |page_params|
+        RelaxDB.paginate_view "#{klass}_all", :startkey => nil, :endkey => {}, :attributes => [:_id],
+          :page_params => page_params, :limit => limit
+      end
+      
+      objs = query.call({})
+      until objs.empty?
+        migrated = objs.map { |o| yield o }.flatten.reject { |o| o.nil? }
+        RelaxDB.bulk_save! *migrated
+        objs = objs.next_params ? query.call(objs.next_params) : []
+      end
+    end
+    
+    #
+    # Runs all outstanding migrations in a given directory
+    #
+    # ==== Example
+    #   RelaxDB::Migration.run_all Dir["couchdb/migrations/**/*.rb"]
+    #
+    def self.run_all file_names, action = lambda { |fn| require fn }
+      v = RelaxDB::MigrationVersion.version
+      file_names.select { |fn| fv(fn) > v }.each do |fn|
+        RelaxDB.logger.info "Applying #{fn}"
+        action.call fn
+        RelaxDB::MigrationVersion.update fv(fn)
+      end
+    end
+    
+    def self.fv file_name
+      File.basename(file_name).split("_")[0].to_i
+    end
+    
+  end
+  
+end

data/lib/relaxdb/migration_version.rb

@@ -0,0 +1,21 @@
+class RelaxDB::MigrationVersion < RelaxDB::Document
+  
+  DOC_ID = "relaxdb_migration_version"
+  
+  property :version, :default => 0
+  
+  def self.version
+    retrieve.version
+  end
+      
+  def self.update v
+    mv = retrieve
+    mv.version = v
+    mv.save!
+  end
+    
+  def self.retrieve
+    (v = RelaxDB.load(DOC_ID)) ? v : new(:_id => DOC_ID).save!
+  end
+  
+end

data/lib/relaxdb/net_http_server.rb

@@ -0,0 +1,61 @@
+module RelaxDB
+
+  class Server
+      
+    def initialize(host, port)
+      @host = host
+      @port = port
+    end
+
+    def delete(uri)
+      request(Net::HTTP::Delete.new(uri))
+    end
+
+    def get(uri)
+      request(Net::HTTP::Get.new(uri))
+    end
+
+    def put(uri, json)
+      req = Net::HTTP::Put.new(uri)
+      req["content-type"] = "application/json"
+      req.body = json
+      request(req)
+    end
+
+    def post(uri, json)
+      req = Net::HTTP::Post.new(uri)
+      req["content-type"] = "application/json"
+      req.body = json
+      request(req)
+    end
+
+    def request(req)
+      res = Net::HTTP.start(@host, @port) {|http|
+        http.request(req)
+      }
+      if (not res.kind_of?(Net::HTTPSuccess))
+        handle_error(req, res)
+      end
+      res
+    end
+  
+    def to_s
+      "http://#{@host}:#{@port}/"
+    end
+  
+    private
+
+    def handle_error(req, res)
+      msg = "#{res.code}:#{res.message}\nMETHOD:#{req.method}\nURI:#{req.path}\n#{res.body}"
+      begin
+        klass = RelaxDB.const_get("HTTP_#{res.code}")
+        e = klass.new(msg)
+      rescue
+        e = RuntimeError.new(msg)
+      end
+
+      raise e
+    end
+  end
+  
+end

data/lib/relaxdb/paginate_params.rb

@@ -0,0 +1,53 @@
+module RelaxDB
+
+  class PaginateParams
+        
+    @@params = %w(key startkey startkey_docid endkey endkey_docid limit update descending group reduce include_docs)
+  
+    @@params.each do |param|
+      define_method(param.to_sym) do |*val|
+        if val.empty?
+          instance_variable_get("@#{param}")
+        else
+          instance_variable_set("@#{param}", val[0])
+          # null is meaningful to CouchDB. _set allows us to know that a param has been set, even to nil
+          instance_variable_set("@#{param}_set", true)
+          self
+        end
+      end
+    end
+    
+    def initialize(params)
+      params.each { |k, v| send(k, v) }
+      
+      # If a client hasn't explicitly set descending, set it to the CouchDB default
+      @descending = false if @descending.nil?
+    end
+  
+    def update(params)
+      @order_inverted = params[:descending].nil? ? false : @descending ^ params[:descending]
+      @descending = !@descending if @order_inverted
+
+      @endkey = @startkey if @order_inverted
+    
+      @startkey = params[:startkey] || @startkey
+    
+      @skip = 1 if params[:startkey]
+      
+      @startkey_docid = params[:startkey_docid] if params[:startkey_docid]
+      @endkey_docid = params[:endkey_docid] if params[:endkey_docid]
+    end
+  
+    def order_inverted?
+      @order_inverted
+    end
+    
+    def invalid?
+      # Simply because allowing either to be omitted increases the complexity of the paginator
+      @startkey_set && @endkey_set ? nil : "Both startkey and endkey must be set"
+    end
+    alias error_msg invalid?
+      
+  end
+
+end

data/lib/relaxdb/paginator.rb

@@ -0,0 +1,88 @@
+module RelaxDB  
+
+  class Paginator
+    
+    attr_reader :paginate_params
+
+    def initialize(paginate_params, page_params)
+      @paginate_params = paginate_params
+      @orig_paginate_params = @paginate_params.clone
+      
+      page_params = page_params.is_a?(String) ? JSON.parse(page_params).to_mash : page_params
+      # Where the magic happens - the original params are updated with the page specific params
+      @paginate_params.update(page_params)
+    end
+
+    def total_doc_count(view_name)
+      RelaxDB.view view_name, :startkey => @orig_paginate_params.startkey, :endkey => @orig_paginate_params.endkey,
+        :descending => @orig_paginate_params.descending, :reduce => true
+    end
+    
+    #
+    # view_keys are used to determine the params for the prev and next links. If a view_key is a symbol
+    # the key value will be the result of invoking the method named by the symbol on the first / last 
+    # element in the result set. If a view_key is not a symbol, its value will be used directly.
+    #
+    def add_next_and_prev(docs, view_name, view_keys)
+      unless docs.empty?
+        no_docs = docs.size
+        offset = docs.offset
+        orig_offset = orig_offset(view_name)
+        total_doc_count = total_doc_count(view_name)      
+      
+        next_exists = !@paginate_params.order_inverted? ? (offset - orig_offset + no_docs < total_doc_count) : true
+        next_params = create_next(docs.last, view_keys) if next_exists
+    
+        prev_exists = @paginate_params.order_inverted? ? (offset - orig_offset + no_docs < total_doc_count) : 
+          (offset - orig_offset == 0 ? false : true)
+        prev_params = create_prev(docs.first, view_keys) if prev_exists
+      else
+        next_exists = prev_exists = false
+      end
+      
+      docs.meta_class.instance_eval do        
+        define_method(:next_params) { next_exists ? next_params : false }
+        define_method(:next_query) { next_exists ? "page_params=#{::CGI::escape(next_params.to_json)}" : false }
+        
+        define_method(:prev_params) { prev_exists ? prev_params : false }
+        define_method(:prev_query) { prev_exists ? "page_params=#{::CGI::escape(prev_params.to_json)}" : false }
+      end      
+    end
+    
+    def create_next(doc, view_keys)
+      next_key = view_keys_to_vals doc, view_keys
+      next_key = next_key.length == 1 ? next_key[0] : next_key
+      next_key_docid = doc._id
+      { :startkey => next_key, :startkey_docid => next_key_docid, :descending => @orig_paginate_params.descending }
+    end
+    
+    def create_prev(doc, view_keys)
+      prev_key = view_keys_to_vals doc, view_keys
+      prev_key = prev_key.length == 1 ? prev_key[0] : prev_key
+      prev_key_docid = doc._id
+      prev_params = { :startkey => prev_key, :startkey_docid => prev_key_docid, :descending => !@orig_paginate_params.descending }
+    end
+    
+    def view_keys_to_vals doc, view_keys
+      view_keys.map do |k|
+        if k.is_a?(Symbol) then doc.send(k)
+        elsif k.is_a?(Proc) then k.call(doc)
+        else k
+        end
+      end
+    end
+    
+    def orig_offset(view_name)
+      if @paginate_params.order_inverted?
+        params = {:startkey => @orig_paginate_params.endkey, :descending => !@orig_paginate_params.descending}
+      else
+        params = {:startkey => @orig_paginate_params.startkey, :descending => @orig_paginate_params.descending}
+      end
+      params[:limit] = 1
+            
+      RelaxDB.rf_view(view_name, params).offset
+    end
+    
+  end
+  
+end

data/lib/relaxdb/query.rb

@@ -0,0 +1,76 @@
+module RelaxDB
+
+  # A Query is used to build the query string made against a view
+  # All parameter values are first JSON encoded and then URL encoded
+  # Nil values are set to the empty string
+  
+  class Query
+    
+    # keys is not included in the standard param as it is significantly different from the others
+    @@params = %w(key startkey startkey_docid endkey endkey_docid limit update 
+      descending skip group group_level reduce include_docs batch)
+    
+    @@params.each do |param|
+      define_method(param.to_sym) do |*val|
+        if val.empty?
+          instance_variable_get("@#{param}")
+        else 
+          instance_variable_set("@#{param}", val[0])
+          # null is meaningful to CouchDB. _set allows us to know that a param has been set, even to nil        
+          instance_variable_set("@#{param}_set", true)
+          self
+        end
+      end
+    end
+        
+    def initialize view_name, params = {}      
+      @view_name = view_name
+      params.each { |k, v| send k, v }
+    end
+    
+    def keys(keys=nil)
+      if keys.nil?
+        @keys
+      else 
+        @keys = { :keys => keys }.to_json
+        self
+      end
+    end
+    
+    # If set to true RelaxDB.view will return unprocessed data
+    def raw(val = nil)
+      if val.nil?
+        @raw
+      else
+        @raw = val
+        self
+      end
+    end
+    
+    def view_path
+      uri = (@view_name =~ /^_/) ? @view_name : "_design/#{RelaxDB.dd}/_view/#{@view_name}"
+      
+      query = ""
+      @@params.each do |param|
+        val_set = instance_variable_get("@#{param}_set")
+        if val_set
+          val = instance_variable_get("@#{param}")
+          val = val.to_json unless ["startkey_docid", "endkey_docid"].include?(param)
+          query << "&#{param}=#{::CGI::escape(val)}" 
+        end
+      end
+    
+      uri << query.sub(/^&/, "?")
+    end
+    
+    def merge(paginate_params)
+      paginate_params.instance_variables.each do |pp|
+        val = paginate_params.instance_variable_get(pp)
+        method_name = pp[1, pp.length]
+        send(method_name, val) if methods.include? method_name
+      end
+    end
+        
+  end
+
+end