cortex-reaver 0.0.1

data/lib/cortex_reaver/support/sequenceable.rb

@@ -0,0 +1,248 @@
+module CortexReaver
+  module Model
+    # Sequences are models that have order. This module provides class
+    # and instance methods that support sequential behavior like pagination, finding
+    # the next or previoud record, and finding a "window" of results around a 
+    # specific record.
+
+    module Sequenceable
+
+      # Which column table to order this sequence by
+      DEFAULT_SEQUENCE_ORDER = :created_on
+      DEFAULT_SEQUENCE_REVERSE = false
+      DEFAULT_WINDOW_SIZE = 16
+
+      # Class methods
+      def self.included(base)
+        base.instance_eval do
+          attr_writer :sequence_order, :sequence_reverse, :window_size
+          
+          # Returns the sequence dataset (optionally, restricted to dataset)
+          def sequence(dataset = self.dataset)
+            if sequence_reverse
+              dataset.reverse_order(sequence_order)
+            else
+              dataset.order(sequence_order)
+            end
+          end
+
+          # Returns the first record in the sequence
+          def first
+            sequence.first
+          end
+
+          # Returns the last record in the sequence
+          def last
+            sequence.last
+          end
+
+          # Returns the table column to order by 
+          def sequence_order
+            @sequence_order || DEFAULT_SEQUENCE_ORDER
+          end
+
+          # Sets the table column to order by 
+          def sequence_order=(order)
+            @sequence_order = order
+          end
+
+          # Returns whether or not to reverse the order
+          def sequence_reverse
+            @sequence_reverse || DEFAULT_SEQUENCE_REVERSE
+          end
+
+          # Sets whether to reverse the sequence
+          def sequence_reverse=(reverse)
+            @sequence_reverse = reverse
+          end
+
+          # Returns an absolute window into this sequence, specified as an offset in 
+          # window-sized increments from the beginning of the sequence. Hence 
+          # window(0, 10) returns the first ten records in the sequence, window(1, 10)
+          # the next ten, and so on.
+          #
+          # One can also specify the special page_offsets :first or :last, which
+          # return the first and last available windows.
+          def window(page_offset, size = self.window_size)
+            case page_offset
+              when :first
+                page_offset = 0
+              when :last
+                page_offset = window_count(size) - 1
+              else
+                page_offset = page_offset.to_i
+            end
+
+            # Don't ask for negative pages!
+            page_offset = 0 if page_offset < 0
+
+            # Calculate offset
+            offset = page_offset * size
+
+            # Limit dataset
+            sequence.limit size, offset
+          end
+
+          # Returns the number of windows required to span this sequence
+          def window_count(size = self.window_size)
+            (Float(sequence.count) / size).ceil
+          end
+
+          # Returns the size of a window into this sequence
+          def window_size
+            @window_size || DEFAULT_WINDOW_SIZE
+          end
+
+          # Sets the size of a window into this sequence
+          def window_size=(size)
+            @window_size = size
+          end
+        end
+      end
+
+      # Instance methods
+
+      # Convenience references to class methods
+      def sequence
+        self.class.sequence
+      end
+
+      def sequence_order
+        self.class.sequence_order
+      end
+
+      def sequence_reverse
+        self.class.sequence_reverse
+      end
+
+      # Returns the next record in the sequence. Caches--use next(true) to refresh.
+      def next(refresh_cache = false)
+        if refresh_cache
+          @next = sequence.filter(sequence_order > send(sequence_order)).limit(1).first
+        else
+          @next ||= sequence.filter(sequence_order > send(sequence_order)).limit(1).first
+        end
+      end
+
+      # Returns true if a next record exists. Caches--use next(true) to refresh.
+      def next?(refresh_cache = false)
+        if refresh_cache
+          @next_exists ||= self.next_count > 0 ? true : false
+        else
+          @next_exists = self.next_count > 0 ? true : false
+        end
+      end
+     
+      # Returns the number of succeeding records
+      def next_count
+        sequence.filter(sequence_order > send(sequence_order)).count
+      end
+
+      # Returns the previous record in the sequence. Caches--use previous(true) to
+      # refresh.
+      def previous(refresh_cache = false)
+        if refresh_cache
+          @previous = sequence.filter(sequence_order < send(sequence_order)).reverse.limit(1).first
+        else
+          @previous ||= sequence.filter(sequence_order < send(sequence_order)).reverse.limit(1).first
+        end 
+      end
+
+      # Returns true if a previous record exists. Caches--use previous?(true) to
+      # refresh.
+      def previous?(refresh_cache = false)
+        if refresh_cache
+          @previous_exists = self.previous_count > 0 ? true : false
+        else
+          @previous_exists ||= self.previous_count > 0 ? true : false
+        end
+      end
+
+      # Returns the number of preceding records
+      def previous_count
+        sequence.filter(sequence_order < send(sequence_order)).count
+      end
+
+      alias :position :previous_count
+
+      # Returns a collection of records around this record.
+      # Mode is one of:
+      # 1. :absolute Returns a window containing this record in even multiples from
+      #              the first record, like a page of a book.
+      # 2. :float    Returns a centered window of the provided size. If the edge of
+      #              the sequence is reached, the window shifts to include more
+      #              elements of the sequence. If no more elements are available 
+      #              (the window is larger than the size of the sequence), the 
+      #              entire sequence is returned. If the size is even, one more
+      #              record is returned suceeding this record than preceding this
+      #              record, if possible.
+      # 3. :clip     Returns a centered window of or smaller than the given size. If
+      #              the edge of the sequence is reached, the window is clipped.
+      def window(mode = :absolute, size = self.class.window_size)
+        case mode
+          when :absolute
+            # Calculate page offset
+            offset = (Float(position) / size).floor * size
+
+            # Find records
+            sequence.limit(size, offset)
+          when :float
+            count = sequence.count			# Total records
+            if size >= count
+              # Window includes all records in the sequence
+              return self.class.find(:all)
+            else
+              # Window is smaller than the sequence
+              position = self.position			              # This record's position
+              previous_size = (Float(size - 1) / 2).floor	# How many records before
+              next_size = (Float(size - 1) / 2).ceil		  # How many records after
+
+              # Shift window if necessary
+              if (displacement = previous_size - position) > 0
+                # The window extends before the start of the sequence
+                previous_size -= displacement
+              elsif (displacement = next_size - self.next_count) > 0
+                # The window extends beyond the end of the sequence
+                previous_size += displacement
+              end
+
+              # Calculate window offset
+              offset = position - previous_size
+
+              # Find records
+              sequence.limit(size, offset)
+            end
+          when :clip
+            position = self.position                    # Our position in sequence
+            previous_size = (Float(size - 1) / 2).floor # How many records before
+
+            if (displacement = previous_size - position) > 0
+              # The window extends before the beginning of the sequence
+              size -= displacement
+              offset = 0
+            else
+              # The window doesn't extend before the beginning of the sequence.
+              offset = position - previous_size
+            end
+
+            # Find records.
+            sequence.limit(size, offset)
+          else
+            raise ArgumentError.new('first argument must be one of :absolute, :float, :clip')
+        end
+      end
+
+      # Returns a url for this record, viewed in an absolute window. TODO: handle non-default window sizes.
+      def absolute_window_url(size = self.class.window_size)
+        page = (Float(position) / size).floor
+        self.class.url + '/page/' + page.to_s + '#' + self.class.to_s.underscore + 
+          '_' + send(self.class.canonical_name_attr)
+      end
+
+      # Returns the absolute window index that this record appears in
+      def absolute_window_index(size = self.class.window_size)
+        (Float(self.position) / size).floor
+      end
+    end
+  end
+end

