couchbase-orm 0.0.1

data/lib/couchbase-orm/railtie.rb

@@ -0,0 +1,96 @@
+# encoding: utf-8
+#
+# Author:: Couchbase <info@couchbase.com>
+# Copyright:: 2012 Couchbase, Inc.
+# License:: Apache License, Version 2.0
+#
+# Licensed under the Apache License, Version 2.0 (the "License");
+# you may not use this file except in compliance with the License.
+# You may obtain a copy of the License at
+#
+#     http://www.apache.org/licenses/LICENSE-2.0
+#
+# Unless required by applicable law or agreed to in writing, software
+# distributed under the License is distributed on an "AS IS" BASIS,
+# WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+# See the License for the specific language governing permissions and
+# limitations under the License.
+#
+
+require 'yaml'
+require 'couchbase-orm/base'
+
+module Rails #:nodoc:
+    module Couchbase #:nodoc:
+        class Railtie < Rails::Railtie #:nodoc:
+
+            config.couchbase = ActiveSupport::OrderedOptions.new
+            config.couchbase.ensure_design_documents ||= true
+
+            # Maping of rescued exceptions to HTTP responses
+            #
+            # @example
+            #   railtie.rescue_responses
+            #
+            # @return [Hash] rescued responses
+            def self.rescue_responses
+                {
+                    'Libcouchbase::Error::KeyNotFound' => :not_found,
+                    'Libcouchbase::Error::NotStored' => :unprocessable_entity
+                }
+            end
+
+            config.send(:app_generators).orm :couchbase_orm, :migration => false
+
+            if config.action_dispatch.rescue_responses
+                config.action_dispatch.rescue_responses.merge!(rescue_responses)
+            end
+
+            # Initialize Couchbase Mode. This will look for a couchbase.yml in the
+            # config directory and configure Couchbase connection appropriately.
+            initializer 'couchbase.setup_connection' do
+                config_file = Rails.root.join('config', 'couchbase.yml')
+                if config_file.file? &&
+                    config = YAML.load(ERB.new(File.read(config_file)).result)[Rails.env]
+                    ::CouchbaseOrm::Connection.options = config.deep_symbolize_keys
+                end
+            end
+
+            # After initialization we will warn the user if we can't find a couchbase.yml and
+            # alert to create one.
+            initializer 'couchbase.warn_configuration_missing' do
+                unless ARGV.include?('couchbase:config')
+                    config.after_initialize do
+                        unless Rails.root.join('config', 'couchbase.yml').file?
+                            puts "\nCouchbase config not found. Create a config file at: config/couchbase.yml"
+                            puts "to generate one run: rails generate couchbase:config\n\n"
+                        end
+                    end
+                end
+            end
+
+            # Set the proper error types for Rails. NotFound errors should be
+            # 404s and not 500s, validation errors are 422s.
+            initializer 'couchbase.load_http_errors' do |app|
+                config.after_initialize do
+                    unless config.action_dispatch.rescue_responses
+                        ActionDispatch::ShowExceptions.rescue_responses.update(Railtie.rescue_responses)
+                    end
+                end
+            end
+
+            # Check (and upgrade if needed) all design documents
+            config.after_initialize do |app|
+                if config.couchbase.ensure_design_documents
+                    begin
+                        ::CouchbaseOrm::Base.descendants.each do |model|
+                            model.ensure_design_document!
+                        end
+                    rescue ::Libcouchbase::Error::Timedout, ::Libcouchbase::Error::ConnectError, ::Libcouchbase::Error::NetworkError
+                        # skip connection errors for now
+                    end
+                end
+            end
+        end
+    end
+end

data/lib/couchbase-orm/utilities/ensure_unique.rb

