openlogic-couchrest_model 1.0.0

data/lib/couchrest/model/collection.rb

@@ -0,0 +1,273 @@
+module CouchRest
+  module Model
+    # Warning! The Collection module is seriously depricated.
+    # Use the new Design Views instead, as this code copies many other parts
+    # of CouchRest Model.
+    #
+    # Expect this to be removed soon.
+    #
+    module Collection
+
+      def self.included(base)
+        base.extend(ClassMethods)
+      end
+
+      module ClassMethods
+
+        # Creates a new class method, find_all_<collection_name>, that will
+        # execute the view specified with the design_doc and view_name 
+        # parameters, along with the specified view_options.  This method will
+        # return the results of the view as an Array of objects which are
+        # instances of the class.
+        #
+        # This method is handy for objects that do not use the view_by method
+        # to declare their views.
+        def provides_collection(collection_name, design_doc, view_name, view_options)
+          class_eval <<-END, __FILE__, __LINE__ + 1
+            def self.find_all_#{collection_name}(options = {})
+              view_options = #{view_options.inspect} || {}
+              CollectionProxy.new(options[:database] || database, "#{design_doc}", "#{view_name}", view_options.merge(options), Kernel.const_get('#{self}'))
+            end
+          END
+        end
+
+        # Fetch a group of objects from CouchDB.  Options can include:
+        #   :page - Specifies the page to load (starting at 1)
+        #   :per_page - Specifies the number of objects to load per page
+        #
+        # Defaults are used if these options are not specified.
+        def paginate(options)
+          proxy = create_collection_proxy(options)
+          proxy.paginate(options)
+        end
+
+        # Iterate over the objects in a collection, fetching them from CouchDB
+        # in groups.  Options can include:
+        #   :page - Specifies the page to load
+        #   :per_page - Specifies the number of objects to load per page
+        #
+        # Defaults are used if these options are not specified.
+        def paginated_each(options, &block)
+          search = options.delete(:search)
+          unless search == true
+            proxy = create_collection_proxy(options)
+          else
+            proxy = create_search_collection_proxy(options)
+          end
+          proxy.paginated_each(options, &block)
+        end
+
+        # Create a CollectionProxy for the specified view and options.
+        # CollectionProxy behaves just like an Array, but offers support for
+        # pagination.
+        def collection_proxy_for(design_doc, view_name, view_options = {})
+          options = view_options.merge(:design_doc => design_doc, :view_name => view_name)
+          create_collection_proxy(options)
+        end
+
+        private
+
+        def create_collection_proxy(options)
+          design_doc, view_name, view_options = parse_view_options(options)
+          CollectionProxy.new(options[:database] || database, design_doc, view_name, view_options, self)
+        end
+
+        def create_search_collection_proxy(options)
+          design_doc, search_name, search_options = parse_search_options(options)
+          CollectionProxy.new(options[:database] || database, design_doc, search_name, search_options, self, :search)
+        end
+
+        def parse_view_options(options)
+          design_doc = options.delete(:design_doc)
+          raise ArgumentError, 'design_doc is required' if design_doc.nil?
+
+          view_name = options.delete(:view_name)
+          raise ArgumentError, 'view_name is required' if view_name.nil?
+
+          default_view_options = (design_doc.class == Design && 
+              design_doc['views'][view_name.to_s] &&
+              design_doc['views'][view_name.to_s]["couchrest-defaults"]) || {}
+          view_options = default_view_options.merge(options)
+          view_options.delete(:database)
+
+          [design_doc, view_name, view_options]
+        end
+
+        def parse_search_options(options)
+          design_doc = options.delete(:design_doc)
+          raise ArgumentError, 'design_doc is required' if design_doc.nil?
+
+          search_name = options.delete(:view_name)
+          raise ArgumentError, 'search_name is required' if search_name.nil?
+
+          search_options = options.clone
+          search_options.delete(:database)
+
+          [design_doc, search_name, search_options]
+        end
+
+      end
+
+      class CollectionProxy
+        alias_method :proxy_respond_to?, :respond_to?
+        instance_methods.each { |m| undef_method m unless m =~ /(^__|^nil\?$|^send$|proxy_|^object_id$)/ }
+
+        DEFAULT_PAGE = 1
+        DEFAULT_PER_PAGE = 30
+        
+        # Create a new CollectionProxy to represent the specified view.  If a
+        # container class is specified, the proxy will create an object of the
+        # given type for each row that comes back from the view.  If no
+        # container class is specified, the raw results are returned.
+        #
+        # The CollectionProxy provides support for paginating over a collection
+        # via the paginate, and paginated_each methods.
+        def initialize(database, design_doc, view_name, view_options = {}, container_class = nil, query_type = :view)
+          raise ArgumentError, "database is a required parameter" if database.nil?
+
+          @database = database
+          @container_class = container_class
+          @query_type = query_type
+
+          strip_pagination_options(view_options)
+          @view_options = view_options
+
+          if design_doc.class == Design
+            @view_name = "#{design_doc.name}/#{view_name}"
+          else
+            @view_name = "#{design_doc}/#{view_name}"
+          end
+
+          # Save the design doc, ready for use
+          @container_class.save_design_doc(@database)
+        end
+
+        # See Collection.paginate
+        def paginate(options = {})
+          page, per_page = parse_options(options)
+          results = @database.send(@query_type, @view_name, pagination_options(page, per_page))
+          remember_where_we_left_off(results, page)
+          instances = convert_to_container_array(results)
+
+          begin
+            if Kernel.const_get('WillPaginate')
+              total_rows = results['total_rows'].to_i
+              paginated = WillPaginate::Collection.create(page, per_page, total_rows) do |pager|
+                pager.replace(instances)
+              end
+              return paginated
+            end
+          rescue NameError
+            # When not using will_paginate, not much we could do about this. :x
+          end
+          return instances
+        end
+
+        # See Collection.paginated_each
+        def paginated_each(options = {}, &block)
+          page, per_page = parse_options(options)
+
+          begin
+            collection = paginate({:page => page, :per_page => per_page})
+            collection.each(&block)
+            page += 1
+          end until collection.size < per_page
+        end
+
+        def respond_to?(*args)
+          proxy_respond_to?(*args) || (load_target && @target.respond_to?(*args))
+        end
+
+        # Explicitly proxy === because the instance method removal above
+        # doesn't catch it.
+        def ===(other)
+          load_target
+          other === @target
+        end
+
+        private
+
+        def method_missing(method, *args)
+          if load_target
+            if block_given?
+              @target.send(method, *args)  { |*block_args| yield(*block_args) }
+            else
+              @target.send(method, *args)
+            end
+          end
+        end
+
+        def load_target
+          unless loaded?
+            @view_options.merge!({:include_docs => true}) if @query_type == :search
+            results = @database.send(@query_type, @view_name, @view_options)
+            @target = convert_to_container_array(results)
+          end
+          @loaded = true
+          @target
+        end
+
+        def loaded?
+          @loaded
+        end
+
+        def reload
+          reset
+          load_target
+          self unless @target.nil?
+        end
+
+        def reset
+          @loaded = false
+          @target = nil
+        end
+
+        def inspect
+          load_target
+          @target.inspect
+        end
+
+        def convert_to_container_array(results) 
+          if @container_class.nil?
+            results
+          else
+            results['rows'].collect { |row| @container_class.build_from_database(row['doc']) } unless results['rows'].nil?
+          end
+        end
+
+        def pagination_options(page, per_page)
+          view_options = @view_options.clone
+          if @query_type == :view && @last_key && @last_docid && @last_page == page - 1
+            key = view_options.delete(:key)
+            end_key = view_options[:endkey] || key
+            options = { :startkey => @last_key, :endkey => end_key, :startkey_docid => @last_docid, :limit => per_page, :skip => 1 }
+          else
+            options = { :limit => per_page, :skip => per_page * (page - 1) }
+          end
+          options[:include_docs] = true
+          view_options.merge(options)
+        end
+
+        def parse_options(options)
+          page = options.delete(:page) || DEFAULT_PAGE
+          per_page = options.delete(:per_page) || DEFAULT_PER_PAGE
+          [page.to_i, per_page.to_i]
+        end
+
+        def strip_pagination_options(options)
+          parse_options(options)
+        end
+
+        def remember_where_we_left_off(results, page)
+          last_row = results['rows'].last
+          if last_row
+            @last_key = last_row['key']
+            @last_docid = last_row['id']
+          end
+          @last_page = page
+        end
+      end
+
+    end
+  end
+end

