couchbase-model-relationship 0.1

data/.gitignore

@@ -0,0 +1,18 @@
+*.gem
+*.rbc
+.bundle
+.config
+.yardoc
+Gemfile.lock
+InstalledFiles
+_yardoc
+coverage
+doc/
+lib/bundler/man
+pkg
+rdoc
+spec/reports
+test/tmp
+test/version_tmp
+tmp
+spec/*.jar

data/Gemfile

@@ -0,0 +1,4 @@
+source 'https://rubygems.org'
+
+# Specify your gem's dependencies in couchbase-model-relationship.gemspec
+gemspec

data/LICENSE.txt

@@ -0,0 +1,22 @@
+Copyright (c) 2013 Jon Moses
+
+MIT License
+
+Permission is hereby granted, free of charge, to any person obtaining
+a copy of this software and associated documentation files (the
+"Software"), to deal in the Software without restriction, including
+without limitation the rights to use, copy, modify, merge, publish,
+distribute, sublicense, and/or sell copies of the Software, and to
+permit persons to whom the Software is furnished to do so, subject to
+the following conditions:
+
+The above copyright notice and this permission notice shall be
+included in all copies or substantial portions of the Software.
+
+THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND,
+EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF
+MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND
+NONINFRINGEMENT. IN NO EVENT SHALL THE AUTHORS OR COPYRIGHT HOLDERS BE
+LIABLE FOR ANY CLAIM, DAMAGES OR OTHER LIABILITY, WHETHER IN AN ACTION
+OF CONTRACT, TORT OR OTHERWISE, ARISING FROM, OUT OF OR IN CONNECTION
+WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE SOFTWARE.

data/README.md

@@ -0,0 +1,29 @@
+# Couchbase::Model::Relationship
+
+TODO: Write a gem description
+
+## Installation
+
+Add this line to your application's Gemfile:
+
+    gem 'couchbase-model-relationship'
+
+And then execute:
+
+    $ bundle
+
+Or install it yourself as:
+
+    $ gem install couchbase-model-relationship
+
+## Usage
+
+TODO: Write usage instructions here
+
+## Contributing
+
+1. Fork it
+2. Create your feature branch (`git checkout -b my-new-feature`)
+3. Commit your changes (`git commit -am 'Add some feature'`)
+4. Push to the branch (`git push origin my-new-feature`)
+5. Create new Pull Request

data/Rakefile

@@ -0,0 +1,19 @@
+require "bundler/gem_tasks"
+
+require 'rake/testtask'
+require 'rake/clean'
+
+rule 'test/CouchbaseMock.jar' do |task|
+  jar_path = "0.5-SNAPSHOT/CouchbaseMock-0.5-20120726.220757-19.jar"
+  sh %{wget -q -O spec/CouchbaseMock.jar http://files.couchbase.com/maven2/org/couchbase/mock/CouchbaseMock/#{jar_path}}
+end
+
+CLOBBER << 'spec/CouchbaseMock.jar'
+
+require 'rspec/core/rake_task'
+
+RSpec::Core::RakeTask.new(:spec)
+
+task :default => :spec
+
+#Rake::Task['spec'].prerequisites.unshift('test/CouchbaseMock.jar')

data/couchbase-model-relationship.gemspec

@@ -0,0 +1,33 @@
+# coding: utf-8
+lib = File.expand_path('../lib', __FILE__)
+$LOAD_PATH.unshift(lib) unless $LOAD_PATH.include?(lib)
+require 'couchbase/model/relationship/version'
+
+Gem::Specification.new do |spec|
+  spec.name          = "couchbase-model-relationship"
+  spec.version       = Couchbase::Model::Relationship::VERSION
+  spec.authors       = ["Jon Moses"]
+  spec.email         = ["jon@burningbush.us"]
+  spec.description   = %q{Closely bound relationships for Couchbase::Model}
+  spec.summary       = %q{Supports relationships that are fetched and saved with a root model}
+  spec.homepage      = "https://github.com/jmoses/couchbase-model-relationship"
+  spec.license       = "MIT"
+
+  spec.files         = `git ls-files`.split($/)
+  spec.executables   = spec.files.grep(%r{^bin/}) { |f| File.basename(f) }
+  spec.test_files    = spec.files.grep(%r{^(test|spec|features)/})
+  spec.require_paths = ["lib"]
+
+  spec.add_dependency 'activemodel', '~> 3'
+  spec.add_dependency 'activesupport', '~> 3'
+  spec.add_dependency 'couchbase', '~> 1'
+  spec.add_dependency 'couchbase-model', '~> 0.5.3'
+  spec.add_dependency 'json', '~> 1.7.7'
+  # FIXME Remove when couchbase is > 1.3.1
+  spec.add_dependency 'multi_json', '1.7.5'
+
+  spec.add_development_dependency "bundler", "~> 1.3"
+  spec.add_development_dependency "rake"
+  spec.add_development_dependency 'rspec'
+  spec.add_development_dependency 'mocha'
+end

data/lib/couchbase/model/attributes.rb

@@ -0,0 +1,36 @@
+module Couchbase
+  class Model
+    module Attributes
+      extend ::ActiveSupport::Concern
+
+      included do
+        include ::ActiveModel::AttributeMethods
+
+        class << self
+          remove_method :attribute
+        end
+      end
+
+      module ClassMethods
+        def attribute(*names)
+          options = names.extract_options!
+
+          names.each do |name|
+            name = name.to_s
+            attributes[name] = options[:default]
+
+            define_attribute_methods([name])
+
+            define_method(name) do
+              read_attribute name
+            end
+
+            define_method("#{name}=") do |value|
+              write_attribute name, value
+            end
+          end
+        end
+      end
+    end
+  end
+end

data/lib/couchbase/model/complex_attributes.rb

@@ -0,0 +1,38 @@
+module Couchbase
+  class Model
+    module ComplexAttributes
+      extend ActiveSupport::Concern
+
+      module ClassMethods
+        def array_attribute(*names)
+          options = names.extract_options!
+          class_name = options.delete(:class_name)
+
+          names.each do |name|
+            name = name.to_s
+
+            (@_array_attributes ||= {})[name] = class_name
+
+            attribute name, {default: proc { [] }}.merge(options)
+
+            define_method("#{name}=") do |values|
+              actual_values = values.map do |value|
+                if value.is_a?(String) && value =~ /json_class/
+                  JSON.load value
+                else
+                  value
+                end
+              end
+
+              write_attribute name, actual_values
+            end
+          end
+        end
+
+        def array_attribute_class(name)
+          @_array_attributes[name.to_s]
+        end
+      end
+    end
+  end
+end

data/lib/couchbase/model/deep_copier.rb

@@ -0,0 +1,45 @@
+module Couchbase
+  class Model
+    class DeepCopier
+      attr_reader :source
+      def initialize(source)
+        @source = source
+      end
+
+      def copy
+        if cloneable?
+          if complex?
+            deep_copy
+          else
+            source.clone
+          end
+        else
+          source
+        end
+      end
+
+      private
+      def cloneable?
+        source.duplicable?
+      end
+
+      def complex?
+        [Array, Hash].include? source.class
+      end
+
+      def deep_copy
+        shallow = source.clone
+
+        if source.is_a?(Array)
+          shallow.clear
+          shallow.concat source.map {|value| DeepCopier.new(value).copy }
+        elsif source.is_a?(Hash)
+          source.each {|key, value| shallow[key] = DeepCopier.new(value).copy }
+          shallow
+        else
+          raise ArgumentError.new("Deep copying a #{source.class} is not supported.")
+        end
+      end
+    end
+  end
+end

data/lib/couchbase/model/dirty.rb

@@ -0,0 +1,81 @@
+# TODO Deep clone previous changes to support nested complex data (from BB)
+module Couchbase
+  class Model
+    module Dirty
+      extend ActiveSupport::Concern
+      include ActiveModel::Dirty
+
+      included do
+        remove_method :write_attribute
+
+        alias_method_chain :save, :dirty
+        alias_method_chain :create, :dirty
+
+        attribute_method_prefix :previous_
+
+        class << self
+          alias_method_chain :_find, :cleaning
+        end
+      end
+
+      module ClassMethods
+        # If we're just loaded from the database, we're not dirty
+        def _find_with_cleaning(quiet, *ids)
+          _find_without_cleaning(quiet, *ids).tap do |results|
+            Array(results).each {|instance| instance.send :clean! }
+          end
+        end
+      end
+
+      def write_attribute(name, value)
+        send "#{name}_will_change!" unless send(name) == value
+
+        @_attributes[name] = value
+      end
+
+      def save_with_dirty(options = {})
+        save_without_dirty(options).tap do |value|
+          capture_previous_changes if value
+        end
+      end
+
+      def create_with_dirty(options = {})
+        create_without_dirty(options).tap do |value|
+          capture_previous_changes if value
+        end
+      end
+
+      # FIXME Return value for "Fail" and "didn't try" is the same
+      def save_if_changed(options = {})
+        save if changed?
+      end
+
+      private
+      def capture_previous_changes
+        @previously_changed = changes
+        @changed_attributes.clear
+      end
+
+      def clean!
+        @changed_attributes.clear if changed?
+      end
+
+      def previous_attribute(attr)
+        return unless previous_changes
+
+        previous_changes[attr.to_s].try :first
+      end
+
+      def attribute_will_change!(attr)
+        begin
+          value = __send__(attr)
+          value = DeepCopier.new(value).copy
+        rescue TypeError, NoMethodError
+        end
+
+        changed_attributes[attr] = value
+      end
+
+    end
+  end
+end

data/lib/couchbase/model/id_prefix.rb

@@ -0,0 +1,53 @@
+module Couchbase
+  class Model
+    module IdPrefix
+      extend ::ActiveSupport::Concern
+
+      included do
+        alias_method_chain :create, :id_prefix
+      end
+
+      def prefixed_id(id)
+        self.class.prefixed_id(id)
+      end
+
+      def create_with_id_prefix(options = {})
+        ensure_has_id
+        create_without_id_prefix(options)
+      end
+
+      def ensure_has_id
+        @id ||= model.next_prefixed_id
+      end
+      private :ensure_has_id
+
+      module ClassMethods
+        # FIXME Need to handle cases where there's no id, or we fail or 
+        # w/e
+        def id_prefix
+          name.underscore
+        end
+
+        def next_prefixed_id
+          prefixed_id(Couchbase::Model::UUID.generator.next(1, thread_storage[:uuid_algorithm]))
+        end
+
+        def prefixed_id(id)
+          "#{id_prefix}:#{unprefixed_id(id)}"
+        end
+
+        def unprefixed_id(id)
+          id.to_s.split(':').last
+        end
+
+        def prefix_from_id(id)
+          id.to_s.split(':').first
+        end
+
+        def class_from_id(id)
+          prefix_from_id(id).classify.constantize
+        end
+      end
+    end
+  end
+end

data/lib/couchbase/model/relationship.rb

@@ -0,0 +1,34 @@
+require 'active_support/concern'
+require 'active_support/core_ext/hash/indifferent_access'
+require 'active_support/core_ext/string/inflections'
+require 'active_support/core_ext/object/try'
+
+require 'active_model'
+
+require "couchbase/model/relationship/version"
+require 'couchbase/model'
+require 'couchbase/model/deep_copier'
+require 'couchbase/model/attributes'
+require 'couchbase/model/complex_attributes'
+require 'couchbase/model/dirty'
+require 'couchbase/model/id_prefix'
+require 'couchbase/model/relationship/association'
+require 'couchbase/model/relationship/parent'
+require 'couchbase/model/relationship/child'
+
+module Couchbase
+  class Model
+    module Relationship
+    end
+  end
+end
+
+# Setup code
+
+Couchbase::Model.send :include, Couchbase::Model::Attributes
+Couchbase::Model.send :include, Couchbase::Model::ComplexAttributes
+Couchbase::Model.send :include, Couchbase::Model::Dirty
+Couchbase::Model.send :include, Couchbase::Model::IdPrefix
+Couchbase::Model.send :include, Couchbase::Model::Relationship::Parent
+Couchbase::Model.send :include, Couchbase::Model::Relationship::Child
+

data/lib/couchbase/model/relationship/association.rb

@@ -0,0 +1,40 @@
+module Couchbase
+  class Model
+    module Relationship
+      class Association
+        attr_accessor :name
+        attr_reader :auto_save, :auto_delete, :auto_load, :class_name
+
+        def initialize(name, options = {})
+          self.name = name.to_s
+          @auto_save = options[:auto_save]
+          @auto_delete = options[:auto_delete]
+          @class_name = options[:class_name]
+          @auto_load = options.key?(:auto_load) ? options[:auto_load] : true
+        end
+
+        def fetch(parent)
+          parent.send(name)
+        end
+
+        def load(parent)
+          child_id = child_class.prefixed_id(parent.id)
+
+          child_class.find_by_id(child_id)
+        end
+
+        def child_klass
+          @class_name || name.classify
+        end
+
+        def child_class
+          child_klass.constantize
+        end
+
+        def prefix
+          child_class.id_prefix
+        end
+      end
+    end
+  end
+end