activecouch 0.1.0

data/lib/active_couch/callbacks.rb

@@ -0,0 +1,81 @@
+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 sets 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
+      return false if callback(:before_save) == false
+      result = save_without_callbacks
+      callback(:after_save)
+      result
+    end
+    private :save_with_callbacks
+    
+    def delete_with_callbacks
+      return false if callback(:before_delete) == false
+      result = delete_without_callbacks
+      callback(:after_delete)
+      result
+    end
+    private :delete_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,155 @@
+# 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:
+
+  # 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 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,17 @@
+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 assign a object of an invalid type as an ActiveCouch attribute.
+  class InvalidCouchTypeError < ActiveCouchError
+  end
+
+  # Raised when trying to get or set a non-existent attribute.
+  class AttributeMissingError < ActiveCouchError
+  end
+end

data/lib/active_couch/migrations.rb

@@ -0,0 +1,3 @@
+require 'active_couch/migrations/errors.rb'
+require 'active_couch/migrations/migration.rb'
+require 'active_couch/migrations/migrator.rb'

data/lib/active_couch/migrations/errors.rb

@@ -0,0 +1,4 @@
+module ActiveCouch
+  class MigrationError < StandardError; end
+  class InvalidFilter < MigrationError; end
+end

data/lib/active_couch/migrations/migration.rb

@@ -0,0 +1,77 @@
+require 'json'
+
+module ActiveCouch
+  class Migration
+    class << self # Class Methods
+      # Class instance variables
+      @view = nil; @database = nil
+      # These are accessible only at class-scope
+      attr_accessor :view, :database  
+      # Set the view name and database name in the define method and then execute
+      # the block
+      def define(*args)
+        # Borrowed from ActiveRecord::Base.find
+        first = args.slice!(0); second = args.slice!(0)
+        # Based on the classes of the arguments passed, set instance variables
+        case first.class.to_s
+          when 'String', 'Symbol' then view = first.to_s;  options = second || {}
+          when 'Hash' then  view = ''; options = first
+          else raise ArgumentError, "Wrong arguments used to define the view"
+        end
+        # Define the view and database instance variables based on the args passed
+        # Don't care if the key doesn't exist
+        @view, @database = get_view(view), options[:for_db]
+        # Block being called to set other parameters for the Migration
+        yield if block_given?
+      end
+      
+      def with_key(key = "")
+        @key = key unless key.nil?
+      end
+      
+      def with_filter(filter = "")
+        @filter = filter unless filter.nil?
+      end
+      
+      def include_attributes(*attrs)
+        @attrs = attrs unless attrs.nil? || !attrs.is_a?(Array)
+      end
+      
+      def view_js
+        results_hash = {"_id" => "_design/#{@view}", "language" => "text/javascript"}
+        results_hash["views"] =  { @view => view_function }
+        # Returns the JSON format for the function
+        results_hash.to_json
+      end
+
+private
+      def include_attrs
+        attrs = "doc"
+        unless @attrs.nil?
+          js = @attrs.inject([]) {|result, att| result << "#{att}: doc.#{att}"}
+          attrs = "{#{js.join(' , ')}}" if js.size > 0
+        end
+        attrs
+      end
+      
+      def get_view(view)
+        view_name = view
+        view_name = Inflector.underscore("#{self}") if view.nil? || view.length == 0
+        view_name  
+      end
+
+      def view_function
+        filter_present = !@filter.nil? && @filter.length > 0
+
+        js = "function(doc) { "
+        js << "if(#{@filter}) { " if filter_present
+        js << "map(doc.#{@key}, #{include_attrs});"
+        js << " } " if filter_present
+        js << " }"
+        
+        js
+      end
+
+    end # End Class Methods
+  end # End Class Migration
+end # End module ActiveCouch

data/lib/active_couch/migrations/migrator.rb

@@ -0,0 +1,53 @@
+# TODO
+# - might consider moving create_database and delete_database to an adapter type class to encapsulate CouchDB semantics
+#   and responses.
+module ActiveCouch
+  class Migrator
+    class << self # Class methods
+      def migrate(site, migration)
+        if migration.view.nil? || migration.database.nil?
+          raise ActiveCouch::MigrationError, "Both the view and the database need to be defined in your migration"
+        end
+
+        conn = Connection.new(site)
+        # Migration 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.put("/#{migration.database}/_design/#{migration.view}", migration.view_js)
+        case response.code
+        when '201'
+          true # 201 = success
+        else
+          raise ActiveCouch::MigrationError, "Error migrating view - got HTTP response #{response.code}"
+        end
+      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::MigrationError, 'Database exists'
+        else
+          raise ActiveCouch::MigrationError, "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 '202'
+          true # 202 = success
+        when '404'
+          raise ActiveCouch::MigrationError, "Database '#{name}' does not exist" # 404 = database doesn't exist
+        else
+          raise ActiveCouch::MigrationError, "Error creating database - got HTTP response #{response.code}"
+        end
+      end
+    end
+  end
+end

data/lib/active_couch/support.rb

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

data/lib/active_couch/support/extensions.rb

@@ -0,0 +1,92 @@
+module ActiveCouch
+
+  String.class_eval do
+    require 'cgi'
+    def url_encode
+      CGI.escape("\"#{self.to_s}\"")
+    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 : Inflector.constantize(parent_name)
+    end
+    
+    # Encapsulates the common pattern of:
+    #
+    #   alias_method :foo_without_feature, :foo
+    #   alias_method :foo, :foo_with_feature
+    #
+    # With this, you simply do:
+    #
+    #   alias_method_chain :foo, :feature
+    #
+    # And both aliases are set up for you.
+    #
+    # Query and bang methods (foo?, foo!) keep the same punctuation:
+    #
+    #   alias_method_chain :foo?, :feature
+    #
+    # is equivalent to
+    #
+    #   alias_method :foo_without_feature?, :foo?
+    #   alias_method :foo?, :foo_with_feature?
+    #
+    # so you can safely chain foo, foo?, and foo! with the same feature.
+    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