data/lib/couchrest/model/configuration.rb

@@ -0,0 +1,67 @@
+module CouchRest
+
+  # CouchRest Model Configuration support, stolen from Carrierwave by jnicklas
+  #    http://github.com/jnicklas/carrierwave/blob/master/lib/carrierwave/uploader/configuration.rb
+
+  module Model
+    module Configuration
+      extend ActiveSupport::Concern
+
+      included do
+        add_config :model_type_key
+        add_config :mass_assign_any_attribute
+        add_config :auto_update_design_doc
+        add_config :environment
+        add_config :connection
+        add_config :connection_config_file
+
+        configure do |config|
+          config.model_type_key = 'type' # was 'couchrest-type'
+          config.mass_assign_any_attribute = false
+          config.auto_update_design_doc = true
+
+          config.environment = :development
+          config.connection_config_file = File.join(Dir.pwd, 'config', 'couchdb.yml')
+          config.connection = {
+            :protocol => 'http',
+            :host     => 'localhost',
+            :port     => '5984',
+            :prefix   => 'couchrest',
+            :suffix   => nil,
+            :join     => '_',
+            :username => nil,
+            :password => nil
+          }
+        end
+      end
+
+      module ClassMethods
+
+        def add_config(name)
+          class_eval <<-RUBY, __FILE__, __LINE__ + 1
+            def self.#{name}(value=nil)
+              @#{name} = value if value
+              return @#{name} if self.object_id == #{self.object_id} || defined?(@#{name})
+              name = superclass.#{name}
+              return nil if name.nil? && !instance_variable_defined?("@#{name}")
+              @#{name} = name && !name.is_a?(Module) && !name.is_a?(Symbol) && !name.is_a?(Numeric) && !name.is_a?(TrueClass) && !name.is_a?(FalseClass) ? name.dup : name
+            end
+
+            def self.#{name}=(value)
+              @#{name} = value
+            end
+
+            def #{name}
+              self.class.#{name}
+            end
+          RUBY
+        end
+
+        def configure
+          yield self
+        end
+      end
+
+    end
+  end
+end

