cortex-reaver 0.0.9 → 0.1.0

data/lib/cortex_reaver/support/cached_rendering.rb

@@ -1,78 +1,81 @@
-module CortexReaver
-  module Model
+require 'ostruct'
 
+module Sequel
+  module Plugins
     # On save, calls a special rendering method on configured attributes, and
     # saves the results to their cache.
     module CachedRendering
-      require 'ostruct'
-
-      def self.included(base)
-        base.class_eval do
-          # Before save, render all changed caching fields
-          before_save(:render_to_cache) do
-            # Get changed fields to render
-            if new?
-              changed = columns.map { |c| c.to_sym }
-            else
-              changed = changed_columns.map { |c| c.to_sym }
-            end
-            fields = render_fields.select do |k, v|
-              changed.include? k.to_sym
-            end
-            
-            fields.each do |name, field|
-              # Render and cache
-              self[field.to] = self.send(field.with, self[name])
+      module ClassMethods
+        # Refreshes all records with cached fields.
+        def refresh_render_caches
+          # TODO: inefficient, but Model.each breaks Sequel in validation
+          # "commands out of sync"
+          all.each do |record|
+            # Mark all caching columns as changed, so the before_save hook
+            # processes them.
+            record.skip_timestamp_update = true
+            render_fields.keys.each do |column|
+              record.changed_columns << column
             end
+            record.save
           end
+          nil
+        end
 
-          # Refreshes all records with cached fields.
-          def self.refresh_render_caches
-            # TODO: inefficient, but Model.each breaks Sequel in validation
-            # "commands out of sync"
-            all.each do |record|
-              # Mark all caching columns as changed, so the before_save hook
-              # processes them.
-              record.skip_timestamp_update = true
-              render_fields.keys.each do |column|
-                record.changed_columns << column
-              end
-              record.save
-            end
-            nil
-          end
+        # Assigns a field to cache
+        #
+        # render :body, :with => 'wikify', :to => 'cached_body'
+        #
+        # ... calls #wikify on the value of self.body, and stores the result
+        # in self.cached_body. :to defaults to the field name with _cache
+        # appended. :with defaults to :render.
+        def render(field, params = {})
+          # Assign parameters
+          params = {
+            :to => (field.to_s + '_cache').to_sym,
+            :with => :render
+          }.merge!(params)
+         
+          # Store field 
+          render_fields[field] = OpenStruct.new(params)
+        end
 
-          # Assigns a field to cache
-          #
-          # render :body, :with => 'wikify', :to => 'cached_body'
-          #
-          # ... calls #wikify on the value of self.body, and stores the result
-          # in self.cached_body. :to defaults to the field name with _cache
-          # appended. :with defaults to :render.
-          def self.render(field, params = {})
-            # Assign parameters
-            params = {
-              :to => (field.to_s + '_cache').to_sym,
-              :with => :render
-            }.merge!(params)
-           
-            # Store field 
-            render_fields[field] = OpenStruct.new(params)
-          end
+        def render_fields
+          @render_fields ||= {}
+        end
+      end
+
+      module InstanceMethods
+        # Before save, render all changed caching fields
+        def before_save
+          return false if super == false
 
-          def self.render_fields
-            @render_fields ||= {}
+          # Get changed fields to render
+          if new?
+            changed = columns.map { |c| c.to_sym }
+          else
+            changed = changed_columns.map { |c| c.to_sym }
+          end
+          fields = render_fields.select do |k, v|
+            changed.include? k.to_sym
           end
+          
+          fields.each do |name, field|
+            # Render and cache
+            self[field.to] = self.send(field.with, self[name])
+          end
+
+          true
         end
-      end
 
-      # Default renderer
-      def render(value)
-        value  
-      end
+        # Default renderer
+        def render(value)
+          value  
+        end
 
-      def render_fields
-        self.class.render_fields
+        def render_fields
+          self.class.render_fields
+        end
       end
     end
   end

data/lib/cortex_reaver/support/canonical.rb

@@ -1,110 +1,107 @@
-module CortexReaver
-  module Model
+module Sequel
+  module Plugins
     # Supports canonical, url-safe identifiers for records, inferred from other
     # fields.
     module Canonical
+      module ClassMethods
+        # The canonical name attribute
+        CANONICAL_NAME_ATTR = :name
+        # The attribute we infer the canonical name from, if not set.
+        CANONICAL_INFERENCE_ATTR = :title
 
