cortex-reaver 0.1.0 → 0.2.0

data/lib/cortex_reaver/migrations/014_convert_projects_to_pages.rb

@@ -0,0 +1,79 @@
+module CortexReaver
+  class ProjectsToPagesSchema < Sequel::Migration
+
+    def down
+      # Nope. Not even going to try.
+    end
+
+    def up
+      pages = self[:pages]
+      projects = self[:projects]
+
+      # Create projects page
+      unless root = pages.filter(:name => 'projects').first
+        pages.insert(
+          :name => 'projects',
+          :title => 'Projects',
+          :created_on => Time.now,
+          :updated_on => Time.now
+        )
+      end
+      root = pages.filter(:name => 'projects').first
+
+      # Migrate each project
+      projects.all.each do |project|
+        project_id = project[:id]
+
+        # Create page
+        project.delete :description
+        project.delete :id
+        project[:page_id] = root[:id]
+        pages << project
+
+        # Get page id
+        page_id = pages.filter(:page_id => root[:id], :name => project[:name]).first[:id]
+        
+        # Reparent comments
+        self[:comments].filter(:project_id => project_id).update(
+          :project_id => nil,
+          :page_id => page_id
+        )
+       
+        # Copy tags
+        self[:projects_tags].filter(:project_id => project_id).each do |t|
+          self[:pages_tags] << {:page_id => page_id, :tag_id => t[:tag_id]}
+        end
+
+        # Move attachments
+        # This is a little tricky; I'd like to deprecate the entire model at
+        # some point. We assume it lives in config.public_dir/data/projects/id
+        project_dir = File.join(
+          CortexReaver.config.public_root, 'data', 'projects', project_id.to_s
+        )
+        page_dir = File.join(
+          CortexReaver.config.public_root, 'data', 'pages', page_id.to_s
+        )
+        if File.directory? project_dir
+          if File.directory? page_dir
+            puts "WARNING: #{page_dir} already exists. Not moving contents of #{project_dir} into it. You should take a look."
+          else
+            FileUtils.move project_dir, page_dir
+          end
+        end
+        
+        projects.filter(:id => project_id).delete
+      end
+
+      # Drop associated columns
+      # Can't do this yet--foreign key constraints...
+#      alter_table :comments do
+#        drop_column :project_id
+#      end
+
+      # Drop projects table
+      unless table_exists? :projects
+        drop_table :projects
+      end
+    end
+  end
+end

data/lib/cortex_reaver/model/comment.rb

@@ -10,7 +10,6 @@ module CortexReaver
     many_to_one :creator, :class => 'CortexReaver::User', :key => 'created_by'
     many_to_one :updater, :class => 'CortexReaver::User', :key => 'updated_by'
     many_to_one :journal, :class => 'CortexReaver::Journal'
-    many_to_one :project, :class => 'CortexReaver::Project'
     many_to_one :photograph, :class => 'CortexReaver::Photograph'
     many_to_one :page, :class => 'CortexReaver::Page'
     many_to_one :comment, :class => 'CortexReaver::Comment'
@@ -90,21 +89,21 @@ module CortexReaver
 
     def validate
       validates_presence :body
-      validates_max_length 255, :title
-      validates_max_length 255, :name
-      validates_max_length 255, :http
-      validates_max_length 255, :email
-      validates_format(/^([^@\s]+)@((?:[-a-z0-9]+\.)+[a-z]{2,})$/, :email)
+      validates_max_length 255, :title, :allow_blank => true
+      validates_max_length 255, :name, :allow_blank => true 
+      validates_max_length 255, :http, :allow_blank => true
+      validates_max_length 255, :email, :allow_blank => true
+      validates_format(/^([^@\s]+)@((?:[-a-z0-9]+\.)+[a-z]{2,})$/, :email, :allow_blank => true)
 
       # Ensure comments with an email specified do *not* conflict with another
       # user.
-      if (not email.blank?) and User.filter(:email => value).count > 0
+      if (not email.blank?) and User.filter(:email => email).count > 0
         self.errors[:email] << 'conflicts with a registered user'
       end
 
       # Ensures comments belong to exactly one parent.
       count = 0
-      [:page_id, :project_id, :journal_id, :comment_id, :photograph_id].each do |field|
+      [:page_id, :journal_id, :comment_id, :photograph_id].each do |field|
         unless self[field].blank?
           count += 1
           if count > 1

data/lib/cortex_reaver/model/page.rb

