samlown-couchrest 0.37.2 → 1.0.0

data/lib/couchrest/core/adapters/restclient.rb

@@ -1,35 +0,0 @@
-module RestClientAdapter
-   
-  module API
-    def proxy=(url)
-      RestClient.proxy = url
-    end 
-    
-    def proxy
-      RestClient.proxy
-    end
-  
-    def get(uri, headers={})
-      RestClient.get(uri, headers).to_s
-    end
-  
-    def post(uri, payload, headers={})
-      RestClient.post(uri, payload, headers).to_s
-    end
-  
-    def put(uri, payload, headers={})
-      RestClient.put(uri, payload, headers).to_s
-    end
-  
-    def delete(uri, headers={})
-      RestClient.delete(uri, headers).to_s
-    end
-  
-    def copy(uri, headers)
-      RestClient::Request.execute(  :method   => :copy,
-                                    :url      => uri,
-                                    :headers  => headers).to_s
-    end
-  end 
-  
-end

data/lib/couchrest/core/http_abstraction.rb

@@ -1,48 +0,0 @@
-require 'couchrest/core/adapters/restclient'
-
-# Abstraction layet for HTTP communications.
-#                                           
-# By defining a basic API that CouchRest is relying on,
-# it allows for easy experimentations and implementations of various libraries.
-# 
-# Most of the API is based on the RestClient API that was used in the early version of CouchRest.
-#
-module HttpAbstraction
-  
-  # here is the list of exception expected by CouchRest
-  # please convert the underlying errors in this set of known
-  # exceptions.
-  class ResourceNotFound < StandardError; end
-  class RequestFailed < StandardError; end
-  class RequestTimeout < StandardError; end
-  class ServerBrokeConnection < StandardError; end
-  class Conflict < StandardError; end
-  
-  
-  # # Here is the API you need to implement if you want to write a new adapter
-  # # See adapters/restclient.rb for more information.
-  #
-  # def self.proxy=(url)
-  # end
-  #      
-  # def self.proxy
-  # end
-  #
-  # def self.get(uri, headers=nil)
-  # end
-  # 
-  # def self.post(uri, payload, headers=nil)
-  # end
-  # 
-  # def self.put(uri, payload, headers=nil)
-  # end
-  # 
-  # def self.delete(uri, headers=nil)
-  # end
-  # 
-  # def self.copy(uri, headers)
-  # end    
- 
-end
-
-HttpAbstraction.extend(RestClientAdapter::API)

data/lib/couchrest/core/view.rb

@@ -1,4 +0,0 @@
-module CouchRest
-  class View
-  end
-end

data/lib/couchrest/mixins.rb

@@ -1,4 +0,0 @@
-mixins_dir = File.join(File.dirname(__FILE__), 'mixins')
-
-require File.join(mixins_dir, 'attachments')
-require File.join(mixins_dir, 'callbacks')

data/lib/couchrest/mixins/attachments.rb

@@ -1,31 +0,0 @@
-module CouchRest
-  module Mixins
-    module Attachments
-    
-      # saves an attachment directly to couchdb
-      def put_attachment(name, file, options={})
-        raise ArgumentError, "doc must be saved" unless self.rev
-        raise ArgumentError, "doc.database required to put_attachment" unless database
-        result = database.put_attachment(self, name, file, options)
-        self['_rev'] = result['rev']
-        result['ok']
-      end
-
-      # returns an attachment's data
-      def fetch_attachment(name)
-        raise ArgumentError, "doc must be saved" unless self.rev
-        raise ArgumentError, "doc.database required to put_attachment" unless database
-        database.fetch_attachment(self, name)
-      end
-
-      # deletes an attachment directly from couchdb
-      def delete_attachment(name, force=false)
-        raise ArgumentError, "doc.database required to delete_attachment" unless database
-        result = database.delete_attachment(self, name, force)
-        self['_rev'] = result['rev']
-        result['ok']
-      end
-    
-    end
-  end
-end

data/lib/couchrest/mixins/attribute_protection.rb