-      # The canonical name attribute
-      CANONICAL_NAME_ATTR = :name
-      # The attribute we infer the canonical name from, if not set.
-      CANONICAL_INFERENCE_ATTR = :title
+        # Canonical names which cannot be reserved.
+        def reserved_canonical_names
+          @reserved_canonical_names ||= []
+        end
 
-      # Lower case, remove special chars, and replace with hyphens.
-      def self.formalize(string)
-        string.downcase.gsub(/[^a-z0-9_]/, '-').squeeze('-')[0..250].sub(/-$/, '')
-      end
+        def reserved_canonical_names=(names)
+          @reserved_canonical_names = names
+        end
 
-      def self.included(base)
-        base.class_eval do
-          # Canonical names which cannot be reserved.
-          def self.reserved_canonical_names
-            @reserved_canonical_names ||= []
-          end
+        # Canonicalize a string. Optionally, ignore conflicts with the record
+        # with opts[:id]
+        def canonicalize(string, opts={})
+          # Lower case, remove special chars, and replace with hyphens.
+          proper = formalize string
 
-          def self.reserved_canonical_names=(names)
-            @reserved_canonical_names = names
+          # If proper is blank, just return it at this point.
+          if proper.blank?
+            return proper
           end
 
-          # Canonicalize a string. Optionally, ignore conflicts with the record
-          # with opts[:id]
-          def self.canonicalize(string, opts={})
-            # Lower case, remove special chars, and replace with hyphens.
-            proper = Canonical.formalize string
-
-            # If proper is blank, just return it at this point.
-            if proper.blank?
-              return proper
-            end
-
-            # Numeric suffix to append
-            suffix = nil
+          # Numeric suffix to append
+          suffix = nil
 
-            # Get similar names from the class
-            similar = similar_canonical_names(proper, opts)
+          # Get similar names from the class
+          similar = similar_canonical_names(proper, opts)
 
-            # Get reserved names from the class
-            reserved_canonical_names.each do |name|
-              if name =~ /^#{proper}(-\d+)?$/
-                similar << name
-              end
+          # Get reserved names from the class
+          reserved_canonical_names.each do |name|
+            if name =~ /^#{proper}(-\d+)?$/
+              similar << name
             end
+          end
 
-            # Extract numeric suffices
-            suffices = {}
-            similar.each do |name|
-              suffices[name[/\d$/].to_i] = true
-            end
+          # Extract numeric suffices
+          suffices = {}
+          similar.each do |name|
+            suffices[name[/\d$/].to_i] = true
+          end
 
-            # Compute suffix
-            unless suffices.empty?
-              i = 1
-              while suffices.include? i
-                i += 1
-              end
-              suffix = i
-            end
-           
-            # Apply suffix
-            if suffix
-              proper + '-' + suffix.to_s
-            else
-              proper
+          # Compute suffix
+          unless suffices.empty?
+            i = 1
+            while suffices.include? i
+              i += 1
             end
+            suffix = i
+          end
+         
+          # Apply suffix
+          if suffix
+            proper + '-' + suffix.to_s
+          else
+            proper
           end
+        end
 
-          # Sets the attribute we infer the canonical name from to attr, or
-          # gets that attr if nil.
-          def self.canonical_inference_attr(attr = nil)
-            if attr
-              @canonical_inference_attr = attr.to_sym
-            else
-              @canonical_inference_attr || CANONICAL_INFERENCE_ATTR
-            end
+        # Sets the attribute we infer the canonical name from to attr, or
+        # gets that attr if nil.
+        def canonical_inference_attr(attr = nil)
+          if attr
+            @canonical_inference_attr = attr.to_sym
+          else
+            @canonical_inference_attr || CANONICAL_INFERENCE_ATTR
           end
+        end
 
-          # Sets the canonical name attribute to attr. Returns it if nil.
-          def self.canonical_name_attr(attr = nil)
-            if attr
-             @canonical_name_attr = attr.to_sym
-            else
-              @canonical_name_attr || CANONICAL_NAME_ATTR
-            end
+        # Sets the canonical name attribute to attr. Returns it if nil.
+        def canonical_name_attr(attr = nil)
+          if attr
+           @canonical_name_attr = attr.to_sym
+          else
+            @canonical_name_attr || CANONICAL_NAME_ATTR
           end
+        end
 