@@ -0,0 +1,18 @@
+module CouchbaseOrm
+    module EnsureUnique
+        private
+
+        def ensure_unique(attrs, name = nil, &processor)
+            # index uses a special bucket key to allow record lookups based on
+            # the values of attrs. ensure_unique adds a simple lookup using
+            # one of the added methods to identify duplicate
+            name = index(attrs, name, &processor)
+
+            validate do |record|
+                unless record.send("#{name}_unique?")
+                    errors.add(name, 'has already been taken')
+                end
+            end
+        end
+    end
+end

data/lib/couchbase-orm/utilities/enum.rb

@@ -0,0 +1,49 @@
+module CouchbaseOrm
+    module Enum
+        private
+
+        def enum(options)
+            # options contains an optional default value, and the name of the
+            # enum, e.g enum visibility: %i(group org public), default: :group
+            default = options.delete(:default)
+            name = options.keys.first.to_sym
+            values = options[name]
+
+            # values is assumed to be a list of symbols. each value is assigned an
+            # integer, and this number is used for db storage. numbers start at 1.
+            mapping = {}
+            values.each_with_index do |value, i|
+                mapping[value.to_sym] = i + 1
+                mapping[i + 1] = value.to_sym
+            end
+
+            # VISIBILITY = {group: 0, 0: group ...}
+            const_set(name.to_s.upcase, mapping)
+
+            # lookup the default's integer value
+            if default
+                default_value = mapping[default]
+                raise 'Unknown default value' unless default_value
+            else
+                default_value = 1
+            end
+            attribute name, default: default_value
+
+            # keep the attribute's value within bounds
+            before_save do |record|
+                value = record[name]
+
+                unless value.nil?
+                    value = case value
+                    when Symbol, String
+                        record.class.const_get(name.to_s.upcase)[value.to_sym]
+                    else
+                        Integer(value)
+                    end
+                end
+
+                record[name] = (1..values.length).cover?(value) ? value : default_value
+            end
+        end
+    end
+end

data/lib/couchbase-orm/utilities/has_many.rb