@@ -1,74 +0,0 @@
-module CouchRest
-  module Mixins
-    module AttributeProtection
-      # Attribute protection from mass assignment to CouchRest properties
-      # 
-      # Protected methods will be removed from
-      #  * new 
-      #  * update_attributes
-      #  * upate_attributes_without_saving
-      #  * attributes=
-      #  
-      # There are two modes of protection
-      #  1) Declare accessible poperties, assume all the rest are protected 
-      #    property :name, :accessible => true
-      #    property :admin                     # this will be automatically protected
-      #
-      #  2) Declare protected properties, assume all the rest are accessible
-      #    property :name                      # this will not be protected
-      #    property :admin, :protected => true
-      #
-      # Note: you cannot set both flags in a single class
-      
-      def self.included(base)
-        base.extend(ClassMethods)
-      end
-
-      module ClassMethods
-        def accessible_properties
-          properties.select { |prop| prop.options[:accessible] }
-        end
-
-        def protected_properties
-          properties.select { |prop| prop.options[:protected] }
-        end
-      end
-
-      def accessible_properties
-        self.class.accessible_properties
-      end
-
-      def protected_properties
-        self.class.protected_properties
-      end
-
-      def remove_protected_attributes(attributes)
-        protected_names = properties_to_remove_from_mass_assignment.map { |prop| prop.name }
-        return attributes if protected_names.empty?
-
-        attributes.reject! do |property_name, property_value|
-          protected_names.include?(property_name.to_s)
-        end
-
-        attributes || {}
-      end
-
-      private
-
-      def properties_to_remove_from_mass_assignment
-        has_protected = !protected_properties.empty?
-        has_accessible = !accessible_properties.empty?
-
-        if !has_protected && !has_accessible
-          []
-        elsif has_protected && !has_accessible
-          protected_properties
-        elsif has_accessible && !has_protected
-          properties.reject { |prop| prop.options[:accessible] }
-        else
-          raise "Set either :accessible or :protected for #{self.class}, but not both"
-        end
-      end
-    end
-  end
-end

data/lib/couchrest/mixins/callbacks.rb

