simply_couch 0.1.0

data/lib/simply_couch/model/has_many_embedded.rb

@@ -0,0 +1,187 @@
+module SimplyCouch
+  module Model
+    module HasManyEmbedded
+      def has_many_embedded(name, options = {})
+        check_existing_properties(name, SimplyCouch::Model::HasMany::Property)
+        properties << SimplyCouch::Model::HasManyEmbedded::Property.new(self, name, options)
+      end
+
+      def define_has_many_embedded_getter(name, options)
+        # Make an alias to the property getter.
+        property_getter_method = "#{name}_property_getter"
+        alias_method property_getter_method, name
+        define_method(name) do |*args|
+          current = instance_variable_get("@#{name}")
+          return  current if current && current.respond_to?(:parent_object_set?)
+          # Rebuild current, ensure parent object
+          current = Array.wrap(self.send(property_getter_method)).map do |h|
+            if h.is_a?(options[:class_name].constantize)
+              o = h
+              o.parent_object = self
+            else
+              o = options[:class_name].constantize.new
+              o._document = h
+              o.parent_object = self
+            end
+            o
+          end
+          def current.parent_object_set?
+            true
+          end
+          instance_variable_set("@#{name}", current)
+          return current
+          local_options = args.first && args.first.is_a?(Hash)
+          forced_reload, with_deleted, limit, descending = extract_association_options(local_options)
+
+          cached_results = send("_get_cached_#{name}") || {}
+          cache_key = _cache_key_for(local_options)
+          debugger
+          if forced_reload || cached_results[cache_key].nil? 
+            #cached_results[cache_key] = get_embedded(options[:class_name], self.class, :with_deleted => with_deleted, :limit => limit, :descending => descending, :foreign_key => options[:foreign_key])
+            cached_results[cache_key] = Array.wrap(self.send(property_getter_method)).map{|h| o = options[:class_name].constantize.new; o._document = h; o}.map{|o| o.parent_object = self; o}
+            instance_variable_set("@#{name}", cached_results)
+            self.class.set_parent_has_many_embedded_association_object(self, cached_results[cache_key])
+          end
+          cached_results[cache_key]
+        end
+      end
+
+      def define_has_many_embedded_setter(name, options)
+        define_method("#{name}=") do |values|
+          klass = self.class.get_class_from_name(name)
+          raise ArgumentError, "expected Array got #{values.class}" unless values.is_a?(Array)
+          instance_variable_set("@#{name}", []) unless instance_variable_get("@#{name}")
+          iid = 0
+          for value in values
+            if value.is_a?(Hash)
+              newval = klass.new
+              newval._document = value
+              newval.updated_at ||= Time.now
+              newval.created_at ||= Time.now
+            else
+              newval = value
+            end
+            newval.index = iid
+            instance_variable_get("@#{name}") << newval
+            iid += 1
+          end
+          save
+        end
+      end
+
+      def define_has_many_embedded_setter_add(name, options)
+        define_method("add_#{name.to_s.singularize}") do |value|
+          klass = self.class.get_class_from_name(name)
+          raise ArgumentError, "expected #{klass} got #{value.class}" unless value.is_a?(klass)
+          if value.is_a?(Hash)
+            newval = klass.new
+            newval._document = value
+            newval.updated_at ||= Time.now
+            newval.created_at ||= Time.now
+          else
+            newval = value
+          end
+          newval.index = (instance_variable_get("@#{name}") || []).size
+          instance_variable_get("@#{name}") << newval
+          save
+        end
+      end
+
+      def define_has_many_embedded_setter_remove(name, options)
+        define_method "remove_#{name.to_s.singularize}" do |value|
+          klass = self.class.get_class_from_name(name)
+          if value.is_a?(klass)
+            found = instance_variable_get("@#{name}").delete(value)
+            if found
+              self.is_dirty
+              self.send("reset_#{name}_index_values")
+            end
+          else
+            raise ArgumentError, "expected #{klass} got #{value.class}"
+          end
+          return save
+        end
+      end
+
+
+      def define_reset_index_values(name, options)
+        define_method "reset_#{name}_index_values" do
+          i = 0
+          for embedded_document in (instance_variable_get("@#{name}") || [])
+            embedded_document.index = i
+            i += 1 
+          end
+        end
+      end
+
+     # Not converted yet 
+      def define_has_many_embedded_setter_remove_all(name, options)
+        define_method "remove_all_#{name}" do
+          all = send("#{name}", :force_reload => true)
+          
+          all.collect{|i| i}.each do |item|
+            send("remove_#{name.to_s.singularize}", item)
+          end
+        end
+      end
+      
+     # Not converted yet 
+      def define_has_many_embedded_count(name, options, through = nil)
+        method_name = name.to_s.singularize.underscore.gsub('/', '__') + "_count"
+        define_method(method_name) do |*args|
+          local_options = args.first && args.first.is_a?(Hash) && args.first
+          if local_options
+            local_options.assert_valid_keys(:force_reload, :with_deleted)
+            forced_reload = local_options[:force_reload]
+            with_deleted = local_options[:with_deleted]
+          else
+            forced_reload = false
+            with_deleted = false
+          end
+
+          if forced_reload || instance_variable_get("@#{method_name}").nil?
+            instance_variable_set("@#{method_name}", count_associated(through || options[:class_name], self.class, :with_deleted => with_deleted, :foreign_key => options[:foreign_key]))
+          end
+          instance_variable_get("@#{method_name}")
+        end
+      end
+      
+     # Not converted yet 
+      def set_parent_has_many_embedded_association_object(parent, child_collection)
+        child_collection.each do |child|
+          if child.respond_to?("#{parent.class.name.to_s.singularize.downcase}=")
+            child.send("#{parent.class.name.to_s.singularize.camelize.downcase}=", parent)
+          end
+        end
+      end
+      
+      class Property < SimplyCouch::Model::AssociationProperty
+        
+        def initialize(owner_clazz, name, options = {})
+          options = {
+            :dependent => :nullify,
+            :through => nil,
+            :class_name => name.to_s.singularize.camelize,
+            :foreign_key => nil
+          }.update(options)
+          @name, @options = name, options
+          
+          options.assert_valid_keys(:dependent, :through, :class_name, :foreign_key)
+          
+          owner_clazz.class_eval do
+            property name, :type => Array
+            _define_cache_accessors(name, options)
+            define_has_many_embedded_getter(name, options)
+            define_has_many_embedded_setter(name, options)
+            define_has_many_embedded_setter_add(name, options)
+            define_has_many_embedded_setter_remove(name, options)
+            define_has_many_embedded_setter_remove_all(name, options)
+            define_reset_index_values(name, options)
+            define_has_many_embedded_count(name, options)
+          end
+        end
+        
+      end
+    end
+  end
+end

