cortex-reaver 0.0.1

data/lib/cortex_reaver/support/cached_rendering.rb

@@ -0,0 +1,79 @@
+module CortexReaver
+  module Model
+
+    # 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])
+            end
+          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 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 self.render_fields
+            @render_fields ||= {}
+          end
+        end
+      end
+
+      # Default renderer
+      def render(value)
+        value  
+      end
+
+      def render_fields
+        self.class.render_fields
+      end
+    end
+  end
+end

data/lib/cortex_reaver/support/canonical.rb

@@ -0,0 +1,107 @@
+module CortexReaver
+  module Model
+    # Supports canonical, url-safe identifiers for records, inferred from other
+    # fields.
+    module Canonical
+
+      # The canonical name attribute
+      CANONICAL_NAME_ATTR = :name
+      # The attribute we infer the canonical name from, if not set.
+      CANONICAL_INFERENCE_ATTR = :title
+
+      def self.included(base)
+        base.class_eval do
+          # Canonical names which cannot be reserved.
+          def self.reserved_canonical_names
+            @reserved_canonical_names ||= []
+          end
+
+          def self.reserved_canonical_names=(names)
+            @reserved_canonical_names = names
+          end
+
+          # Canonicalize a string. Optionally, ignore conflicts with the record
+          # with id.
+          def self.canonicalize(string, id = nil)
+            # Lower case, remove special chars, and replace with hyphens.
+            proper = string.downcase.gsub(/[^a-z0-9_]/, '-').squeeze('-')[0..250].sub(/-$/, '')
+
+            # If proper is blank, just return it at this point.
+            if proper.blank?
+              return proper
+            end
+
+            # Numeric suffix to append
+            suffix = nil
+
+            if proper != filter(:id => id).map(canonical_name_attr).first
+              # We don't already have this name.
+
+              similar = []
+
+              if filter(canonical_name_attr => proper).limit(1).count > 0
+                similar << proper
+                # This name already exists, and it's not ours!
+                similar += filter(canonical_name_attr.like(/^#{proper}\-[0-9]+$/)).map(canonical_name_attr)
+              end
+
+              # Check for reserved names
+              reserved_canonical_names.each do |name|
+                if name =~ /^#{proper}(-\d+)?$/
+                  similar << name
+                end
+              end
+
+              # Find possible conflicting names from actions on this model's controller.
+#              if self.respond_to? :url and controller = Ramaze::Controller.at(self.url)
+#                similar += controller.action_methods.select do |action|
+#                  action =~ /^#{proper}(-\d+)?$/
+#                end
+#              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
+            end
+
+            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
+          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
+          end
+        end
+      end
+    end
+  end
+end

data/lib/cortex_reaver/support/comments.rb

@@ -0,0 +1,69 @@
+module CortexReaver
+  module Model
+    # 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_delete(: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
+          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
+        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
+            end
+          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
+        end
+      end
+    end
+  end
+end

data/lib/cortex_reaver/support/pagination.rb

@@ -0,0 +1,38 @@
+module CortexReaver
+  module Model
+    # Defines class-level accessors for page size, order attribute, etc.
+    module Pagination
+      DEFAULT_SIZE = 16
+      DEFAULT_ORDER = 'created_on'
+      DEFAULT_REVERSE = false
+
+      def self.included(base)
+        base.class_eval do
+          class << self
+            attr_accessor :page_size, :page_order, :page_reverse
+          end
+
+          @page_size ||= CortexReaver::Model::Pagination::DEFAULT_SIZE
+          @page_order ||= CortexReaver::Model::Pagination::DEFAULT_ORDER
+          @page_reverse ||= CortexReaver::Model::Pagination::DEFAULT_REVERSE
+        end
+
+        # Returns a paginated dataset at page number. Optionally, filters on
+        # dataset instead of the whole model.
+        def page(number, dataset = self.dataset)
+          if reverse
+            dataset = dataset.reverse
+          end
+
+          dataset.order(@order).paginate(number, @page_size)
+        end
+      end
+
+      # Returns the page number for this model. Optionally, filters on dataset
+      # rather than the whole model.
+      def page_number(dataset = self.class.dataset)
+        
+      end
+    end
+  end
+end

data/lib/cortex_reaver/support/renderer.rb

@@ -0,0 +1,196 @@
+module CortexReaver
+  module Model
+    # Some common rendering methods, wrapped up for your convenience. Use in your model
+    # with something like:
+    #
+    # render :body, :with => :render_comment
+    #
+    # See CortexReaver::Model::CachedRendering for more details.
+    module Renderer
+      require 'bluecloth'
+      require 'hpricot'
+      require 'syntax'
+
+      # Elements to allow in sanitized HTML.
+      ELEMENTS = [
+        'a', 'b', 'blockquote', 'br', 'code', 'dd', 'dl', 'dt', 'em', 'i', 'li',
+        'ol', 'p', 'pre', 'small', 'strike', 'strong', 'sub', 'sup', 'u', 'ul'
+      ]
+   
+      # Attributes to allow in sanitized HTML elements.
+      ATTRIBUTES = {
+        'a' => ['href', 'title'],
+        'pre' => ['class']
+      }
+      
+      # Attributes to add to sanitized HTML elements.
+      ADD_ATTRIBUTES = {
+        'a' => {'rel' => 'nofollow'}
+      }
+   
+      # Attributes that should be checked for valid protocols.
+      PROTOCOL_ATTRIBUTES = {'a' => ['href']}
+   
+      # Valid protocols.
+      PROTOCOLS = ['ftp', 'http', 'https', 'mailto']
+
+      
+      # Renders plain text and html to html.
+      def bluecloth(text)
+        return text if text.nil?
+
+        BlueCloth::new(text).to_html
+      end
+
+      # Replace <% and %> to prevent Erubis injection.
+      def erubis_filter(text)
+        return text if text.nil?
+        
+        t = text.dup
+        t.gsub!('<%', '&lt;%')
+        t.gsub!('%>', '%&rt;')
+        t
+      end
+
+      # Macro substitutions
+      #
+      # Expands [[type:resource][name]] macros. Right now, resource is just an attachment.
+      # Included types are:
+      #
+      # url: returns the URL to an attachment
+      # image: returns an image tag
+      # link: returns a link to an attachment
+      #
+      # The default action is a link, so
+      #
+      # [[foo.jpg]] => <a href="/data/.../foo.jpg">foo.jpg</a>
+      def macro(text)
+        return text if text.nil?
+
+        copy = text.dup
+
+        # Links
+        # 
+        # Example                         [[image:foo.png][name]]
+        # 1. the link type prefix         image:
+        # 2. the link type, sans-colon    image
+        # 3. the link itself              foo.png
+        # 4. the second half of the link  [name]
+        # 5. the name                     name 
+       copy.gsub!(/\[\[(([^\]]+):)?([^\]]+)(\]\[([^\]]+))?\]\]/) do |match|
+          prefix = $2
+          path = $3
+          name = $5
+
+          # Find the link target
+          target = attachment(path)
+
+          if target.exists?
+            # Name of the link
+            name ||= path
+
+            # Create link to this target
+            case prefix
+            when 'image'
+              # Create an inline image
+              "<img src=\"#{target.public_path}\" alt=\"#{name.gsub('"', '&quot;')}\" title=\"#{name.gsub('"', '&quot')}\" />"
+            when 'url'
+              # Create a URL
+              target.public_path
+            else
+              # Create a full link
+              "<a href=\"#{target.public_path}\">#{Rack::Utils.escape_html(name).gsub(/#([{@$]@?)/, '&#35;\1')}</a>"
+            end
+          else
+            # Don't create a link
+            match
+          end
+        end
+       
+        copy
+      end
+
+      def syntax_highlight(text)
+        return text if text.nil?
+
+        h = Hpricot(text)
+
+        h.search('cr:code').replace do |code|
+          code[:lang]
+        end
+      end
+
+      # Stolen wholesale from Ryan's Thoth (http://github.com/rgrove/thoth/)
+      # Who adapted it from http://rid.onkulo.us/archives/14-sanitizing-html-with-ruby-and-hpricot
+      def sanitize_html(html)
+        return html if html.nil?
+
+        h = Hpricot(html)
+  
+        h.search('*').each do |el|
+          if el.elem?
+            tag = el.name.downcase
+   
+            if ELEMENTS.include?(tag)
+              if ATTRIBUTES.has_key?(tag)
+                # Delete any attribute that isn't in the whitelist for this
+                # particular element.
+                el.raw_attributes.delete_if do |key, val|
+                  !ATTRIBUTES[tag].include?(key.downcase)
+                end
+   
+                # Check applicable attributes for valid protocols.
+                if PROTOCOL_ATTRIBUTES.has_key?(tag)
+                  el.raw_attributes.delete_if do |key, val|
+                    PROTOCOL_ATTRIBUTES[tag].include?(key.downcase) &&
+                        (!(val.downcase =~ /^([^:]+)\:/) || !PROTOCOLS.include?($1))
+                  end
+                end
+              else
+                # Delete all attributes from elements with no whitelisted
+                # attributes.
+                el.raw_attributes = {}
+              end
+   
+              # Add required attributes.
+              if ADD_ATTRIBUTES.has_key?(tag)
+                el.raw_attributes.merge!(ADD_ATTRIBUTES[tag])
+              end
+            else
+              # Delete any element that isn't in the whitelist.
+              el.parent.replace_child(el, el.children)
+            end
+          elsif el.comment?
+            # Delete all comments, since it's possible to make IE execute JS
+            # within conditional comments.
+            el.swap('')
+          end
+        end
+   
+        h.to_s
+      end
+
+      # Default renderer
+      def render(text)
+        bluecloth(
+          macro(
+            erubis_filter(
+              text
+            )
+          )
+        ) # (((Feeling) LISPish yet)?)
+      end
+
+      # Comments render
+      def render_comment(text)
+        bluecloth(
+          erubis_filter(
+            sanitize_html(
+              text
+            )
+          )
+        )
+      end
+    end
+  end
+end