@@ -1,532 +0,0 @@
-# Copyright (c) 2006-2009 David Heinemeier Hansson
-#  
-# 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.
-#
-# Extracted from ActiveSupport::NewCallbacks written by Yehuda Katz
-# http://github.com/rails/rails/raw/d6e4113c83a9d55be6f2af247da2cecaa855f43b/activesupport/lib/active_support/new_callbacks.rb
-# http://github.com/rails/rails/commit/1126a85aed576402d978e6f76eb393b6baaa9541
-
-require File.join(File.dirname(__FILE__), '..', 'support', 'class')
-
-module CouchRest
-  # Callbacks are hooks into the lifecycle of an object that allow you to trigger logic
-  # before or after an alteration of the object state.
-  #
-  # Mixing in this module allows you to define callbacks in your class.
-  #
-  # Example:
-  #   class Storage
-  #     include ActiveSupport::Callbacks
-  #
-  #     define_callbacks :save
-  #   end
-  #
-  #   class ConfigStorage < Storage
-  #     save_callback :before, :saving_message
-  #     def saving_message
-  #       puts "saving..."
-  #     end
-  #
-  #     save_callback :after do |object|
-  #       puts "saved"
-  #     end
-  #
-  #     def save
-  #       _run_save_callbacks do
-  #         puts "- save"
-  #       end
-  #     end
-  #   end
-  #
-  #   config = ConfigStorage.new
-  #   config.save
-  #
-  # Output:
-  #   saving...
-  #   - save
-  #   saved
-  #
-  # Callbacks from parent classes are inherited.
-  #
-  # Example:
-  #   class Storage
-  #     include ActiveSupport::Callbacks
-  #
-  #     define_callbacks :save
-  #
-  #     save_callback :before, :prepare
-  #     def prepare
-  #       puts "preparing save"
-  #     end
-  #   end
-  #
-  #   class ConfigStorage < Storage
-  #     save_callback :before, :saving_message
-  #     def saving_message
-  #       puts "saving..."
-  #     end
-  #
-  #     save_callback :after do |object|
-  #       puts "saved"
-  #     end
-  #
-  #     def save
-  #       _run_save_callbacks do
-  #         puts "- save"
-  #       end
-  #     end
-  #   end
-  #
-  #   config = ConfigStorage.new
-  #   config.save
-  #
-  # Output:
-  #   preparing save
-  #   saving...
-  #   - save
-  #   saved
-  module Callbacks
-    def self.included(klass)
-      klass.extend ClassMethods
-    end
-
-    def run_callbacks(kind, options = {}, &blk)
-      send("_run_#{kind}_callbacks", &blk)
-    end
-
-    class Callback
-      @@_callback_sequence = 0
-
-      attr_accessor :filter, :kind, :name, :options, :per_key, :klass
-      def initialize(filter, kind, options, klass)
-        @kind, @klass = kind, klass
-
-        normalize_options!(options)
-
-        @per_key              = options.delete(:per_key)
-        @raw_filter, @options = filter, options
-        @filter               = _compile_filter(filter)
-        @compiled_options     = _compile_options(options)
-        @callback_id          = next_id
-
-        _compile_per_key_options
-      end
-
-      def clone(klass)
-        obj                  = super()
-        obj.klass            = klass
-        obj.per_key          = @per_key.dup
-        obj.options          = @options.dup
-        obj.per_key[:if]     = @per_key[:if].dup
-        obj.per_key[:unless] = @per_key[:unless].dup
-        obj.options[:if]     = @options[:if].dup
-        obj.options[:unless] = @options[:unless].dup
-        obj
-      end
-
-      def normalize_options!(options)
-        options[:if] = Array.wrap(options[:if])
-        options[:unless] = Array.wrap(options[:unless])
-
-        options[:per_key] ||= {}
-        options[:per_key][:if] = Array.wrap(options[:per_key][:if])
-        options[:per_key][:unless] = Array.wrap(options[:per_key][:unless])
-      end
-
-      def next_id
-        @@_callback_sequence += 1
-      end
-
-      def matches?(_kind, _filter)
-        @kind   == _kind &&
-        @filter == _filter
-      end
-
-      def _update_filter(filter_options, new_options)
-        filter_options[:if].push(new_options[:unless]) if new_options.key?(:unless)
-        filter_options[:unless].push(new_options[:if]) if new_options.key?(:if)
-      end
-
-      def recompile!(_options, _per_key)
-        _update_filter(self.options, _options)
-        _update_filter(self.per_key, _per_key)
-
-        @callback_id      = next_id
-        @filter           = _compile_filter(@raw_filter)
-        @compiled_options = _compile_options(@options)
-                            _compile_per_key_options
-      end
-
-      def _compile_per_key_options
-        key_options  = _compile_options(@per_key)
-
-        @klass.class_eval <<-RUBY_EVAL, __FILE__, __LINE__ + 1
-          def _one_time_conditions_valid_#{@callback_id}?
-            true #{key_options[0]}
-          end
-        RUBY_EVAL
-      end
-
-      # This will supply contents for before and around filters, and no
-      # contents for after filters (for the forward pass).
-      def start(key = nil, options = {})
-        object, terminator = (options || {}).values_at(:object, :terminator)
-
-        return if key && !object.send("_one_time_conditions_valid_#{@callback_id}?")
-
-        terminator ||= false
-
-        # options[0] is the compiled form of supplied conditions
-        # options[1] is the "end" for the conditional
-
-        if @kind == :before || @kind == :around
-          if @kind == :before
-            # if condition    # before_save :filter_name, :if => :condition
-            #   filter_name
-            # end
-            filter = <<-RUBY_EVAL
-              unless halted
-                result = #{@filter}
-                halted = (#{terminator})
-              end
-            RUBY_EVAL
-            
-            [@compiled_options[0], filter, @compiled_options[1]].compact.join("\n")
-          else
-            # Compile around filters with conditions into proxy methods
-            # that contain the conditions.
-            #
-            # For `around_save :filter_name, :if => :condition':
-            #
-            # def _conditional_callback_save_17
-            #   if condition
-            #     filter_name do
-            #       yield self
-            #     end
-            #   else
-            #     yield self
-            #   end
-            # end
-
-            name = "_conditional_callback_#{@kind}_#{next_id}"
-            txt, line = <<-RUBY_EVAL, __LINE__ + 1
-              def #{name}(halted)
-                #{@compiled_options[0] || "if true"} && !halted
-                  #{@filter} do
-                    yield self
-                  end
-                else
-                  yield self
-                end
-              end
-            RUBY_EVAL
-            @klass.class_eval(txt, __FILE__, line)
-            "#{name}(halted) do"
-          end
-        end
-      end
-
-      # This will supply contents for around and after filters, but not
-      # before filters (for the backward pass).
-      def end(key = nil, options = {})
-        object = (options || {})[:object]
-
-        return if key && !object.send("_one_time_conditions_valid_#{@callback_id}?")
-
-        if @kind == :around || @kind == :after
-          # if condition    # after_save :filter_name, :if => :condition
-          #   filter_name
-          # end
-          if @kind == :after
-            [@compiled_options[0], @filter, @compiled_options[1]].compact.join("\n")
-          else
-            "end"
-          end
-        end
-      end
-
-      private
-      # Options support the same options as filters themselves (and support
-      # symbols, string, procs, and objects), so compile a conditional
-      # expression based on the options
-      def _compile_options(options)        
-        return [] if options[:if].empty? && options[:unless].empty?
-
-        conditions = []
-
-        unless options[:if].empty?
-          conditions << Array.wrap(_compile_filter(options[:if]))
-        end
-
-        unless options[:unless].empty?
-          conditions << Array.wrap(_compile_filter(options[:unless])).map {|f| "!#{f}"}
-        end
-
-        ["if #{conditions.flatten.join(" && ")}", "end"]
-      end
-
-      # Filters support:
-      #   Arrays::  Used in conditions. This is used to specify
-      #             multiple conditions. Used internally to
-      #             merge conditions from skip_* filters
-      #   Symbols:: A method to call
-      #   Strings:: Some content to evaluate
-      #   Procs::   A proc to call with the object
-      #   Objects:: An object with a before_foo method on it to call
-      #
-      # All of these objects are compiled into methods and handled
-      # the same after this point:
-      #   Arrays::  Merged together into a single filter
-      #   Symbols:: Already methods
-      #   Strings:: class_eval'ed into methods
-      #   Procs::   define_method'ed into methods
-      #   Objects:: 
-      #     a method is created that calls the before_foo method
-      #     on the object.
-      def _compile_filter(filter)
-        method_name = "_callback_#{@kind}_#{next_id}"
-        case filter
-        when Array
-          filter.map {|f| _compile_filter(f)}
-        when Symbol
-          filter
-        when String
-          "(#{filter})"
-        when Proc
-          @klass.send(:define_method, method_name, &filter)
-          return method_name if filter.arity == 0
-
-          method_name << (filter.arity == 1 ? "(self)" : " self, Proc.new ")
-        else
-          @klass.send(:define_method, "#{method_name}_object") { filter }
-
-          _normalize_legacy_filter(kind, filter)
-
-          @klass.class_eval <<-RUBY_EVAL, __FILE__, __LINE__ + 1
-            def #{method_name}(&blk)
-              #{method_name}_object.send(:#{kind}, self, &blk)
-            end
-          RUBY_EVAL
-
-          method_name
-        end
-      end
-
-      def _normalize_legacy_filter(kind, filter)
-        if !filter.respond_to?(kind) && filter.respond_to?(:filter)
-          filter.class_eval(
-            "def #{kind}(context, &block) filter(context, &block) end",
-            __FILE__, __LINE__ - 1)
-        elsif filter.respond_to?(:before) && filter.respond_to?(:after) && kind == :around
-          def filter.around(context)
-            should_continue = before(context)
-            yield if should_continue
-            after(context)
-          end
-        end
-      end
-
-    end
-
-    # An Array with a compile method
-    class CallbackChain < Array
-      def initialize(symbol)
-        @symbol = symbol
-      end
-
-      def compile(key = nil, options = {})
-        method = []
-        method << "halted = false"
-        each do |callback|
-          method << callback.start(key, options)
-        end
-        method << "yield self if block_given? && !halted"
-        reverse_each do |callback|
-          method << callback.end(key, options)
-        end
-        method.compact.join("\n")
-      end
-
-      def clone(klass)
-        chain = CallbackChain.new(@symbol)
-        chain.push(*map {|c| c.clone(klass)})
-      end
-    end
-
-    module ClassMethods
-      #CHAINS = {:before => :before, :around => :before, :after => :after}
-
-      # Make the _run_save_callbacks method. The generated method takes
-      # a block that it'll yield to. It'll call the before and around filters
-      # in order, yield the block, and then run the after filters.
-      # 
-      # _run_save_callbacks do
-      #   save
-      # end
-      #
-      # The _run_save_callbacks method can optionally take a key, which
-      # will be used to compile an optimized callback method for each
-      # key. See #define_callbacks for more information.
-      def _define_runner(symbol)
-        body = send("_#{symbol}_callback").
-          compile(nil, :terminator => send("_#{symbol}_terminator"))
-
-        body, line = <<-RUBY_EVAL, __LINE__ + 1
-          def _run_#{symbol}_callbacks(key = nil, &blk)
-            if key
-              name = "_run__\#{self.class.name.hash.abs}__#{symbol}__\#{key.hash.abs}__callbacks"
-
-              unless respond_to?(name)
-                self.class._create_keyed_callback(name, :#{symbol}, self, &blk)
-              end
-
-              send(name, &blk)
-            else
-              #{body}
-            end
-          end
-        RUBY_EVAL
-
-        undef_method "_run_#{symbol}_callbacks" if method_defined?("_run_#{symbol}_callbacks")
-        class_eval body, __FILE__, line
-      end
-
-      # This is called the first time a callback is called with a particular
-      # key. It creates a new callback method for the key, calculating
-      # which callbacks can be omitted because of per_key conditions.
-      def _create_keyed_callback(name, kind, obj, &blk)
-        @_keyed_callbacks ||= {}
-        @_keyed_callbacks[name] ||= begin
-          str = send("_#{kind}_callback").
-            compile(name, :object => obj, :terminator => send("_#{kind}_terminator"))
-
-          class_eval "def #{name}() #{str} end", __FILE__, __LINE__
-
-          true
-        end
-      end
-
-      # Define callbacks.
-      #
-      # Creates a <name>_callback method that you can use to add callbacks.
-      #
-      # Syntax:
-      #   save_callback :before, :before_meth
-      #   save_callback :after,  :after_meth, :if => :condition
-      #   save_callback :around {|r| stuff; yield; stuff }
-      #
-      # The <name>_callback method also updates the _run_<name>_callbacks
-      # method, which is the public API to run the callbacks.
-      #
-      # Also creates a skip_<name>_callback method that you can use to skip
-      # callbacks.
-      #
-      # When creating or skipping callbacks, you can specify conditions that
-      # are always the same for a given key. For instance, in ActionPack,
-      # we convert :only and :except conditions into per-key conditions.
-      #
-      #   before_filter :authenticate, :except => "index"
-      # becomes
-      #   dispatch_callback :before, :authenticate, :per_key => {:unless => proc {|c| c.action_name == "index"}}
-      #
-      # Per-Key conditions are evaluated only once per use of a given key.
-      # In the case of the above example, you would do:
-      #
-      #   run_dispatch_callbacks(action_name) { ... dispatch stuff ... }
-      #
-      # In that case, each action_name would get its own compiled callback
-      # method that took into consideration the per_key conditions. This
-      # is a speed improvement for ActionPack.
-      def _update_callbacks(name, filters = CallbackChain.new(name), block = nil)
-        type = [:before, :after, :around].include?(filters.first) ? filters.shift : :before
-        options = filters.last.is_a?(Hash) ? filters.pop : {}
-        filters.unshift(block) if block
-
-        callbacks = send("_#{name}_callback")
-        yield callbacks, type, filters, options if block_given?
-
-        _define_runner(name)
-      end
-
-      alias_method :_reset_callbacks, :_update_callbacks
-
-      def set_callback(name, *filters, &block)
-        _update_callbacks(name, filters, block) do |callbacks, type, filters, options|        
-          filters.map! do |filter|
-            # overrides parent class
-            callbacks.delete_if {|c| c.matches?(type, filter) }
-            Callback.new(filter, type, options.dup, self)
-          end
-
-          options[:prepend] ? callbacks.unshift(*filters) : callbacks.push(*filters)
-        end
-      end
-
-      def skip_callback(name, *filters, &block)
-        _update_callbacks(name, filters, block) do |callbacks, type, filters, options|
-          filters.each do |filter|
-            callbacks = send("_#{name}_callback=", callbacks.clone(self))
-
-            filter = callbacks.find {|c| c.matches?(type, filter) }
-
-            if filter && options.any?
-              filter.recompile!(options, options[:per_key] || {})
-            else
-              callbacks.delete(filter)
-            end
-          end
-        end
-      end
-
-      def define_callbacks(*symbols)
-        terminator = symbols.pop if symbols.last.is_a?(String)
-        symbols.each do |symbol|
-          extlib_inheritable_accessor("_#{symbol}_terminator") { terminator }
-
-          extlib_inheritable_accessor("_#{symbol}_callback") do
-            CallbackChain.new(symbol)
-          end
-
-          _define_runner(symbol)
-          
-          # Define more convenient callback methods
-          # set_callback(:save, :before) becomes before_save
-          [:before, :after, :around].each do |filter|
-            self.class_eval <<-RUBY_EVAL, __FILE__, __LINE__ + 1
-              def self.#{filter}_#{symbol}(*symbols, &blk)
-                _alias_callbacks(symbols, blk) do |callback, options|
-                  set_callback(:#{symbol}, :#{filter}, callback, options)
-                end
-              end
-            RUBY_EVAL
-          end
-        end
-      end
-      
-      def _alias_callbacks(callbacks, block)
-        options = callbacks.last.is_a?(Hash) ? callbacks.pop : {}
-        callbacks.push(block) if block
-        callbacks.each do |callback|
-          yield callback, options
-        end
-      end
-    end
-  end
-end