peleteiro-activecouch 0.2.1

data/lib/active_couch/callbacks.rb

@@ -0,0 +1,89 @@
+module ActiveCouch
+  module Callbacks
+    CALLBACKS = %w(before_save after_save before_delete after_delete)
+    
+    def self.included(base)
+      # Alias methods which will have callbacks, (for now only save and delete).
+      # This creates 2 pairs of methods: save_with_callbacks, save_without_callbacks,
+      # delete_with_callbacks, delete_without_callbacks
+      #
+      # save_without_callbacks and delete_without_callbacks
+      # have the same behaviour as the save and delete methods, respectively
+      [:save, :delete].each do |method|
+        base.send :alias_method_chain, method, :callbacks
+      end
+      
+      CALLBACKS.each do |method|
+        base.class_eval <<-"end_eval"
+          def self.#{method}(*callbacks, &block)
+            callbacks << block if block_given?
+            # Assumes that the default value for the callbacks hash in the
+            # including class is an empty array
+            self.callbacks[#{method.to_sym.inspect}] = self.callbacks[#{method.to_sym.inspect}] + callbacks
+          end
+        end_eval
+      end
+    end # end method self.included 
+    
+    def before_save() end
+    
+    def after_save() end
+      
+    def before_delete() end
+      
+    def after_delete() end
+    
+    def save_with_callbacks(opts = {})
+      return false if callback(:before_save) == false
+      result = save_without_callbacks(opts)
+      callback(:after_save)
+      result
+    end
+    private :save_with_callbacks
+    
+    def delete_with_callbacks(opts = {})
+      return false if callback(:before_delete) == false
+      result = delete_without_callbacks(opts)
+      callback(:after_delete)
+      result
+    end
+    private :delete_with_callbacks
+    
+    def find_with_callbacks
+      return false if callback(:before_find) == false
+      result = find_without_callbacks
+      callback(:after_find)
+      result
+    end
+    private :find_with_callbacks
+    
+    private
+      def callback(method)
+        callbacks_for(method).each do |callback|
+          result = case callback
+            when Symbol
+              self.send(callback)
+            when String
+              eval(callback, binding)
+            when Proc, Method
+              callback.call(self)
+            else
+              if callback.respond_to?(method)
+                callback.send(method, self)
+              else
+                raise ActiveCouchError, "Callbacks must be a symbol denoting the method to call, a string to be evaluated, a block to be invoked, or an object responding to the callback method."
+              end
+          end
+          return false if result == false
+        end
+
+        result = send(method) if respond_to?(method)
+
+        return result
+      end
+      
+      def callbacks_for(method)
+        self.class.callbacks[method.to_sym]
+      end
+  end # end module Callbacks
+end # end module ActiveCouch

data/lib/active_couch/connection.rb

@@ -0,0 +1,164 @@
+# Connection class borrowed from ActiveResource
+require 'net/https'
+require 'date'
+require 'time'
+require 'uri'
+require 'benchmark'
+
+module ActiveCouch
+  class ConnectionError < StandardError # :nodoc:
+    attr_reader :response
+
+    def initialize(response, message = nil)
+      @response = response
+      @message  = message
+    end
+
+    def to_s
+      "Failed with #{response.code} #{response.message if response.respond_to?(:message)}"
+    end
+  end
+
+  # 3xx Redirection
+  class Redirection < ConnectionError # :nodoc:
+    def to_s; response['Location'] ? "#{super} => #{response['Location']}" : super; end    
+  end 
+
+  # 4xx Client Error
+  class ClientError < ConnectionError; end # :nodoc:
+  
+  # 404 Not Found
+  class ResourceNotFound < ClientError; end # :nodoc:
+  
+  # 409 Conflict
+  class ResourceConflict < ClientError; end # :nodoc:
+
+  # 412 Precondition Failed - this is returned when there is an update conflict (usually means revisions don't match).
+  class UpdateConflict < ClientError # :nodoc:
+    def to_s
+      "Failed with #{response.code} #{response.message if response.respond_to?(:message)}. Body: #{response.body}"
+    end
+  end
+
+  # 5xx Server Error
+  class ServerError < ConnectionError; end # :nodoc:
+
+  # 405 Method Not Allowed
+  class MethodNotAllowed < ClientError # :nodoc:
+    def allowed_methods
+      @response['Allow'].split(',').map { |verb| verb.strip.downcase.to_sym }
+    end
+  end
+
+  # Class to handle connections to remote web services.
+  # This class is used by ActiveCouch::Base to interface with REST
+  # services.
+  class Connection
+    attr_reader :site
+
+    class << self
+      def requests
+        @@requests ||= []
+      end
+    end
+
+    # The +site+ parameter is required and will set the +site+
+    # attribute to the URI for the remote resource service.
+    def initialize(site)
+      raise ArgumentError, 'Missing site URI' unless site
+      init_site_with_path(site)
+    end
+
+    # Set URI for remote service.
+    def site=(site)
+      @site = site.is_a?(URI) ? site : URI.parse(site)
+    end
+
+    # Execute a GET request.
+    # Used to get (find) resources.
+    def get(path, headers = {})
+      request(:get, path, build_request_headers(headers)).body
+    end
+
+    # Execute a DELETE request (see HTTP protocol documentation if unfamiliar).
+    # Used to delete resources.
+    def delete(path, headers = {})
+      request(:delete, path, build_request_headers(headers))
+    end
+
+    # Execute a PUT request (see HTTP protocol documentation if unfamiliar).
+    # Used to update resources.
+    def put(path, body = '', headers = {})
+      request(:put, path, body.to_s, build_request_headers(headers))
+    end
+
+    # Execute a POST request.
+    # Used to create new resources.
+    def post(path, body = '', headers = {})
+      request(:post, path, body.to_s, build_request_headers(headers))
+    end
+
+
+    private
+      # Makes request to remote service.
+      def request(method, path, *arguments)
+        result = nil
+        time = Benchmark.realtime { result = http.send(method, path, *arguments) }
+        handle_response(result)
+      end
+
+      # Handles response and error codes from remote service.
+      def handle_response(response)
+        case response.code.to_i
+          when 301,302
+            raise(Redirection.new(response))
+          when 200...400
+            response
+          when 404
+            raise(ResourceNotFound.new(response))
+          when 405
+            raise(MethodNotAllowed.new(response))
+          when 409
+            raise(ResourceConflict.new(response))
+          when 412
+            raise(UpdateConflict.new(response))
+          when 422
+            raise(ResourceInvalid.new(response))
+          when 401...500
+            raise(ClientError.new(response))
+          when 500...600
+            raise(ServerError.new(response))
+          else
+            raise(ConnectionError.new(response, "Unknown response code: #{response.code}"))
+        end
+      end
+
+      # Creates new Net::HTTP instance for communication with
+      # remote service and resources.
+      def http
+        http             = Net::HTTP.new(@site.host, @site.port)
+        http.use_ssl     = @site.is_a?(URI::HTTPS)
+        http.verify_mode = OpenSSL::SSL::VERIFY_NONE if http.use_ssl
+        http
+      end
+
+      def default_header
+        @default_header ||= { 'Content-Type' => 'application/json' }
+      end
+      
+      # Builds headers for request to remote service.
+      def build_request_headers(headers)
+        authorization_header.update(default_header).update(headers)
+      end
+      
+      # Sets authorization header; authentication information is pulled from credentials provided with site URI.
+      def authorization_header
+        (@site.user || @site.password ? { 'Authorization' => 'Basic ' + ["#{@site.user}:#{ @site.password}"].pack('m').delete("\r\n") } : {})
+      end
+      
+      def init_site_with_path(site)
+        site = "#{site}:5984" if site.is_a?(String) && (site =~ /http\:\/\/(.*?)\:(\d+)/).nil?
+        @site = URI.parse(site)
+      end
+  end
+end

data/lib/active_couch/errors.rb

@@ -0,0 +1,13 @@
+module ActiveCouch
+  # Base exception class for all ActiveCouch errors.
+  class ActiveCouchError < StandardError
+  end
+
+  # Raised when there is a configuration error (duh).
+  class ConfigurationError < ActiveCouchError
+  end
+
+  # Raised when trying to get or set a non-existent attribute.
+  class AttributeMissingError < ActiveCouchError
+  end
+end

data/lib/active_couch/support.rb

@@ -0,0 +1,3 @@
+require 'active_couch/support/inflector'
+require 'active_couch/support/extensions'
+require 'active_couch/support/exporter'

data/lib/active_couch/support/exporter.rb

@@ -0,0 +1,97 @@
+# TODO
+# - might consider moving create_database and delete_database to an adapter type class to encapsulate CouchDB semantics
+#   and responses.
+module ActiveCouch
+  class Exporter
+    class << self # Class methods
+
+      def all_databases(site)
+        conn = Connection.new(site)
+        JSON.parse(conn.get("/_all_dbs"))
+      end
+      
+      def export(site, view, opts = {})
+        existing_view = {}
+        if view.name.nil? || (view.database.nil? && opts[:database].nil?)
+          raise ActiveCouch::ViewError, "Both the name and the database need to be defined in your view"
+        end
+        # If the database is not defined in the view, it can be supported
+        # as an option to the export method
+        database_name = opts[:database] || view.database
+        conn = Connection.new(site)
+        # The view function for a view with name 'by_name' and database 'activecouch_test' should be PUT to
+        # http://#{host}:#{port}/activecouch_test/_design/by_name.
+        if(view_json = exists?(site, "/#{database_name}/_design/#{view.name}"))
+          existing_view = JSON.parse(view_json)
+        end
+        response = conn.put("/#{database_name}/_design/#{view.name}", view.to_json(existing_view))
+        case response.code
+        when '201'
+          true # 201 = success
+        else
+          raise ActiveCouch::ViewError, "Error exporting view - got HTTP response #{response.code}"
+        end
+      end
+
+      def delete(site, view, opts = {})
+        rev = nil
+        if view.name.nil? || (view.database.nil? && opts[:database].nil?)
+          raise ActiveCouch::ViewError, "Both the name and the database need to be defined in your view"
+        end
+        # If the database is not defined in the view, it can be supported
+        # as an option to the export method
+        database_name = opts[:database] || view.database
+        conn = Connection.new(site)
+        if(view_json = exists?(site, "/#{database_name}/_design/#{view.name}"))
+          rev = JSON.parse(view_json)['_rev']
+        end
+        # The view function for a view with name 'by_name' and database 'activecouch_test' should be PUT to
+        # http://#{host}:#{port}/activecouch_test/_design/by_name.
+        response = conn.delete("/#{database_name}/_design/#{view.name}?rev=#{rev}")
+        if response.code =~ /20[0,2]/
+          true # 20[0,2] = success
+        else
+          raise ActiveCouch::ViewError, "Error deleting view - got HTTP response #{response.code}"
+        end
+      end
+
+      def exists?(site, name)
+        conn = Connection.new(site)
+        response = conn.get("#{name}")
+        response
+      rescue ActiveCouch::ResourceNotFound
+        false
+      end
+
+      def create_database(site, name)
+        conn = Connection.new(site)
+        response = conn.put("/#{name}", "{}")
+
+        case response.code
+        when '201' # 201 = success
+          true
+        when '409' # 409 = database already exists
+          raise ActiveCouch::ViewError, 'Database exists'
+        else
+          raise ActiveCouch::ViewError, "Error creating database - got HTTP response #{response.code}"
+        end
+      end
+
+      def delete_database(site, name)
+        conn = Connection.new(site)
+        response = conn.delete("/#{name}")
+
+        case response.code
+        when '200'
+        when '201'
+        when '202'
+          true # 201 = success
+        when '404'
+          raise ActiveCouch::ViewError, "Database '#{name}' does not exist" # 404 = database doesn't exist
+        else
+          raise ActiveCouch::ViewError, "Error creating database - got HTTP response #{response.code}"
+        end
+      end
+    end
+  end
+end

data/lib/active_couch/support/extensions.rb

@@ -0,0 +1,86 @@
+module ActiveCouch
+
+  Symbol.class_eval do
+    def singularize; ActiveCouch::Inflector.singularize(self); end
+  end
+
+  String.class_eval do
+    require 'cgi'
+    def url_encode; CGI.escape("\"#{self.to_s}\""); end
+    # Delegate to Inflector
+    def singularize; ActiveCouch::Inflector.singularize(self); end
+    def demodulize; ActiveCouch::Inflector.demodulize(self); end
+    def pluralize; ActiveCouch::Inflector.pluralize(self); end
+    def underscore; ActiveCouch::Inflector.underscore(self); end
+    def classify; ActiveCouch::Inflector.classify(self); end
+    def constantize; ActiveCouch::Inflector.constantize(self); end
+  end
+
+  Array.class_eval do
+    def extract_options!
+      last.is_a?(::Hash) ? pop : {}
+    end
+  end  
+  
+  Hash.class_eval do
+    # Flatten on the array removes everything into *one* single array,
+    # so {}.to_a.flatten sometimes won't work nicely because a value might be an array
+    # So..introducing flatten for Hash, so that arrays which are values (to keys)
+    # are retained
+    def flatten
+      (0...self.size).inject([]) {|k,v| k << self.keys[v]; k << self.values[v]}
+    end 
+  end
+
+  Object.class_eval do
+    def get_class(name)
+      # From 'The Ruby Way Second Edition' by Hal Fulton
+      # This is to get nested class for e.g. A::B::C
+      name.split("::").inject(Object) {|x,y| x.const_get(y)}
+    end
+
+    # The singleton class.
+    def metaclass; class << self; self; end; end
+    def meta_eval &blk; metaclass.instance_eval &blk; end
+
+    # Adds methods to a metaclass.
+    def meta_def name, &blk
+      meta_eval { define_method name, &blk }
+    end
+
+    # Defines an instance method within a class.
+    def class_def name, &blk
+      class_eval { define_method name, &blk }
+    end
+  end
+  
+  Module.module_eval do
+    # Return the module which contains this one; if this is a root module, such as
+    # +::MyModule+, then Object is returned.
+    def parent
+      parent_name = name.split('::')[0..-2] * '::'
+      parent_name.empty? ? Object : ActiveCouch::Inflector.constantize(parent_name)
+    end
+    
+    def alias_method_chain(target, feature)
+      # Strip out punctuation on predicates or bang methods since
+      # e.g. target?_without_feature is not a valid method name.
+      aliased_target, punctuation = target.to_s.sub(/([?!=])$/, ''), $1
+      yield(aliased_target, punctuation) if block_given?
+
+      with_method, without_method = "#{aliased_target}_with_#{feature}#{punctuation}", "#{aliased_target}_without_#{feature}#{punctuation}"
+
+      alias_method without_method, target
+      alias_method target, with_method
+
+      case
+        when public_method_defined?(without_method)
+          public target
+        when protected_method_defined?(without_method)
+          protected target
+        when private_method_defined?(without_method)
+          private target
+      end
+    end
+  end
+end