data/lib/cortex_reaver/support/tags.rb

@@ -0,0 +1,108 @@
+module CortexReaver
+  module Model
+    module Tags
+      # Support for taggable models
+     
+      def self.included(base)
+        base.class_eval do
+          # If tags have changed, make sure to update those tags' counts.
+          after_save(:update_tag_counts) do
+            if @added_tags
+              @added_tags.each do |tag|
+                tag.count += 1
+                tag.save
+              end
+              @removed_tags.each do |tag|
+                tag.count -= 1
+                tag.save
+              end
+            end
+          end
+
+          # Remove tags on deletion
+          before_destroy(:drop_associated_tags) do
+            tags.each do |tag|
+              tag.count -= 1
+              if tag.count == 0
+                tag.destroy
+              else
+                tag.save
+              end
+            end
+            remove_all_tags
+          end
+
+          # Returns all models with ALL the following tags:
+          def self.tagged_with(tags)
+            # Find map between this model and tags, e.g. pages_tags
+            map = [table_name.to_s, 'tags'].sort.join('_').to_sym
+            
+            # The name in the mapping table which points to us
+            own_id = (table_name.to_s.singularize + '_id').to_sym
+            
+            # The tag IDs to search for
+            ids = tags.map { |t| t.id }
+            
+            # Now filter this model, finding all ids which appear n times with
+            # the same model_id in the mapping table, which has been filtered
+            # to contain only rows with one of our interesting tags.
+            #
+            # Man, don't you wish MySQL had intersect?
+            filter(:id =>
+              CortexReaver.db[map].filter(:tag_id => ids).group(own_id).having(
+                "count(*) = #{ids.size}"
+              ).select(own_id)
+            )
+          end
+        end
+      end
+
+      # Set tags from a string, or array of tags. Finds existing tags or
+      # creates new ones. Also updates tag counts.
+      def tags=(tags)
+        if tags.kind_of? String
+          tags = tags.squeeze(',').split(',').map do |title|
+            title.strip!
+            if title.blank?
+              # Do nothing
+              tag = nil
+            else
+              # Look up existing tag
+              tag = Tag[:title => title]
+              # Or create new one
+              tag ||= Tag.create(:title => title, :name => Tag.canonicalize(title))
+              unless tag
+                # Everything failed
+                raise RuntimeError.new("couldn't find or create tag for #{title}")
+              end
+            end
+            tag
+          end
+        end
+
+        unless tags.respond_to? :each
+          raise ArgumentError.new("Needed a string or Enumerable of Tags, got #{tags.class}")
+        end
+
+        # Get rid of empty tags
+        tags.reject do |tag|
+          tag.nil?
+        end
+        tags.uniq!
+
+        # Find which tags to change. Their counts are updated by an after_save
+        # callback.
+        old_tags = self.tags
+        @removed_tags = old_tags - tags
+        @added_tags = tags - old_tags
+
+        # Change own tags
+        remove_all_tags
+        tags.each do |tag|
+          add_tag tag
+        end
+      end
+
+    end
+  end
+end

