cortex-reaver 0.0.1

data/lib/cortex_reaver/helper/feeds.rb

@@ -0,0 +1,88 @@
+module Ramaze
+  module Helper
+    # Adds an atom method to each controller it's included in, which 
+    # lists that controller's recent elements by yielding a block with
+    # each record and a builder object for the feed.
+    #
+    # Requires crud.
+    module Feeds
+      require 'builder'
+
+      Helper::LOOKUP << self
+
+      def self.included(base)
+        base.instance_eval do
+          def self.for_feed(&block)
+            @for_feed_block = block
+          end
+
+          def self.for_feed_block
+            @for_feed_block
+          end
+        end
+      end
+
+      def atom
+        atom_builder
+      end
+
+      private
+
+      def atom_builder(params = {:model_class => self.model_class})
+        response['Content-Type'] = 'application/atom+xml'
+
+        x = Builder::XmlMarkup.new(:indent => 2)
+        x.instruct!
+
+        # Get model class to work with
+        model_class = params[:model_class]
+
+        # Get recent items
+        recent = params[:recent] || model_class.recent
+
+        # Find update time
+        updated = recent.first.updated_on.xmlschema
+
+        x.feed(:xmlns => 'http://www.w3.org/2005/Atom') do
+          x.id = model_class.url
+          x.title CortexReaver.config.name + ' - ' + model_class.to_s.demodulize.titleize
+          # x.subtitle
+          x.updated updated
+          x.link :href => model_class.url
+          x.link :href => model_class.atom_url, :rel => 'self'
+
+          recent.all do |model|
+            x.entry do
+              x.id model.url
+              x.title model.title
+              x.published model.created_on.xmlschema
+              x.updated model.updated_on.xmlschema
+              x.link :href => model.url, :rel => 'alternate'
+
+              x.author do
+                x.name model.user.name
+
+                if model.user.http
+                  x.uri model.user.http
+                end
+              end
+
+              # Any additional controller-specific info
+              if self.class.for_feed_block
+                self.class.for_feed_block.call(model, x)
+              end
+            end
+          end
+        end
+      end
+
+      def feeds
+        @feeds ||= {}
+      end
+
+      def feed(title, href)
+        feeds[title] = href
+      end
+    end
+  end
+end

data/lib/cortex_reaver/helper/form.rb

@@ -0,0 +1,114 @@
+module Ramaze
+  module Helper
+    # Helps make forms, especially by escaping.
+    module Form
+
+      # Displays errors on a record.
+      def errors_on(model)
+        unless model.errors.empty?
+          s = "<div class=\"form-errors\">\n<h3>Errors</h3>\n<ul>\n"
+          model.errors.each do |attribute, error|
+            s << "<li>#{attribute} #{error}</li>\n"
+          end
+          s << "</ul></div>"
+        end
+      end
+
+      # Makes a form for a model. Takes a model, form action, and an array of
+      # fields, which are passed to form_p.
+      def form_for(model, action, fields = [])
+        if model.nil?
+          raise ArgumentError.new("needs a model")
+        elsif action.nil?
+          raise ArgumentError.new("needs an action")
+        end
+
+        f = ''
+
+        unless model.errors.empty?
+          f << "<div class=\"form-errors\">\n"
+          f << "<ul>\n"
+          model.errors.each do |attribute, error|
+            f << "<li>#{attribute} #{error}\n</li>"
+          end
+          f << "</ul>\n"
+          f << "</div>\n"
+        end
+
+        f = "<form action=\"#{action}\" method=\"post\" class=\"edit-form\">"
+
+        fields.each do |field|
+          case field
+          when Array
+            f << form_p(field[0], ({:model => model}.merge!(field[1] || {})))
+          else
+            f << form_p(field, :model => model)
+          end
+        end
+
+        f << form_submit("Submit #{model.class.to_s.demodulize.titleize}")
+      end
+
+      # Makes a paragraph for accessing an attribute. Escapes the default value.
+      # Parameters:
+      #   id => the HTML id/name of the form field.
+      #   :type => the type of form field to generate (text, password, checkbox...)
+      #   :description => The label for the field (inferred from id by default)
+      #   :model => The model to query for fields
+      #   :default => The default value for the field (inferred from model and id)
+      def form_p(id, params = {})
+        type = params[:type]
+        description = params[:description] || id.to_s.titleize
+        model = params[:model]
+        default = params[:default]
+        if model and not default
+          default = model.send(id)
+        end
+
+        unless type
+          case default
+          when true
+            type = 'checkbox'
+        when false
+            type = 'checkbox'
+          else
+            type = 'text'
+          end
+        end
+
+        f = '<p>'
+        unless type == 'checkbox' or type == 'hidden'
+          f << "<label for=\"#{id}\">#{description}</label>"
+        end
+
+        if type == 'textarea'
+          f << '<br />'
+        end
+
+        case type
+        when 'textarea'
+          f << "<textarea name=\"#{id}\" id=\"#{id}\">#{default}</textarea>"
+        when 'checkbox'
+          f << "<input type=\"checkbox\" name=\"#{id}\" id=\"#{id}\" #{default ? 'checked="checked"' : ''} />"
+        else
+         f << "<input name=\"#{id}\" id=\"#{id}\" type=\"#{type}\" value=\"#{attr_h(default)}\" />"
+        end
+
+        if type == 'checkbox'
+          f << "<label class=\"checkbox\" for=\"#{id}\">#{description}</label>"
+        end
+
+        f << "</p>\n"
+      end
+
+      def form_submit(value = "Submit")
+        '<p><input name="submit" type="submit" value="' + attr_h(value) + '" /></p>'
+      end
+
+      # Escapes quotes for HTML attributes.
+      def attr_h(string)
+        h(string).gsub('"', '&quot;')
+      end
+    end
+  end
+end