@@ -0,0 +1,73 @@
+module CouchbaseOrm
+    module HasMany
+        private
+
+        # :foreign_key, :class_name, :through
+        def has_many(model, class_name: nil, foreign_key: nil, through: nil, through_class: nil, through_key: nil, **options)
+            class_name  = (class_name || model.to_s.singularize.camelcase).to_s
+            foreign_key = (foreign_key || ActiveSupport::Inflector.foreign_key(self.name)).to_sym
+
+            if through || through_class
+                remote_class = class_name
+                class_name = (through_class || through.to_s.camelcase).to_s
+                through_key = (through_key || "#{remote_class.underscore}_id").to_sym
+                remote_method = :"by_#{foreign_key}_with_#{through_key}"
+            else
+                remote_method = :"find_by_#{foreign_key}"
+            end
+
+            relset_varname = "@#{model}_rel_set"
+
+            klass = begin
+                class_name.constantize
+            rescue NameError => e
+                puts "WARNING: #{class_name} referenced in #{self.name} before it was loaded"
+
+                # Open the class early - load order will have to be changed to prevent this.
+                # Warning notice required as a misspelling will not raise an error
+                Object.class_eval <<-EKLASS
+                    class #{class_name} < CouchbaseOrm::Base
+                        attribute :#{foreign_key}
+                    end
+                EKLASS
+                class_name.constantize
+            end
+
+
+            if remote_class
+                klass.class_eval do
+                    view remote_method, map: <<-EMAP
+    function(doc) {
+        if (doc.type === "{{design_document}}" && doc.#{through_key}) {
+            emit(doc.#{foreign_key}, null);
+        }
+    }
+EMAP
+                end
+
+                define_method(model) do
+                    return self.instance_variable_get(relset_varname) if instance_variable_defined?(relset_varname)
+
+                    remote_klass = remote_class.constantize
+                    enum = klass.__send__(remote_method, key: self.id) { |row|
+                        remote_klass.find(row.value[through_key])
+                    }
+
+                    self.instance_variable_set(relset_varname, enum)
+                end
+            else
+                klass.class_eval do
+                    index_view foreign_key
+                end
+
+                define_method(model) do
+                    return self.instance_variable_get(relset_varname) if instance_variable_defined?(relset_varname)
+                    self.instance_variable_set(relset_varname, klass.__send__(remote_method, self.id))
+                end
+            end
+
+            @associations ||= []
+            @associations << [model, options[:dependent]]
+        end
+    end
+end

data/lib/couchbase-orm/utilities/index.rb

@@ -0,0 +1,117 @@
+module CouchbaseOrm
+    module Index
+        private
+
+        def index(attrs, name = nil, &processor)
+            attrs = Array(attrs).flatten
+            name ||= attrs.map(&:to_s).join('_')
+
+            find_by_method          = "find_by_#{name}"
+            processor_method        = "process_#{name}"
+            bucket_key_method       = "#{name}_bucket_key"
+            bucket_key_vals_method  = "#{name}_bucket_key_vals"
+            class_bucket_key_method = "generate_#{bucket_key_method}"
+            original_bucket_key_var = "@original_#{bucket_key_method}"
+
+
+            #----------------
+            # keys
+            #----------------
+            # class method to generate a bucket key given input values
+            define_singleton_method(class_bucket_key_method) do |*values|
+                processed = self.send(processor_method, *values)
+                "#{@design_document}#{name}-#{processed}"
+            end
+
+            # instance method that uses the class method to generate a bucket key
+            # given the current value of each of the key's component attributes
+            define_method(bucket_key_method) do |args = nil|
+                self.class.send(class_bucket_key_method, *self.send(bucket_key_vals_method))
+            end
+
+            # collect a list of values for each key component attribute
+            define_method(bucket_key_vals_method) do
+                attrs.collect {|attr| self[attr]}
+            end
+
+
+            #----------------
+            # helpers
+            #----------------
+            # simple wrapper around the processor proc if supplied
+            define_singleton_method(processor_method) do |*values|
+                if processor
+                    processor.call(values.length == 1 ? values.first : values)
+                else
+                    values.join('-')
+                end
+            end
+
+            # use the bucket key as an index - lookup records by attr values
+            define_singleton_method(find_by_method) do |*values|
+                key = self.send(class_bucket_key_method, *values)
+                id  = self.bucket.get(key, quiet: true)
+                if id
+                    mod = self.find_by_id(id)
+                    return mod if mod
+
+                    # Clean up record if the id doesn't exist
+                    self.bucket.delete(key, quiet: true)
+                end
+
+                nil
+            end
+
+
+            #----------------
+            # validations
+            #----------------
+            # ensure each component of the unique key is present
+            attrs.each do |attr|
+                validates attr, presence: true
+                define_attribute_methods attr
+            end
+
+            define_method("#{name}_unique?") do
+                values = self.send(bucket_key_vals_method)
+                other  = self.class.send(find_by_method, *values)
+                !other || other.id == self.id
+            end
+
+
+            #----------------
+            # callbacks
+            #----------------
+            # before a save is complete, while changes are still available, store
+            # a copy of the current bucket key for comparison if any of the key
+            # components have been modified
+            before_save do |record|
+                if attrs.any? { |attr| record.changes.include?(attr) }
+                    args = attrs.collect { |attr| send(:"#{attr}_was") || send(attr) }
+                    instance_variable_set(original_bucket_key_var, self.class.send(class_bucket_key_method, *args))
+                end
+            end
+
+            # after the values are persisted, delete the previous key and store the
+            # new one. the id of the current record is used as the key's value.
+            after_save do |record|
+                original_key = instance_variable_get(original_bucket_key_var)
+                record.class.bucket.delete(original_key, quiet: true) if original_key
+                record.class.bucket.set(record.send(bucket_key_method), record.id, plain: true)
+                instance_variable_set(original_bucket_key_var, nil)
+            end
+
+            # cleanup by removing the bucket key before the record is deleted
+            # TODO: handle unpersisted, modified component values
+            before_destroy do |record|
+                record.class.bucket.delete(record.send(bucket_key_method), quiet: true)
+                true
+            end
+
+            # return the name used to construct the added method names so other
+            # code can call the special index methods easily
+            return name
+        end
+
+    end
+end

data/lib/couchbase-orm/utilities/join.rb

@@ -0,0 +1,68 @@
+module CouchbaseOrm
+    module Join
+        private
+
+        # join adds methods for retrieving the join model by user or group, and
+        # methods for retrieving either model through the join model (e.g all
+        # users who are in a group). model_a and model_b must be strings or symbols
+        # and are assumed to be singularised, underscored versions of model names
+        def join(model_a, model_b, options={})
+            # store the join model names for use by has_many associations
+            @join_models = [model_a.to_s, model_b.to_s]
+
+            # join :user, :group => design_document :ugj
+            doc_name = options[:design_document] || "#{model_a.to_s[0]}#{model_b.to_s[0]}j".to_sym
+            design_document doc_name
+
+            # a => b
+            add_single_sided_features(model_a)
+            add_joint_lookups(model_a, model_b)
+
+            # b => a
+            add_single_sided_features(model_b)
+            add_joint_lookups(model_b, model_a, true)
+
+            # use Index to allow lookups of joint records more efficiently than
+            # with a view or search
+            index ["#{model_a}_id".to_sym, "#{model_b}_id".to_sym], :join
+        end
+
+        def add_single_sided_features(model)
+            # belongs_to :group
+            belongs_to model
+
+            # view :by_group_id
+            view "by_#{model}_id"
+
+            # find_by_group_id
+            instance_eval "
+                def self.find_by_#{model}_id(#{model}_id)
+                    by_#{model}_id(key: #{model}_id)
+                end
+            "
+        end
+
+        def add_joint_lookups(model_a, model_b, reverse = false)
+            # find_by_user_id_and_group_id
+            instance_eval "
+                def self.find_by_#{model_a}_id_and_#{model_b}_id(#{model_a}_id, #{model_b}_id)
+                    self.find_by_join([#{reverse ? model_b : model_a}_id, #{reverse ? model_a : model_b}_id])
+                end
+            "
+
+            # user_ids_by_group_id
+            instance_eval "
+                def self.#{model_a}_ids_by_#{model_b}_id(#{model_b}_id)
+                    self.find_by_#{model_b}_id(#{model_b}_id).map(&:#{model_a}_id)
+                end
+            "
+
+            # users_by_group_id
+            instance_eval "
+                def self.#{model_a.to_s.pluralize}_by_#{model_b}_id(#{model_b}_id)
+                    self.find_by_#{model_b}_id(#{model_b}_id).map(&:#{model_a})
+                end
+            "
+        end
+    end
+end

data/lib/couchbase-orm/version.rb

@@ -0,0 +1,5 @@
+# frozen_string_literal: true, encoding: ASCII-8BIT
+
+module CouchbaseOrm
+    VERSION = '0.0.1'
+end

data/lib/couchbase-orm/views.rb

@@ -0,0 +1,148 @@
+# frozen_string_literal: true, encoding: ASCII-8BIT
+
+require 'active_model'
+
+module CouchbaseOrm
+    module Views
+        extend ActiveSupport::Concern
+
+
+        module ClassMethods
+            # Defines a view for the model
+            #
+            # @param [Symbol, String, Array] names names of the views
+            # @param [Hash] options options passed to the {Couchbase::View}
+            #
+            # @example Define some views for a model
+            #  class Post < CouchbaseOrm::Base
+            #    view :all
+            #    view :by_rating, emit_key: :rating
+            #  end
+            #
+            #  Post.by_rating.stream do |response|
+            #    # ...
+            #  end
+            def view(name, map: nil, emit_key: nil, reduce: nil, **options)
+                raise "unknown emit_key attribute for view :#{name}, emit_key: :#{emit_key}" if emit_key && @attributes[emit_key].nil?
+
+                options = ViewDefaults.merge(options)
+
+                method_opts = {}
+                method_opts[:map]    = map    if map
+                method_opts[:reduce] = reduce if reduce
+
+                unless method_opts.has_key? :map
+                    emit_key = emit_key || :id
+
+                    if emit_key != :id && self.attributes[emit_key][:type].to_s == 'Array'
+                        method_opts[:map] = <<-EMAP
+function(doc) {
+    var i;
+    if (doc.type === "{{design_document}}") {
+        for (i = 0; i < doc.#{emit_key}.length; i += 1) {
+            emit(doc.#{emit_key}[i], null);
+        }
+    }
+}
+EMAP
+                    else
+                        method_opts[:map] = <<-EMAP
+function(doc) {
+    if (doc.type === "{{design_document}}") {
+        emit(doc.#{emit_key}, null);
+    }
+}
+EMAP
+                    end
+                end
+
+                @views ||= {}
+
+                name = name.to_sym
+                @views[name] = method_opts
+
+                singleton_class.__send__(:define_method, name) do |**opts, &result_modifier|
+                    opts = options.merge(opts)
+
+                    if result_modifier
+                        opts[:include_docs] = true
+                        bucket.view(@design_document, name, **opts, &result_modifier)
+                    elsif opts[:include_docs]
+                        bucket.view(@design_document, name, **opts) { |row|
+                            self.new(row)
+                        }
+                    else
+                        bucket.view(@design_document, name, **opts)
+                    end
+                end
+            end
+            ViewDefaults = {include_docs: true}
+
+            # add a view and lookup method to the model for finding all records
+            # using a value in the supplied attr.
+            def index_view(attr, validate: true, find_method: nil, view_method: nil)
+                view_method ||= "by_#{attr}"
+                find_method ||= "find_#{view_method}"
+
+                validates(attr, presence: true) if validate
+                view view_method, emit_key: attr
+
+                instance_eval "
+                    def self.#{find_method}(#{attr})
+                        #{view_method}(key: #{attr})
+                    end
+                "
+            end
+
+            def ensure_design_document!
+                return false unless @views && !@views.empty?
+                existing = {}
+                update_required = false
+
+                # Grab the existing view details
+                ddoc = bucket.design_docs[@design_document]
+                existing = ddoc.view_config if ddoc
+
+                views_actual = {}
+                # Fill in the design documents
+                @views.each do |name, document|
+                    doc = document.dup
+                    views_actual[name] = doc
+                    doc[:map] = doc[:map].gsub('{{design_document}}', @design_document) if doc[:map]
+                    doc[:reduce] = doc[:reduce].gsub('{{design_document}}', @design_document) if doc[:reduce]
+                end
+
+                # Check there are no changes we need to apply
+                views_actual.each do |name, desired|
+                    check = existing[name]
+                    if check
+                        cmap = (check[:map] || '').gsub(/\s+/, '')
+                        creduce = (check[:reduce] || '').gsub(/\s+/, '')
+                        dmap = (desired[:map] || '').gsub(/\s+/, '')
+                        dreduce = (desired[:reduce] || '').gsub(/\s+/, '')
+
+                        unless cmap == dmap && creduce == dreduce
+                            update_required = true
+                            break
+                        end
+                    else
+                        update_required = true
+                        break
+                    end
+                end
+
+                # Updated the design document
+                if update_required
+                    bucket.save_design_doc({
+                        views: views_actual
+                    }, @design_document)
+
+                    puts "Couchbase views updated for #{self.name}, design doc: #{@design_document}"
+                    true
+                else
+                    false
+                end
+            end
+        end
+    end
+end