yssk22-couch_resource 0.1.0

data/lib/couch_resource/callbacks.rb

@@ -0,0 +1,103 @@
+require 'rubygems'
+require 'json'
+
+module CouchResource
+  # Callbacks are hooks similar to ActiveRecord::Callbacks
+  #
+  # * (-) <tt>save</tt>
+  # * (-) <tt>valid</tt>
+  # * (1) <tt>before_validation</tt>
+  # * (2) <tt>before_validation_on_create</tt>
+  # * (-) <tt>validate</tt>
+  # * (-) <tt>validate_on_create</tt>
+  # * (3) <tt>after_validation</tt>
+  # * (4) <tt>after_validation_on_create</tt>
+  # * (5) <tt>before_save</tt>
+  # * (6) <tt>before_create</tt>
+  # * (-) <tt>create</tt>
+  # * (7) <tt>after_create</tt>
+  # * (8) <tt>after_save</tt>
+  #
+  module Callbacks
+    CALLBACKS = %w(
+      after_find after_initialize before_save after_save before_create after_create before_update after_update before_validation
+      after_validation before_validation_on_create after_validation_on_create before_validation_on_update
+      after_validation_on_update before_destroy after_destroy
+    )
+
+    def self.included(base)
+      [:create_or_update, :valid?, :create, :update, :destroy].each do |method|
+        base.send :alias_method_chain, method, :callbacks
+      end
+
+      base.send(:include, ActiveSupport::Callbacks)
+      [:save, :create, :update, :validation, :validation_on_create, :validation_on_update, :destroy].each do |method|
+        base.define_callbacks "before_#{method}".to_sym,  "after_#{method}".to_sym
+      end
+
+    end
+
+    [:save, :create, :update, :validation, :validation_on_create, :validation_on_update, :destroy].each do |method|
+      module_eval <<-EOS
+      def before_#{method}; end
+      def after_#{method};  end
+EOS
+    end
+
+    private
+    def create_or_update_with_callbacks
+      return false if invoke_callbacks(:before_save) == false
+      result = create_or_update_without_callbacks
+      invoke_callbacks(:after_save)
+      result
+    end
+
+    def create_with_callbacks
+      return false if invoke_callbacks(:before_create) == false
+      result = create_without_callbacks
+      invoke_callbacks(:after_create)
+      result
+    end
+
+    def update_with_callbacks
+      return false if invoke_callbacks(:before_update) == false
+      result = update_without_callbacks
+      invoke_callbacks(:after_update)
+      result
+    end
+
+    def valid_with_callbacks?
+      return false if invoke_callbacks(:before_validation) == false
+      if new_record? then
+        return false if invoke_callbacks(:before_validation_on_create) == false
+      else
+        return false if invoke_callbacks(:before_validation_on_update) == false
+      end
+
+      result = valid_without_callbacks?
+
+      invoke_callbacks(:after_validation)
+      if new_record? then
+        invoke_callbacks(:after_validation_on_create)
+      else
+        invoke_callbacks(:after_validation_on_update)
+      end
+      return result
+    end
+
+    def destroy_with_callbacks
+      return false if invoke_callbacks(:before_destroy) == false
+      result = destroy_without_callbacks
+      invoke_callbacks(:after_destroy)
+      result
+    end
+
+    def invoke_callbacks(callback_name)
+      # invoke member method
+      return false if send(callback_name) == false
+      # invoke callbacks defined by using ActiveSupport::Callbacks
+      run_callbacks(callback_name)
+    end
+
+  end
+end

data/lib/couch_resource/connection.rb