data/lib/cortex_reaver/helper/navigation.rb

@@ -0,0 +1,142 @@
+module Ramaze
+  module Helper
+    # Provides navigation rendering shortcuts
+    module Navigation
+      # Returns a div with next/up/previous links for the record.
+      def model_nav(model)
+        n = '<div class="navigation actions">'
+        if model.previous
+          n << '  <a class="previous" href="' + model.previous.url + '">&laquo; Previous ' + model.class.to_s.demodulize + '</a>'
+        end
+        n << '  <a class="up" href="' + model.absolute_window_url + '">Back to ' + model.class.to_s.demodulize.pluralize + '</a>'
+        if model.next
+          n << '  <a class="next" href="' + model.next.url + '">Next ' + model.class.to_s.demodulize + ' &raquo;</a>'
+        end
+        n << '</div>'
+      end
+
+      # Generate pagination links from a Sequenceable class and index.
+      # The index can be :first or :last for the corresponding pages, an instance
+      # of the class (in which case the page which would contain that instance
+      # is highlighted, or a page number. Limit determines how many numeric links
+      # to include--use :all to include all pages.
+      def page_nav(klass, index = nil, limit = 15)
+        # Translate :first, :last into corresponding windows.
+        case index
+        when :first
+          page = 0
+        when :last
+          page = klass.window_count - 1
+        when klass
+          # Index is actually an instance of the target class
+          page = index.window_absolute_index
+        else
+          # Index is a page number
+          page = index.to_i
+        end
+
+        pages = Array.new
+        links = '<ol class="pagination actions">'
+        window_count = klass.window_count
+
+        # Determine which pages to create links to
+        if limit.kind_of? Integer and window_count > limit
+          # There are more pages than we can display.
+
+          # Default first and last pages are the size of the collection
+          first_page = 1
+          last_page = window_count - 2
+
+          # The desired number of previous or next pages
+          previous_pages = (Float(limit - 3) / 2).floor
+          next_pages = (Float(limit - 3) / 2).floor
+
+          if (offset = first_page - (page - previous_pages)) > 0
+            # Window extends before the start of the pages
+            last_page = first_page + (limit - 2)
+          elsif (offset = (page + next_pages) - last_page) > 0
+            # Window extends beyond the end of the pages
+            first_page = last_page - (limit - 2)
+          else
+            # Window is somewhere in the middle
+            first_page = page - previous_pages
+            last_page = page + next_pages
+          end
+
+          # Generate list of pages
+          pages = [0] + (first_page..last_page).to_a + [window_count - 1]
+        else
+          # The window encompasses the entire set of pages
+          pages = (0 .. window_count - 1).to_a
+        end
+
+        if page > 0
+          # Add "previous page" link.
+          links << "<li><a href=\"#{klass.url}/page/#{page - 1}\">&laquo; Previous</a></li>"
+        end
+
+        # Convert pages to links
+        unless pages.empty?
+          pages.inject(pages.first - 1) do |previous, i|
+            if (i - previous) > 1
+              # These pages are not side-by-side.
+              links << '<li>&hellip;</li>'
+            end
+
+            if i == page
+              # This is a link to the current page.
+              links << "<li class=\"current\">#{i + 1}</li>"
+            else
+              # This is a link to a different page.
+              links << "<li><a href=\"#{klass.url}/page/#{i}\">#{i + 1}</a></li>"
+            end
+
+            # Remember this as the previous page.
+            i
+          end
+        end
+
+        if page < klass.window_count - 1
+          # Add "next page" link.
+          links << "<li><a href=\"#{klass.url}/page/#{page + 1}\">Next &raquo;</a></li>"
+        end
+
+        links << '</ol>'
+      end
+
+      # Returns a link to a user.
+      def user_link(x)
+        case x
+        when CortexReaver::User
+          name = x.name || x.login
+          A(name, :href => x.url)
+        when CortexReaver::Comment
+          if x.user
+            # Use attached user
+            user_link x.user
+          else
+            # Use anonymous info
+            name = x.name || x.email || 'Anonymous'
+            if x.email
+              s = "<a href=\"mailto:#{attr_h x.email}\">#{h name}</a>"
+              if x.http
+                s << " (<a href=\"#{attr_h x.http}\" rel=\"nofollow\">#{h x.http}</a>)"
+              end
+              s
+            elsif x.http
+              "<a href=\"#{attr_h x.http}\" rel=\"nofollow\">#{h name}</a>"
+            else
+              h name
+            end
+          end
+        else
+          if x.respond_to? :user
+            user_link x.user
+          else
+            raise ArgumentError.new("don't know how to make a user link to #{x.inspect}")
+          end
+        end
+      end
+    end
+  end
+end