data/lib/simply_couch/model/has_one.rb

@@ -0,0 +1,75 @@
+module SimplyCouch
+  module Model
+    module HasOne
+      def has_one(name, options = {})
+        check_existing_properties(name, SimplyCouch::Model::HasOne::Property)
+        properties << SimplyCouch::Model::HasOne::Property.new(self, name, options)
+      end
+      
+      def define_has_one_setter(name, options)
+        define_method("#{name}=") do |value|
+          klass = self.class.get_class_from_name(name)
+          raise ArgumentError, "expected #{klass} got #{value.class}" unless value.nil? || value.is_a?(klass)
+          old_value = send("#{name}", :force_reload => true)
+          if value.nil?
+            instance_variable_set("@#{name}", nil)
+          else
+            instance_variable_set("@#{name}", value)
+            value.send("#{self.class.foreign_key}=", id)
+            value.save
+          end
+          
+          if old_value
+            if options[:dependent] == :destroy
+              old_value.destroy
+            else
+              old_value.send("#{self.class.foreign_property}=", nil)
+              old_value.save
+            end
+          end
+          old_value
+        end
+      end
+      
+      def define_has_one_getter(name, options)
+        define_method(name) do |*args|
+          local_options = args.first && args.first.is_a?(Hash) && args.first
+          forced_reload, with_deleted, limit, descending = extract_association_options(local_options)
+
+          if forced_reload || instance_variable_get("@#{name}").nil?
+            found_object = find_one_associated(options[:class_name], self.class, :with_deleted => with_deleted, :foreign_key => options[:foreign_key])
+            instance_variable_set("@#{name}", found_object)
+            self.class.set_parent_has_one_association_object(self, found_object)
+          end
+          instance_variable_get("@#{name}")
+        end
+      end
+      
+      def set_parent_has_one_association_object(parent, child)
+        if child.respond_to?("#{parent.class.name.to_s.singularize.downcase}=")
+          child.send("#{parent.class.name.to_s.singularize.camelize.downcase}=", parent)
+        end
+      end
+      
+      class Property < SimplyCouch::Model::AssociationProperty
+      
+        def initialize(owner_clazz, name, options = {})
+          options = {
+            :dependent => :nullify,
+            :class_name => name.to_s.singularize.camelize,
+            :foreign_key => nil
+          }.update(options)
+          @name, @options = name, options
+          
+          options.assert_valid_keys(:dependent, :class_name, :foreign_key)
+          
+          owner_clazz.class_eval do
+            define_has_one_getter(name, options)
+            define_has_one_setter(name, options)
+          end
+        end
+
+      end
+    end
+  end
+end