@@ -0,0 +1,194 @@
+require 'rubygems'
+require 'active_support'
+require 'json'
+require 'net/https'
+require 'uri'
+require File.join(File.dirname(__FILE__), "error")
+
+module CouchResource
+  class ConnectionError < CouchResourceError # :nodoc:
+    attr_reader :request
+    attr_reader :response
+    attr_reader :json
+
+    def initialize(request, response, message = nil)
+      @request  = request
+      @response = response
+      @json     = JSON(response.body) rescue nil
+      @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:
+
+  # 400 Bad Request
+  class BadRequest < ClientError; end # :nodoc
+
+  # 401 Unauthorized
+  class UnauthorizedAccess < ClientError; end # :nodoc
+
+  # 403 Forbidden
+  class ForbiddenAccess < ClientError; end # :nodoc
+
+  # 404 Not Found
+  class ResourceNotFound < ClientError; end # :nodoc:
+
+  # 409 Conflict
+  class ResourceConflict < ClientError; end # :nodoc:
+
+  # 412 Precondition Failed
+  class PreconditionFailed < ClientError; 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 Connection
+    attr_reader :site, :user, :password, :timeout
+    attr_writer :user, :password, :timeout
+
+    def initialize(site)
+      raise ArgumentError, 'Missing site URI' unless site
+      @user = @password = nil
+      self.site = site
+    end
+
+    def site=(uri_string)
+      @site = uri_string.is_a?(URI) ? uri_string : URI.parse(uri_string)
+      @user = URI.decode(@site.user) if @site.user
+      @password = URI.decode(@site.password) if @site.password
+    end
+
+    def get(path, headers = {})
+      req = Net::HTTP::Get.new(path)
+      set_request_headers(req, headers)
+      request(req)
+    end
+
+    def delete(path, headers = {})
+      req = Net::HTTP::Delete.new(path)
+      set_request_headers(req, headers)
+      request(req)
+    end
+
+    def put(path, body='', headers = {})
+      req = Net::HTTP::Put.new(path)
+      set_request_headers(req, headers)
+      req.body = body
+      request(req)
+    end
+
+    def post(path, body='', headers = {})
+      req = Net::HTTP::Post.new(path)
+      set_request_headers(req, headers)
+      req.body = body
+      request(req)
+    end
+
+    def head(path, body='', headers = {})
+      req = Net::HTTP::Head.new(path)
+      request(req)
+    end
+
+    private
+    def request(req)
+      res = http.request(req)
+      handle_response(req, res)
+    end
+
+    # Handles response and error codes from remote service.
+    def handle_response(request, response)
+      case response.code.to_i
+      when 301,302
+        raise(Redirection.new(request, response))
+      when 200...400
+        response
+      when 400
+        raise(BadRequest.new(request, response))
+      when 401
+        raise(UnauthorizedAccess.new(request, response))
+      when 403
+        raise(ForbiddenAccess.new(request, response))
+      when 404
+        raise(ResourceNotFound.new(request, response))
+      when 405
+        raise(MethodNotAllowed.new(request, response))
+      when 409
+        raise(ResourceConflict.new(request, response))
+      when 412
+        raise(PreconditionFailed.new(request, response))
+      when 422
+        raise(ResourceInvalid.new(request, response))
+      when 401...500
+        raise(ClientError.new(request, response))
+      when 500...600
+        raise(ServerError.new(request, response))
+      else
+        raise(ConnectionError.new(request, response, "Unknown response code: #{response.code}"))
+      end
+      begin
+        if response.body.blank?
+          nil
+        else
+          hash = JSON(response.body)
+          normalize_hash(hash)
+        end
+      rescue JSON::ParserError => e
+        raise(ConnectionError.new(request, response, "Invalid json response: #{e.body}"))
+      end
+    end
+
+    def normalize_hash(hash)
+      hash.inject(HashWithIndifferentAccess.new({})) do |normalized, (k, v)|
+        v = normalize_hash(v) if v.is_a?(Hash)
+        normalized[k.to_sym] = v
+        normalized
+      end
+    end
+
+    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.read_timeout = @timeout if @timeout
+      http
+    end
+
+    def default_header
+      @default_header ||= {
+        "Accept"       => "application/json",
+        'Content-Type' => "application/json"
+      }
+    end
+
+
+    def set_request_headers(request, headers={})
+      headers = authorization_header.update(default_header).update(headers)
+      headers.each do |k,v|
+        request[k.to_s] = v
+      end
+    end
+
+    # Sets authorization header
+    def authorization_header
+      (@user || @password ? { 'Authorization' => 'Basic ' + ["#{@user}:#{ @password}"].pack('m').delete("\r\n") } : {})
+    end
+
+  end
+end

data/lib/couch_resource/error.rb

@@ -0,0 +1,3 @@
+module CouchResource
+  class CouchResourceError < StandardError; end
+end

data/lib/couch_resource/struct.rb

