dm-couchdb-adapter 0.10.2

data/lib/couchdb_adapter/conditions.rb

@@ -0,0 +1,190 @@
+module DataMapper  
+  module Couch
+    module Conditions
+      include DataMapper::Query::Conditions
+      
+      # TODO: document
+      # @api semipublic
+      def property_to_column_name(property, qualify)
+        property.field
+      end
+  
+      private
+      # Constructs couchdb if statement
+      #
+      # @return [String]
+      #   where clause
+      #
+      # @api private
+      def conditions_statement(conditions, qualify = false)
+        case conditions
+          when Query::Conditions::NotOperation
+            negate_operation(conditions, qualify)
+
+          when Query::Conditions::AbstractOperation
+            # TODO: remove this once conditions can be compressed
+            if conditions.operands.size == 1
+              # factor out operations with a single operand
+              conditions_statement(conditions.operands.first, qualify)
+            else
+              operation_statement(conditions, qualify)
+            end
+
+          when Query::Conditions::AbstractComparison
+            comparison_statement(conditions, qualify)
+
+          when Array
+            statement, bind_values = conditions  # handle raw conditions
+            [ "(#{statement})", bind_values ]
+        end
+      end
+
+      # TODO: document
+      # @api private
+      def negate_operation(operation, qualify)
+        @negated = !@negated
+        begin
+          conditions_statement(operation.operands.first, qualify)
+        ensure
+          @negated = !@negated
+        end
+      end
+
+      def query_string(query)
+        query_string = []
+        if query.view_options
+          query_string +=
+            query.view_options.map do |key, value|
+              if [:endkey, :key, :startkey].include? key
+                URI.escape(%Q(#{key}=#{value.to_json}))
+              else
+                URI.escape("#{key}=#{value}")
+              end
+            end
+        end
+        query_string << "limit=#{query.limit}" if query.limit
+        query_string << "descending=#{query.add_reversed?}" if query.add_reversed?
+        query_string << "skip=#{query.offset}" if query.offset != 0
+        query_string.empty? ? nil : "?#{query_string.join('&')}"
+      end
+
+  
+      # TODO: document
+      # @api private
+      def operation_statement(operation, qualify)
+        statements  = []
+        bind_values = []
+
+        operation.each do |operand|
+          statement, values = conditions_statement(operand, qualify)
+
+          if operand.respond_to?(:operands) && operand.operands.size > 1
+            statement = "(#{statement})"
+          end
+
+          statements << statement
+          bind_values.concat(values)
+        end
+
+        join_with = operation.kind_of?(@negated ? Query::Conditions::OrOperation : Query::Conditions::AndOperation) ? '&&' : '||'
+        statement = statements.join(" #{join_with} ")
+
+        return statement, bind_values
+      end
+
+      # Constructs comparison clause
+      #
+      # @return [String]
+      #   comparison clause
+      #
+      # @api private
+      def comparison_statement(comparison, qualify)
+        value = comparison.value.to_json.gsub("\"", "'")
+
+        # TODO: move exclusive Range handling into another method, and
+        # update conditions_statement to use it
+
+        # break exclusive Range queries up into two comparisons ANDed together
+        if value.kind_of?(Range) && value.exclude_end?
+          operation = Query::Conditions::Operation.new(:and,
+            Query::Conditions::Comparison.new(:gte, comparison.subject, value.first),
+            Query::Conditions::Comparison.new(:lt,  comparison.subject, value.last)
+          )
+
+          statement, bind_values = conditions_statement(operation, qualify)
+
+          return "(#{statement})", bind_values
+        elsif comparison.relationship?
+          return conditions_statement(comparison.foreign_key_mapping, qualify)
+        end
+
+        operator = case comparison
+          when Query::Conditions::EqualToComparison              then @negated ? '!=' : '=='
+          when Query::Conditions::InclusionComparison            then @negated ? exclude_operator(comparison.subject, value)    : include_operator(comparison.subject, value)
+          when Query::Conditions::RegexpComparison               then @negated ? not_regexp_operator(value) : regexp_operator(value)
+          when Query::Conditions::LikeComparison                 then @negated ? unlike_operator(value)     : like_operator(value)
+          when Query::Conditions::GreaterThanComparison          then @negated ? ' <= '                       : ' > '
+          when Query::Conditions::LessThanComparison             then @negated ? ' >= '                       : ' < '
+          when Query::Conditions::GreaterThanOrEqualToComparison then @negated ? ' < '                        : ' >= '
+          when Query::Conditions::LessThanOrEqualToComparison    then @negated ? ' > '                        : ' <= '
+        end
+
+        # if operator return value contains ? then it means that it is function call
+        # and it contains placeholder (%s) for property name as well (used in Oracle adapter for regexp operator)
+        if operator.include?('?')
+          return operator % property_to_column_name(comparison.subject, qualify), [ value ]
+        else
+          return "doc.#{property_to_column_name(comparison.subject, qualify)}#{operator}#{value}".strip, [value].compact
+        end
+      end
+
+      # TODO: document
+      # @api private
+      def include_operator(property, operand)
+        case operand
+          when Array then 'IN'
+          when Range then 'BETWEEN'
+        end
+      end
+
+      # TODO: document
+      # @api private
+      def exclude_operator(property, operand)
+        "NOT #{include_operator(property, operand)}"
+      end
+
+      # TODO: document
+      # @api private
+      def regexp_operator(operand)
+        '~'
+      end
+
+      # TODO: document
+      # @api private
+      def not_regexp_operator(operand)
+        '!~'
+      end
+
+      # TODO: document
+      # @api private
+      def like_operator(value)
+        case value
+        when Regexp then value = value.source
+        when String
+          # We'll go ahead and transform this string for SQL compatability
+          value = "^#{value}" unless value[0..0] == ("%")
+          value = "#{value}$" unless value[-1..-1] == ("%")
+          value.gsub!("%", ".*")
+          value.gsub!("_", ".")
+        end
+        return "match(/#{value}/)"
+      end
+  
+      # TODO: document
+      # @api private
+      def unlike_operator(value)
+        # how the hell...
+      end
+    end # end Collection
+  end # end Couch
+end 

data/lib/couchdb_adapter/couch_resource.rb

@@ -0,0 +1,45 @@
+module DataMapper
+  module Couch
+    module Resource
+
+      def self.included(base)
+        base.send(:include, DataMapper::Resource)
+        mod.class_eval do
+          # include DataMapper::CouchResource::Attachments
+
+          property :id, String, :key => true, :field => '_id', :nullable => true
+          property :attachments, DataMapper::Types::JsonObject, :field => '_attachments'
+          property :rev, String, :field => '_rev'
+          property :couchdb_type, DataMapper::Types::Discriminator
+        
+          class << self
+
+            def couchdb_types
+              [self.base_model] | self.descendants
+            end
+
+            def couchdb_types_condition
+              couchdb_types.collect {|type| "doc.couchdb_type == '#{type}'"}.join(' || ')
+            end
+
+            def view(name, &block)
+              @views ||= Hash.new { |h,k| h[k] = {} }
+              view = View.new(self, name)
+              @views[repository.name][name] = block_given? ? block : lambda {}
+              view
+            end
+
+            def views(repository_name = default_repository_name)
+              @views ||= Hash.new { |h,k| h[k] = {} }
+              views = @views[repository_name].dup
+              views.each_pair {|key, value| views[key] = value.call}
+            end
+
+          end
+        
+        end
+      end
+      
+    end # end Resource
+  end
+end

data/lib/couchdb_adapter/design.rb

@@ -0,0 +1,5 @@
+module DataMapper
+  class CouchDesign
+    
+  end
+end

data/lib/couchdb_adapter/json_object.rb

@@ -0,0 +1,23 @@
+require 'json'
+
+# Non-lazy objects that serialize to/from JSON, for use with couchdb
+module DataMapper
+  module Types
+    class JsonObject < DataMapper::Type
+      primitive String
+      size 65535
+
+      def self.load(value, property)
+        value.nil? ? nil : value
+      end
+
+      def self.dump(value, property)
+        value.nil? ? nil : value
+      end
+
+      def self.typecast(value, property)
+        value
+      end
+    end # class JsonObject
+  end # module Types
+end # module DataMapper

data/lib/couchdb_adapter/migrations.rb

@@ -0,0 +1,25 @@
+module DataMapper
+  module Migrations
+    module CouchAdapter      
+      def create_model_storage(repository, model)
+        uri = "/#{self.escaped_db_name}/_design/#{model.base_model.to_s}"
+        view = Net::HTTP::Put.new(uri)
+        view['content-type'] = "application/json"
+        views = model.views.reject {|key, value| value.nil?}
+        view.body = { :views => views }.to_json
+        request do |http|
+          http.request(view)
+        end
+      end
+
+      def destroy_model_storage(repository, model)
+        uri = "/#{self.escaped_db_name}/_design/#{model.base_model.to_s}"
+        response = http_get(uri)
+        unless response['error']
+          uri += "?rev=#{response["_rev"]}"
+          http_delete(uri)
+        end
+      end
+    end
+  end
+end

data/lib/couchdb_adapter/model.rb

@@ -0,0 +1,9 @@
+module DataMapper
+  module Couch
+    module Model
+      def new_collection(query, resources = nil, &block)
+        Couch::Collection.new(query, resources, &block)
+      end
+    end
+  end
+end

data/lib/couchdb_adapter/query.rb

@@ -0,0 +1,7 @@
+module DataMapper
+  module Couch
+    class Query < ::Query
+
+    end
+  end
+end

data/lib/couchdb_adapter/resource.rb

@@ -0,0 +1,19 @@
+module DataMapper
+  module Resource
+    # Converts a Resource to a JSON representation.
+    def to_couch_json(dirty = false)
+      property_list = self.class.properties.select { |key, value| dirty ? self.dirty_attributes.key?(key) : true }
+      data = {}
+      for property in property_list do
+        data[property.field] =
+          if property.type.respond_to?(:dump)
+            property.type.dump(property.get!(self), property)
+          else
+            property.get!(self)
+          end
+      end
+      data.delete('_attachments') if data['_attachments'].nil? || data['_attachments'].empty?
+      data.to_json
+    end
+  end
+end

data/lib/couchdb_adapter/version.rb

@@ -0,0 +1,5 @@
+module DataMapper
+  class CouchDBAdapter
+    VERSION = '0.10.1'.freeze
+  end
+end

data/lib/couchdb_adapter/view.rb

@@ -0,0 +1,41 @@
+module DataMapper
+  class Query
+    attr_accessor :view, :view_options
+  end
+end
+
+module DataMapper
+  module CouchResource
+    class View
+      attr_reader :model, :name
+
+      def initialize(model, name)
+        @model = model
+        @name = name
+
+        create_getter
+      end
+
+      def create_getter
+        @model.class_eval <<-RUBY, __FILE__, __LINE__ + 1
+          def self.#{@name}(*args)
+            options = {}
+            if args.size == 1 && !args.first.is_a?(Hash)
+              options[:key] = args.shift
+            else
+              options = args.pop
+            end
+            query = Query.new(repository, self)
+            query.view_options = options || {}
+            query.view = '#{@name}'
+            if options.is_a?(Hash) && options.has_key?(:repository)
+              repository(options.delete(:repository)).read_many(query)
+            else
+              repository.read_many(query)
+            end
+          end
+        RUBY
+      end
+    end
+  end
+end

data/lib/couchdb_adapter.rb

@@ -0,0 +1,31 @@
+require 'rubygems'
+require 'pathname'
+
+
+gem "couchrest", "~> 0.35"
+require "couchrest"
+
+# load after because couchrest clones some methods in Extlib,
+# I'd rather just have the ones in the current Extlib
+gem 'dm-core', '~>0.10.2'
+require 'dm-core'
+
+begin
+  gem "json"
+  require "json/ext"
+rescue LoadError
+  gem "json_pure"
+  require "json/pure"
+end
+
+
+dir = Pathname(__FILE__).dirname.expand_path / 'couchdb_adapter'
+
+require dir / 'attachments'
+require dir / 'couch_resource'
+require dir / 'json_object'
+require dir / 'view'
+require dir / 'version'
+require dir / 'resource'
+require dir / 'adapter'
+require dir / 'migrations'