-          # Canonicalize only in the context of our parent's namespace.
-          # Takes a proper canonical name to check for conflicts with, and an optional
-          # id to ignore conflicts with
-          def self.similar_canonical_names(proper, opts={})
-            id = opts[:id]
-            similar = []
-            if filter(canonical_name_attr => proper).exclude(:id => id).limit(1).count > 0
-              # This name already exists, and it's not ours.
-              similar << proper
-              similar += filter(canonical_name_attr.like(/^#{proper}\-[0-9]+$/)).map(canonical_name_attr)
-            end
-            similar
-          end 
+        # Lower case, remove special chars, and replace with hyphens.
+        def formalize(string)
+          string.downcase.gsub(/'"/, '').gsub(/[^a-z0-9_]/, '-').squeeze('-')[0..250].sub(/-$/, '')
         end
+
+        # Canonicalize only in the context of our parent's namespace.  Takes a
+        # proper canonical name to check for conflicts with, and an optional id
+        # to ignore conflicts with
+        def similar_canonical_names(proper, opts={})
+          id = opts[:id]
+          similar = []
+          if filter(canonical_name_attr => proper).exclude(:id => id).limit(1).count > 0
+            # This name already exists, and it's not ours.
+            similar << proper
+            similar += filter(canonical_name_attr.like(/^#{proper}\-[0-9]+$/)).map(canonical_name_attr)
+          end
+          similar
+        end 
       end
     end
   end

data/lib/cortex_reaver/support/comments.rb

@@ -1,67 +1,73 @@
-module CortexReaver
-  module Model
+module Sequel
+  module Plugins
     # Support methods for comments on models
     module Comments
-      def self.included(base)
-        base.class_eval do
-          # When we delete a model that has comments, remove the comments too.
-          before_destroy(:drop_comments) do
-            comments = self.comments
-            remove_all_comments
-            comments.each do |comment|
-              comment.destroy
-            end
-          end
-
-          # Refresh all comment counts
-          def self.refresh_comment_counts
-            all.each do |model|
-              model.refresh_comment_count
-            end
+      module ClassMethods
+        # Refresh all comment counts
+        def refresh_comment_counts
+          all.each do |model|
+            model.refresh_comment_count
           end
         end
       end
 
-      # Recalculates the number of comments on this record (and all comments
-      # below it, recursively) and saves those values. Returns the comment
-      # count on this record.
-      def refresh_comment_count
-        count = 0
-        comments.each do |comment|
-          # Recalculate for sub-comments and sum.
-          count += comment.refresh_comment_count + 1
+      module InstanceMethods
+        # When we delete a model that has comments, remove the comments too.
+        def before_destroy
+          Ramaze::Log.debug 'remove_comments'
+          return false if super == false
+          Ramaze::Log.debug 'removing comments'
+
+          comments = self.comments
+          remove_all_comments
+          comments.each do |comment|
+            comment.destroy
+          end
+
+          true
         end
-        self[:comment_count] = count
-        self.skip_timestamp_update = true
 
-        # Save and return
-        self.save
-        self[:comment_count]
-      end
+        # Recalculates the number of comments on this record (and all comments
+        # below it, recursively) and saves those values. Returns the comment
+        # count on this record.
+        def refresh_comment_count
+          count = 0
+          comments.each do |comment|
+            # Recalculate for sub-comments and sum.
+            count += comment.refresh_comment_count + 1
+          end
+          self[:comment_count] = count
+          self.skip_timestamp_update = true
+
+          # Save and return
+          self.save
+          self[:comment_count]
+        end
 
-      # Returns the parent of a given comment. Caches, pass true to refresh.
-      def parent(refresh = false)
-        if refresh or @parent_cache.nil?
-          [:comment, :journal, :photograph, :project, :page].each do |p|
-            if self.respond_to?(p) and parent = self.send(p)
-              # We found an applicable parent.
-              @parent_cache = parent
-              return parent
+        # Returns the parent of a given comment. Caches, pass true to refresh.
+        def parent(refresh = false)
+          if refresh or @parent_cache.nil?
+            [:comment, :journal, :photograph, :project, :page].each do |p|
+              if self.respond_to?(p) and parent = self.send(p)
+                # We found an applicable parent.
+                @parent_cache = parent
+                return parent
+              end
             end
+            # We didn't find any parent
+            nil
+          else
+            @parent_cache
           end
-          # We didn't find any parent
-          nil
-        else
-          @parent_cache
         end
-      end
 
-      # Returns the top-level parent of a given comment.
-      def root_parent
-        if parent
-          parent.root_parent
-        else
-          self
+        # Returns the top-level parent of a given comment.
+        def root_parent
+          if parent
+            parent.root_parent
+          else
+            self
+          end
         end
       end
     end