data/lib/cortex_reaver/helper/photographs.rb

@@ -0,0 +1,25 @@
+module Ramaze
+  module Helper
+    # Helps display photographs
+    module Photographs
+      def description_of(photo)
+        begin
+          if exif = photo.exif
+            description = ''
+            description << photo.date.strftime('%m/%d/%Y') + ': '
+            description << exif.make if exif.make
+            description << ' ' + exif.model + ', ' if exif.model
+            description << ' ' + exif.focal_length_in_35mm_film.to_i.to_s + 'mm' if exif.focal_length_in_35mm_film
+            description << ' at ' + exposure_time_to_s(exif.exposure_time) if exif.exposure_time
+            description << ' F' + exif.f_number.to_f.to_s if exif.f_number
+          else
+            nil
+          end
+        rescue
+          # File might not be available, or EXIF might be missing... 
+          return description
+        end
+      end
+    end
+  end
+end

data/lib/cortex_reaver/helper/tags.rb

@@ -0,0 +1,47 @@
+module Ramaze
+  module Helper
+    module Tags
+      # Adds an AJAX-ified tag editor for a model.
+      def live_tags_field(model, opts={:name => 'tags'})
+        name = opts[:name]
+        title = opts[:title] || name.to_s.titleize
+        
+        s = "<p><label for=\"#{name}\">#{title}</label>"
+        s << "<input name=\"#{name}\" id=\"#{name}\" type=\"text\" class=\"autobox\" value=\"#{attr_h(tags_on(model, false))}\" />"
+        s << "</p>"
+
+        s << <<EOF
+
+<script type="text/javascript">
+/* <![CDATA[ */
+
+
+/* ]]> */
+</script>
+EOF
+      end
+
+      # Returns an html list of tags on a model that supports #tags.
+      def tags_on(model, html=true)
+        begin
+          if html
+            t = '<ul class="tags">'
+            model.tags.each do |tag|
+              t << "<li><a href=\"#{tag.url}\">#{tag.title}</a></li>"
+            end
+            t << '</ul>'
+          else
+            t = model.tags.map{ |t| t.title }.join(', ')
+          end
+        rescue
+          # HACK: This is probably only going to break because a blank model is
+          # missing a primary key or something like that. Since we call this
+          # method SO much (and because that specific error is not subclassed
+          # by Sequel) no custom error handling here.
+          ''
+        end
+      end
+    end
+  end
+end
+

data/lib/cortex_reaver/helper/workflow.rb

@@ -0,0 +1,27 @@
+module Ramaze
+  module Helper
+    # Provides workflow links on a per-section basis
+    module Workflow
+      def workflows
+        @workflows
+      end
+
+      def workflow(name, href)
+        @workflows ||= []
+        @workflows << [name, href]
+      end
+
+      def workflowbox
+        if @workflows
+          b = '<div class="workflows">'
+          b << '  <ul>'
+          @workflows.each do |name, href|
+            b << "    <li><a href=\"#{href}\">#{name}</a></li>"
+          end
+          b << '  </ul>'
+          b << '</div>'
+        end
+      end
+    end
+  end
+end