@@ -10,8 +10,10 @@ module CortexReaver
     plugin :viewable
     include CortexReaver::Model::Renderer
 
+    self.sequence_order = :name
+
     many_to_one :page, :class => 'CortexReaver::Page'
-    one_to_many   :pages, :class => 'CortexReaver::Page'
+    one_to_many   :pages, :class => 'CortexReaver::Page', :order => :name
     many_to_one :creator, :class => 'CortexReaver::User', :key => 'created_by'
     many_to_one :updater, :class => 'CortexReaver::User', :key => 'updated_by' 
     one_to_many   :comments, :class => 'CortexReaver::Comment'
@@ -111,12 +113,12 @@ module CortexReaver
     end
 
     # Create a default page if none exists.
-    if dataset.table_exists? and Page.count == 0
+    if db.table_exists?(table_name) and Page.count == 0
       Page.new(
         :name => 'about',
         :title => 'About Cortex Reaver',
         :body => <<EOF
-<p>Cortex Reaver is a blog engine designed for managing photographs, projects,
+<p>Cortex Reaver is a blog engine designed for managing photographs, pages,
 journal entries, and more, with support for tags and comments. Cortex
 Reaver is written in <a href="http://ruby-lang.org">Ruby</a> using <a
 href="http://ramaze.net">Ramaze</a>, uses the <a

data/lib/cortex_reaver/model/photograph.rb

@@ -10,7 +10,7 @@ module CortexReaver
 
     # Target image sizes
     SIZES = {
-      :thumbnail => '150x',
+      :thumbnail => '166x',
       :grid => '150x150',
       :small => 'x512',
       :medium => 'x768',
@@ -34,6 +34,12 @@ module CortexReaver
       reverse_order(:created_on).limit(16)
     end
 
+    def self.regenerate_sizes
+      all.each do |p|
+        p.regenerate_sizes
+      end
+    end
+
     def self.url
       '/photographs'
     end
@@ -72,19 +78,10 @@ module CortexReaver
       end
 
       # Write file to disk
-      attachment = Attachment.new(self, 'original.jpg')
-      attachment.file = file
-
-      # Read image through ImageMagick
-      image = Magick::Image.read(attachment.local_path).first
+      attachment = Attachment.new(self, 'original.jpg').file = file
 
-      # Write appropriate sizes to disk
-      SIZES.each do |size, geometry|
-        image.change_geometry(geometry) do |width, height|
-          attachment = Attachment.new(self, size.to_s + '.jpg')
-          image.scale(width, height).write(attachment.local_path)
-        end
-      end
+      # Compute thumbnails
+      regenerate_sizes
 
       true
     end
@@ -111,6 +108,53 @@ module CortexReaver
       attachment(size.to_s + '.jpg').path(type)
     end
 
+    # Regenerates various photo sizes.
+    def regenerate_sizes
+      Ramaze::Log.info "Regenerating photo sizes for #{self}"
+
+      # Find existing attachments, in order of decreasing (roughly) size
+      known_files = attachments.map{|a| a.name.sub(/\.jpg$/,'')} & (SIZES.keys.map(&:to_s) + ['original'])
+      largest = attachment(
+        known_files.sort_by { |f| 
+          File.stat(attachment("#{f}.jpg").path).size
+        }.last + '.jpg'
+      )
+
+      # Replace original.jpg with the largest available, if necessary.
+      orig = attachment 'original.jpg'
+      unless orig.exists? and orig == largest
+        orig.file = largest
+      end
+
+      # Delete everything but original.jpg
+      attachments.reject {|a| a.name == 'original.jpg'}.each{|a| a.delete}
+
+      # Read image through ImageMagick
+      begin
+        image = Magick::Image.read(orig.local_path).first
+      rescue => e
+        Ramaze::Log.error "Invalid image #{orig.local_path}; not processing."
+        return false
+      end
+
+      # Write appropriate sizes to disk
+      SIZES.each do |size, geometry|
+        image.change_geometry(geometry) do |width, height|
+          attachment = attachment(size.to_s + '.jpg')
+          image.scale(width, height).write(attachment.local_path)
+        end
+
+      end
+        
+      # Yep, GC time. Gotta clear out those imagemagick stubs.
+      GC.start
+
+      # Free IM stubs
+      GC.start
+
+      true
+    end
+
     # Returns the system path to the thumbnail photograph
     def thumbnail_local_path
       path :local, 'thumbnail'

data/lib/cortex_reaver/model/tag.rb

@@ -4,7 +4,6 @@ module CortexReaver
 
     many_to_many :photographs, :class => 'CortexReaver::Photograph'
     many_to_many :journals, :class => 'CortexReaver::Journal'
-    many_to_many :projects, :class => 'CortexReaver::Project'
     many_to_many :pages, :class => 'CortexReaver::Page'
 
     subset :unused, :count => 0
@@ -23,7 +22,6 @@ module CortexReaver
       
       remove_all_photographs
       remove_all_journals
-      remove_all_projects
       remove_all_pages
 
       true
@@ -62,8 +60,7 @@ module CortexReaver
       old_count = self[:count]
       self[:count] = photographs_dataset.count + 
         journals_dataset.count +
-        pages_dataset.count + 
-        projects_dataset.count
+        pages_dataset.count
       
       # Save and return
       changed = changed_columns.include? :count

data/lib/cortex_reaver/model/user.rb

@@ -9,12 +9,10 @@ module CortexReaver
     one_to_many :created_journals, :key => 'created_by', :class => 'CortexReaver::Journal'
     one_to_many :created_pages, :key => 'created_by', :class => 'CortexReaver::Page'
     one_to_many :created_photographs, :key => 'created_by', :class => 'CortexReaver::Photograph'
-    one_to_many :created_projects, :key => 'created_by', :class => 'CortexReaver::Project'
     one_to_many :updated_comments, :key => 'updated_by', :class => 'CortexReaver::Comment'
     one_to_many :updated_journals, :key => 'updated_by', :class => 'CortexReaver::Journal'
    one_to_many :updated_pages, :key => 'updated_by', :class => 'CortexReaver::Page'
     one_to_many :updated_photographs, :key => 'updated_by', :class => 'CortexReaver::Photograph'
-    one_to_many :updated_projects, :key => 'updated_by', :class => 'CortexReaver::Project'
 
 
     self.window_size = 64
@@ -70,6 +68,11 @@ module CortexReaver
       self[:login => id] || self[id]
     end
 
+    # Class URL
+    def self.url
+      '/users'
+    end
+
     # Returns true if the user is an administrator.
     def admin?
       self.admin
@@ -269,7 +272,7 @@ module CortexReaver
     public
 
     # Create default user if none exist
-    if dataset.table_exists? and count == 0
+    if db.table_exists?(table_name) and count == 0
       u = User.new(
         :login => 'shodan',
         :name => 'Shodan',

data/lib/cortex_reaver/plugin.rb

@@ -1,4 +1,4 @@
 module CortexReaver
-  module Plugin
+  module Plugins
   end
 end

data/lib/cortex_reaver/plugins/twitter.rb

@@ -0,0 +1,185 @@
+#--
+#
+# Kyle Kingsbury: This plugin is adapted from Ryan's Thoth. His license follows:
+#
+# Copyright (c) 2009 Ryan Grove <ryan@wonko.com>
+# All rights reserved.
+#
+# Redistribution and use in source and binary forms, with or without
+# modification, are permitted provided that the following conditions are met:
+#
+#   * Redistributions of source code must retain the above copyright notice,
+#     this list of conditions and the following disclaimer.
+#   * Redistributions in binary form must reproduce the above copyright notice,
+#     this list of conditions and the following disclaimer in the documentation
+#     and/or other materials provided with the distribution.
+#   * Neither the name of this project nor the names of its contributors may be
+#     used to endorse or promote products derived from this software without
+#     specific prior written permission.
+#
+# THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS "AS IS"
+# AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE
+# IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE ARE
+# DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT OWNER OR CONTRIBUTORS BE LIABLE
+# FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL
+# DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR
+# SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER
+# CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY,
+# OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE
+# OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
+#++
+
+require 'json'
+require 'open-uri'
+require 'timeout'
+require 'uri'
+
+module CortexReaver; module Plugins
+
+  # Twitter plugin for Cortex Reaver.
+  module Twitter
+    Config = CortexReaver.config.plugins.twitter ||= Construct.new
+
+    # The twitter username to look for
+    Config.define :username, :default => 'aphyr_'
+
+    # Whether or not to include replies. If this is false, the most recent
+    # non-reply tweets will be displayed.
+    Config.define :include_replies, :default => false
+
+    # Time in seconds to cache results. It's a good idea to keep this nice
+    # and high both to improve the performance of your site and to avoid
+    # pounding on Twitter's servers. Default is 600 seconds (10 minutes).
+    Config.define :cache_ttl, :default => 600
+
+    # Request timeout in seconds.
+    Config.define :request_timeout, :default => 3
+
+    # If Twitter fails to respond at least this many times in a row, no new
+    # requests will be sent until the failure_timeout expires in order to
+    # avoid hindering your blog's performance.
+    Config.define :failure_threshold, :default => 3
+
+    # After the failure_threshold is reached, the plugin will wait this many
+    # seconds before trying again. Default is 600 seconds (10 minutes).
+    Config.define :failure_timeout, :default => 600
+
+    class << self
+
+      # Parses tweet text and converts it into HTML. Explicit URLs and @username
+      # or #hashtag references will be turned into links.
+      def parse_tweet(tweet)
+        index     = 0
+        html      = tweet.dup
+        protocols = ['ftp', 'ftps', 'git', 'http', 'https', 'mailto', 'scp',
+                     'sftp', 'ssh', 'telnet']
+        urls      = []
+
+        # Extract URLs and replace them with placeholders for later.
+        URI.extract(html.dup, protocols) do |url|
+          html.sub!(url, "__URL#{index}__")
+          urls << url
+          index += 1
+        end
+
+        # Replace URL placeholders with links.
+        urls.each_with_index do |url, index|
+          html.sub!("__URL#{index}__", "<a href=\"#{url}\">" <<
+              "#{url.length > 26 ? url[0..26] + '...' : url}</a>")
+        end
+
+        # Turn @username into a link to the specified user's Twitter profile.
+        html.gsub!(/@([a-zA-Z0-9_]{1,16})([^a-zA-Z0-9_])?/,
+            '@<a href="http://twitter.com/\1">\1</a>\2')
+
+        # Turn #hashtags into links.
+        html.gsub!(/#([a-zA-Z0-9_]{1,32})([^a-zA-Z0-9_])?/,
+            '<a href="http://search.twitter.com/search?q=%23\1">#\1</a>\2')
+
+        return html
+      end
+
+      # Gets a Hash containing recent tweets for the specified _user_. The only
+      # valid option currently is <code>:count</code>, which specifies the
+      # maximum number of tweets that should be returned.
+      def recent_tweets(user = Config.username, options = {:count => 1})
+        if @skip_until
+          return [] if @skip_until > Time.now
+          @skip_until = nil
+        end
+
+        cache   = Ramaze::Cache.plugin
+        options = {:count => 5}.merge(options)
+        count   = options[:count].to_i
+
+        count += 10 unless Config.include_replies
+        count = 200 if count > 200
+
+        url = "http://twitter.com/statuses/user_timeline/#{user}.json?count=" <<
+            count.to_s
+
+        if value = cache[url]
+          return value
+        end
+
+        tweets = []
+
+        Timeout.timeout(Config.request_timeout, StandardError) do
+          failed = 0
+          begin
+            tweets = JSON.parse(open(url).read)
+          rescue JSON::ParserError => e
+            # Twitter likes to hand out weird HTML responses sometimes. :/
+            failed += 1
+            retry unless failed > 3
+
+            # Admit defeat
+            raise RuntimeError.new("Failed to parse Twitter response 4 times: #{e}")
+          end
+        end
+
+        # Weed out replies if necessary.
+        unless Config.include_replies
+          tweets.delete_if do |tweet|
+            !tweet['in_reply_to_status_id'].nil? ||
+                !tweet['in_reply_to_user_id'].nil?
+          end
+
+          tweets = tweets.slice(0, options[:count].to_i)
+        end
+
+        # Parse the tweets into an easier-to-use format.
+        tweets.map! do |tweet|
+          {
+            :created_at => Time.parse(tweet['created_at']),
+            :html       => parse_tweet(tweet['text']),
+            :id         => tweet['id'],
+            :source     => tweet['source'],
+            :text       => tweet['text'],
+            :truncated  => tweet['truncated'],
+            :url        => "http://twitter.com/#{user}/statuses/#{tweet['id']}"
+          }
+        end
+
+        @failures = 0
+
+        return cache.store(url, tweets, :ttl => Config.cache_ttl)
+
+      rescue => e
+        Ramaze::Log.error "CortexReaver::Plugins::Twitter: #{e.message}"
+
+        @failures ||= 0
+        @failures += 1
+
+        if @failures >= Config.failure_threshold
+          @skip_until = Time.now + Config.failure_timeout
+          Ramaze::Log.error "CortexReaver::Plugins::Twitter: Twitter failed to respond #{@failures} times. Will retry after #{@skip_until}."
+        end
+
+        return []
+      end
+
+    end
+
+  end
+end; end