data/lib/couchrest/model/connection.rb

@@ -0,0 +1,70 @@
+module CouchRest
+  module Model
+    module Connection
+      extend ActiveSupport::Concern
+
+      def server
+        self.class.server
+      end
+
+      module ClassMethods
+
+        # Overwrite the normal use_database method so that a database
+        # name can be provided instead of a full connection.
+        def use_database(db)
+          @database = prepare_database(db)
+        end
+
+        # Overwrite the default database method so that it always
+        # provides something from the configuration
+        def database
+          super || (@database ||= prepare_database)
+        end
+
+        def server
+          @server ||= CouchRest::Server.new(prepare_server_uri)
+        end
+
+        def prepare_database(db = nil)
+          unless db.is_a?(CouchRest::Database)
+            conf = connection_configuration
+            db = [conf[:prefix], db.to_s, conf[:suffix]].reject{|s| s.to_s.empty?}.join(conf[:join])
+            self.server.database!(db)
+          else
+            db
+          end
+        end
+
+        protected
+
+        def prepare_server_uri
+          conf = connection_configuration
+          userinfo = [conf[:username], conf[:password]].compact.join(':')
+          userinfo += '@' unless userinfo.empty?
+          "#{conf[:protocol]}://#{userinfo}#{conf[:host]}:#{conf[:port]}"
+        end
+
+        def connection_configuration
+          @connection_configuration ||=
+            self.connection.update(
+              (load_connection_config_file[environment.to_sym] || {}).symbolize_keys
+            )
+        end
+
+        def load_connection_config_file
+          file = connection_config_file
+          connection_config_cache[file] ||=
+            (File.exists?(file) ?
+              YAML::load(ERB.new(IO.read(file)).result) :
+              { }).symbolize_keys
+        end
+
+        def connection_config_cache
+          Thread.current[:connection_config_cache] ||= {}
+        end
+
+      end
+
+    end
+  end
+end