@@ -0,0 +1,340 @@
+require 'rubygems'
+require 'active_support'
+require 'json'
+module CouchResource
+  module Struct
+    def self.included(base)
+      base.send(:extend,  ClassMethods)
+      base.send(:include, InstanceMethods)
+    end
+
+    module ClassMethods
+      #
+      # define a string attribtue
+      # options are :
+      # * <tt>:validates</tt> - see CouchResource::Validations
+      #
+      def string(name, option={})
+        option[:is_a] = :string
+        register_attribute_member(name, option)
+        define_attribute_accessor(name, option)
+        define_validations(name, option)
+      end
+
+      #
+      # define a number attribute
+      # options are :
+      # * <tt>:validates</tt> - see CouchResource::Validations
+      #
+      def number(name, option={})
+        option[:is_a] = :number
+        register_attribute_member(name, option)
+        define_attribute_accessor(name, option)
+        define_validations(name, option)
+      end
+
+      #
+      # define a boolean attribute
+      # options are :
+      # * <tt>:validates</tt> - see CouchResource::Validations
+      #
+      def boolean(name, option={})
+        option[:is_a] = :boolean
+        register_attribute_member(name, option)
+        define_attribute_accessor(name, option)
+        method = <<-EOS
+          def #{name}?
+            get_attribute(:#{name})
+          end
+EOS
+        class_eval(method, __FILE__, __LINE__)
+        define_validations(name, option)
+      end
+
+      #
+      # define a array attribute, each of which elements is a primitive (one of string, number, array, boolean or hash) object
+      # options are :
+      #
+      def array(name, option={})
+        option[:is_a] = :array
+        register_attribute_member(name, option)
+        define_attribute_accessor(name, option)
+        define_validations(name, option)
+      end
+
+      #
+      # define a collection attribute, each of which elements is an object specified by the <tt>:is_a</tt> option.
+      # options are :
+      # * <tt>:each</tt> - set the class to encode/decode each of Hash object (default is :hash, which means no encoding/decoding will be processed)
+      # * <tt>:validates</tt> - see CouchResource::Validations
+      #
+      def collection(name, option={})
+        option = {
+          :each => :hash
+        }.update(option)
+        option[:is_a] = :collection
+        register_attribute_member(name, option)
+        define_attribute_accessor(name, option)
+        define_validations(name, option)
+      end
+
+      #
+      # define a object attribute
+      # <tt>options</tt> are :
+      # * <tt>:is_a</tt> - set the class to encode/decode Hash object (default is :hash, which means no encoding/decoding will be processed)
+      # * <tt>:validates</tt> - see CouchResource::Validations
+      #
+      def object(name, option={})
+        unless option.has_key?(:is_a)
+          option[:is_a] = :hash
+        end
+        register_attribute_member(name, option)
+        define_attribute_accessor(name, option)
+        define_validations(name, option)
+      end
+
+      #
+      # define a datetime object (extension of string)
+      # options are :
+      # * <tt>:validates</tt> - see CouchResource::Validations
+      #
+      def datetime(name, option={})
+        option[:is_a] = :datetime
+        register_attribute_member(name, option)
+        define_attribute_accessor(name, option)
+        define_validations(name, option)
+      end
+
+
+      def from_hash(hash)
+        hash ||= {}
+        hash.symbolize_keys!
+        instance = self.new
+        (read_inheritable_attribute(:attribute_members) || {}).each do |name, option|
+          instance.set_attribute(name, hash[name.to_sym])
+        end
+        instance
+      end
+
+      private
+      def register_attribute_member(name, option = {})
+        attribute_members = read_inheritable_attribute(:attribute_members)
+        attribute_members ||= HashWithIndifferentAccess.new({})
+        attribute_members[name] = option
+        write_inheritable_attribute(:attribute_members, attribute_members)
+      end
+
+      def define_attribute_accessor(name, option={})
+        define_attribute_read_accessor(name, option)
+        define_attribute_write_accessor(name, option)
+      end
+
+      def define_attribute_read_accessor(name, option={})
+        method = <<-EOS
+          def #{name}
+            get_attribute(:#{name})
+          end
+          def #{name}_before_type_cast
+            get_attribute_before_type_cast(:#{name})
+          end
+EOS
+        class_eval(method, __FILE__, __LINE__)
+      end
+
+      def define_attribute_write_accessor(name, option={})
+        method = <<-EOS
+          def #{name}=(value)
+            set_attribute(:#{name}, value)
+          end
+EOS
+        class_eval(method, __FILE__, __LINE__)
+      end
+
+      def define_validations(name, option={})
+        (option[:validates] || []).each do |validation_type, validate_option|
+          args = validate_option.nil? ? [name] : [name, validate_option]
+          case validation_type.to_sym
+          when :each
+            proc = validate_option[:proc]
+            send("validates_each", *args) do |record, attr, value|
+              proc.call(record, attr, value) if proc
+            end
+          when :confirmation_of, :presense_of, :length_of, :size_of, :format_of,
+            :inclusion_of, :exclusion_of, :numericality_of, :children_of
+            send("validates_#{validation_type}", *args)
+          else
+            raise ArgumentError, "invalid validation type (#{validation_type})"
+          end
+        end
+      end
+    end
+
+    module InstanceMethods
+      def [](name)
+        get_attribute(name)
+      end
+
+      def []=(name, value)
+        set_attribute(name, value)
+      end
+
+      def get_attribute_option(attr_name)
+        (self.class.read_inheritable_attribute(:attribute_members) || {})[attr_name]
+      end
+
+      def set_attribute(name, value)
+        @attributes ||= HashWithIndifferentAccess.new({})
+        # inplicit type cast
+        attribute_members = self.class.read_inheritable_attribute(:attribute_members) || {}
+        if attribute_members.has_key?(name)
+          option = attribute_members[name]
+          if value.nil?
+            @attributes[name] = nil
+          else
+            if option[:allow_nil] && value.blank?
+              @attributes[name] = nil
+            else
+              klass = option[:is_a]
+              @attributes[name] = case klass
+                                  when :string, :number, :boolean, :array, :hash, :datetime
+                                    self.send("type_cast_for_#{klass}_attributes", value)
+                                  when :collection
+                                    self.send("type_cast_for_collection_attributes", value, option[:each])
+                                  else
+                                    self.send("type_cast_for_object_attributes", value, klass)
+                                  end
+            end
+          end
+        else
+          @attributes[name] = nil
+        end
+        value
+      end
+
+
+      def get_attribute(name)
+        value = get_attribute_before_type_cast(name)
+        attribute_members = self.class.read_inheritable_attribute(:attribute_members) || {}
+        if attribute_members.has_key?(name)
+          value = @attributes[name]
+          option = attribute_members[name]
+          value
+          #if value.nil?
+          #  nil
+          #else
+          #  klass = option[:is_a]
+          #  case klass
+          #  when :string, :number, :boolean, :array, :hash, :datetime
+          #    self.send("type_cast_for_#{klass}_attributes", value)
+          #  when :collection
+          #    self.send("type_cast_for_collection_attributes", value, option[:each])
+          #  else
+          #    self.send("type_cast_for_object_attributes", value, klass)
+          #  end
+          #end
+        else
+          nil
+        end
+      end
+
+      def get_attribute_before_type_cast(name)
+        @attributes ||= HashWithIndifferentAccess.new({})
+        @attributes[name]
+      end
+
+      def to_hash
+        hash = HashWithIndifferentAccess.new({ :class => self.class.name })
+        (self.class.read_inheritable_attribute(:attribute_members) || {}).each do |name, option|
+          klass = option[:is_a]
+          value = get_attribute(name)
+          case klass
+          when :string, :number, :boolean, :array, :hash, :datetime
+            hash[name] = value
+          when :collection
+            hash[name] = value.map(&:to_hash)
+          else
+            if value
+              hash[name] = value.to_hash
+            else
+              hash[name] = nil
+            end
+          end
+        end
+        hash
+      end
+
+      private
+      def type_cast_for_string_attributes(value)
+        value.is_a?(String) ? value : value.to_s
+      end
+
+      def type_cast_for_number_attributes(value)
+        if value.is_a?(Numeric)
+          value
+        else
+          v = value.to_s
+          if v =~ /^\d+$/
+            v.to_i
+          else
+            v.to_f
+          end
+        end
+      end
+
+      def type_cast_for_boolean_attributes(value)
+        value && true
+      end
+
+      def type_cast_for_array_attributes(value)
+        if value.is_a?(Array)
+          value
+        else
+          if value.respond_to?(:to_a)
+            value.to_a
+          else
+            [value]
+          end
+        end
+      end
+
+      def type_cast_for_collection_attributes(v1, each)
+        type_cast_for_array_attributes(v1).map { |v2|
+          type_cast_for_object_attributes(v2, each)
+        }.reject { |v3|
+          v3.nil?
+        }
+      end
+
+      def type_cast_for_hash_attributes(value)
+        if value.is_a?(Hash)
+          value
+        else
+          if value.respond_to?(:to_hash)
+            value.to_hash
+          else
+            nil
+          end
+        end
+      end
+
+      def type_cast_for_object_attributes(value, klass)
+        if value.is_a?(klass)
+          value
+        elsif value.is_a?(Hash)
+          klass.from_hash(value)
+        else
+          nil
+        end
+      end
+
+      def type_cast_for_datetime_attributes(value)
+        case value
+        when Date, Time, DateTime
+          value
+        else
+          DateTime.parse(value.to_s) rescue nil
+        end
+      end
+    end
+  end
+end