data/lib/simply_couch/model/pagination.rb

@@ -0,0 +1,25 @@
+module SimplyCouch
+  module Model
+    module Pagination
+      def total_pages_method(setter = nil)
+        @_total_pages_method = setter if setter
+        @_total_pages_method || 'total_pages'
+      end
+
+      def current_page_method(setter = nil)
+        @_current_page_method = setter if setter
+        @_current_page_method || 'current_page'
+      end
+
+      def num_pages_method(setter = nil)
+        @_num_pages_method = setter if setter
+        @_num_pages_method || 'num_pages'
+      end
+
+      def per_page_method(setter = nil)
+        @_per_page_method = setter if setter
+        @_per_page_method || 'per_page'
+      end
+    end
+  end
+end

data/lib/simply_couch/model/pagination_options.rb

@@ -0,0 +1,55 @@
+module SimplyCouch
+  module Model
+    module PaginationOptions
+      def with_pagination_options(options, &block)
+        # Allow for manual setting of total_entries
+        # If none given, default fallback will be total_rows
+        # This is not true for a paginated find_all_by construction
+        total_entries = options.delete(:total_entries)
+        # Add limit and skip to options if requested
+        if ([:page, :per_page] & options.keys).any? # Pagination active
+          page = [options.delete(:page).to_i, 1].max
+          per_page = options.delete(:per_page).to_i # Can be string
+          per_page = 22 unless per_page > 0 # Nill will be 0
+          options[:limit] = per_page
+          options[:skip] = (page - 1) * options[:limit]
+        elsif options[:offset] && options[:limit] # Sql syntax support
+          options[:skip] = options.delete(:offset)
+          options.delete(:order)
+          page = (options[:skip].to_i / options[:limit].to_i).floor.succ
+          per_page = options[:limit]
+        else
+          page = 1
+          per_page = 22
+        end
+        result = block.call(options)
+        if result
+          result.instance_eval <<-PAGINATION, __FILE__, __LINE__
+            unless respond_to?(:total_rows)
+              def total_rows
+                1
+              end
+            end
+            def total_entries
+              #{total_entries || 'total_rows'}
+            end
+            alias total_count total_entries
+
+            def #{current_page_method}
+              #{page}
+            end
+            def #{num_pages_method}
+              return 1 if total_entries.zero?
+              (total_entries.to_f / #{per_page}).ceil
+            end
+            alias :#{total_pages_method} :#{num_pages_method}
+            def #{per_page_method}
+              #{per_page}
+            end
+          PAGINATION
+        end
+        result
+      end
+    end
+  end
+end