data/lib/cortex_reaver/support/timestamps.rb

@@ -0,0 +1,33 @@
+module CortexReaver
+  module Model
+    # Supports updated_on and created_on behavior
+    module Timestamps
+      def self.included(base)
+        base.class_eval do
+          # Create
+          before_create(:init_timestamp) do
+            unless skip_timestamp_update?
+              self.created_on = Time.now
+              self.updated_on = Time.now
+            end
+          end
+
+          # Update
+          before_update(:update_timestamp) do
+            unless skip_timestamp_update?
+              self.updated_on = Time.now
+            end
+          end
+        end
+      end
+
+      def skip_timestamp_update=(boolean)
+        @skip_timestamp_update = boolean
+      end
+
+      def skip_timestamp_update?
+        @skip_timestamp_update
+      end
+    end
+  end
+end

data/lib/cortex_reaver/version.rb

@@ -0,0 +1,8 @@
+module CortexReaver
+  APP_NAME = 'Cortex Reaver'
+  APP_VERSION = '0.0.1'
+  APP_AUTHOR = 'aphyr'
+  APP_EMAIL = 'aphyr@aphyr.com'
+  APP_URL = 'http://aphyr.com'
+  APP_COPYRIGHT = 'Copyright (c) 2008 aphyr <aphyr@aphyr.com>. All rights reserved.'
+end

data/lib/cortex_reaver/view/adminbox.rhtml

@@ -0,0 +1,56 @@
+<div id="adminbox">
+  <% if admin? %>
+    <table class="actions-table">
+      <tr>
+        <td class="title">Sections</td>
+        <td>
+          <ul class="actions">
+            <li><a href="/pages">Pages</a></li>
+            <li><a href="/projects">Projects</a></li>
+            <li><a href="/journals">Journals</a></li>
+            <li><a href="/photographs">Photographs</a></li>
+            <li><a href="/comments">Comments</a></li>
+            <li><a href="/tags">Tags</a></li>
+            <li><a href="/users">Users</a></li>
+            <li><a href="/config">Config</a></li>
+          </ul>
+        </td>
+      </tr>
+      <% if workflows %>
+        <tr>
+          <td class="title">Actions</td>
+          <td>
+            <ul class="actions">
+              <% workflows.each do |name, href| %>
+                <li>
+                  <a href="<%= href %>"
+                    <%= name.to_s[/delete|destroy/i] ? "onclick = \"return confirm('Are you sure you want to delete #{@title.gsub(/'"/, '')}?');\"" : '' %>>
+                    <%= name %>
+                  </a>
+                </li>
+              <% end %>
+            </ul>
+          </td>
+        </tr>
+      <% end %>
+    </table>
+
+    <div id="admin_user_actions">
+      <a href="/users/logout">Log out</a>
+    </div>
+  <% elsif session[:user] %>
+    <div id="admin_user_actions">
+      <a href="/users/logout">Log out</a>
+    </div>
+  <% else %>
+    <form action="/users/login" method="post">
+      <p>
+        <label for="admin_login">Login</label> <input type="text" name="login" id="admin_login" />
+        <label for="admin_password">Password</label> <input type="password" name="password" id="admin_password" />
+        <input type="hidden" id="target_uri" name="target_uri" value="<%= request.request_uri %>" />
+        <input type="submit" name="action" value="Log in" />
+      </p>
+    </form>
+  <% end %>
+  <div class="clear"></div>
+</div>