data/lib/couchrest/model/core_extensions/hash.rb

@@ -0,0 +1,9 @@
+# This file contains various hacks for Rails compatibility.
+class Hash
+  # Hack so that CouchRest::Document, which descends from Hash,
+  # doesn't appear to Rails routing as a Hash of options
+  def self.===(other)
+    return false if self == Hash && other.is_a?(CouchRest::Document)
+    super
+  end
+end

data/lib/couchrest/model/core_extensions/time_parsing.rb

@@ -0,0 +1,66 @@
+module CouchRest
+  module Model
+    module CoreExtensions
+      module TimeParsing
+
+        if RUBY_VERSION < "1.9.0"
+          # Overrwrite Ruby's standard new method to provide compatible support
+          # of 1.9.2's Time.new method.
+          #
+          # Only supports syntax like:
+          #
+          #   Time.new(2011, 4, 1, 18, 50, 32, "+02:00")
+          #   # or
+          #   Time.new(2011, 4, 1, 18, 50, 32)
+          #
+          def new(*args)
+            return super() if (args.empty?)
+            zone = args.delete_at(6)
+            time = mktime(*args)
+            if zone =~ /([\+|\-]?)(\d{2}):?(\d{2})/
+              tz_difference = ("#{$1 == '-' ? '+' : '-'}#{$2}".to_i * 3600) + ($3.to_i * 60)
+              time + tz_difference + zone_offset(time.zone)
+            else
+              time
+            end
+          end
+        end
+
+        # Attemtps to parse a time string in ISO8601 format.
+        # If no match is found, the standard time parse will be used.
+        #
+        # Times, unless provided with a time zone, are assumed to be in 
+        # UTC.
+        #
+        def parse_iso8601(string)
+          if (string =~ /(\d{4})[\-|\/](\d{2})[\-|\/](\d{2})[T|\s](\d{2}):(\d{2}):(\d{2})(Z| ?([\+|\s|\-])?(\d{2}):?(\d{2}))?/)
+            # $1 = year
+            # $2 = month
+            # $3 = day
+            # $4 = hours
+            # $5 = minutes
+            # $6 = seconds
+            # $7 = UTC or Timezone
+            # $8 = time zone direction
+            # $9 = tz difference hours
+            # $10 = tz difference minutes
+
+            if (!$7.to_s.empty? && $7 != 'Z')
+              new($1.to_i, $2.to_i, $3.to_i, $4.to_i, $5.to_i, $6.to_i, "#{$8 == '-' ? '-' : '+'}#{$9}:#{$10}")
+            else
+              utc($1.to_i, $2.to_i, $3.to_i, $4.to_i, $5.to_i, $6.to_i)
+            end
+          else
+            parse(string)
+          end
+        end
+
+      end
+    end
+  end
+end
+
+Time.class_eval do
+  extend CouchRest::Model::CoreExtensions::TimeParsing
+end
+