aerial 0.0.0 → 0.1.0

data/lib/aerial/app.rb

@@ -0,0 +1,93 @@
+module Aerial
+  class App < Sinatra::Default
+    include Aerial
+
+    before do
+      # kill trailing slashes for all requests except '/'
+      request.env['PATH_INFO'].gsub!(/\/$/, '') if request.env['PATH_INFO'] != '/'
+    end
+
+    # Helpers
+    helpers do
+      include Rack::Utils
+      include Sinatra::Cache::Helpers
+      include Aerial::Helper
+      alias_method :h, :escape_html
+    end
+
+    # Homepage
+    get '/' do
+      @articles = Aerial::Article.recent(:limit => 10)
+      cache haml(Aerial.config.views.default.to_sym)
+    end
+
+    # Articles
+    get '/articles' do
+      @content_for_sidebar = partial(:sidebar)
+      @articles = Aerial::Article.recent(:limit => 10)
+      cache haml(:articles)
+    end
+
+    get '/feed*' do
+      content_type 'text/xml', :charset => 'utf-8'
+      @articles = Aerial::Article.all
+      cache haml(:rss, :layout => false)
+    end
+
+    # Sassy!
+    get '/style.css' do
+      content_type 'text/css', :charset => 'utf-8'
+      cache sass(:style)
+    end
+
+    # Single page
+    get '/:page' do
+      cache haml(params[:page])
+    end
+
+    # Single article page
+    get '/:year/:month/:day/:article' do
+      link = [params[:year], params[:month], params[:day], params[:article]].join("/")
+      @content_for_sidebar = partial(:sidebar)
+      @article = Aerial::Article.with_permalink("/#{link}")
+      throw :halt, [404, not_found ] unless @article
+      @page_title = @article.title
+      cache haml(:post)
+    end
+
+    # Article tags
+    get '/tags/:tag' do
+      @content_for_sidebar = partial(:sidebar)
+      @articles = Aerial::Article.with_tag(params[:tag])
+      cache haml(:articles)
+    end
+
+    # Article archives
+    get '/archives/:year/:month' do
+      @content_for_sidebar = partial(:sidebar)
+      @articles = Aerial::Article.with_date(params[:year], params[:month])
+      cache haml(:articles)
+    end
+
+    # Add comment
+    post '/article/:id/comments' do
+      @article = Aerial::Article.find(params[:id])
+      throw :halt, [404, not_found ] unless @article
+
+      comment = Aerial::Comment.new(params.merge!({:referrer    => request.referrer,
+                                                   :user_agent  => request.user_agent,
+                                                   :ip          => request.ip
+                                                   }))
+
+      @article.comments << comment.save(@article.archive_name)
+      cache_expire( @article.permalink )
+      status 204
+    end
+
+    not_found do
+      @content_for_sidebar = partial(:sidebar)
+      cache haml(:not_found)
+    end
+
+  end
+end

data/lib/aerial/article.rb

@@ -3,7 +3,7 @@ module Aerial
   class Article < Content
 
     attr_reader :comments, :id,         :tags,      :archive_name, :body_html,
-                :meta,     :updated_on, :published, :file_name
+                :meta,     :updated_on, :publish_date, :file_name
 
     # =============================================================================================
     # PUBLIC CLASS METHODS
@@ -14,19 +14,19 @@ module Aerial
       self.find_all
     end
 
-    # A quick way to load an article
+    # A quick way to load an article by blob id
     #   +id+ of the blob
     def self.open(id, options = {})
       self.find_by_blob_id(id, options)
     end
 
-    # Find a single article
+    # Find a single article by id
     #   +id+ of the blob
     def self.find(id, options={})
       self.find_by_id(id, options)
     end
 
-    # Find a single article
+    # Find a single article by name
     #   +name+ of the article file
     def self.with_name(name, options={})
       self.find_by_name(name, options)
@@ -58,6 +58,7 @@ module Aerial
     end
 
     # Return true if the article file exists
+    # +id+
     def self.exists?(id)
       self.find_by_name(id) ? true : false
     end
@@ -67,7 +68,7 @@ module Aerial
       self.find_tags
     end
 
-    # Calculate the ar
+    # Calculate the archives
     def self.archives
       self.find_archives
     end
@@ -79,21 +80,21 @@ module Aerial
     # Add a comment to the list of this Article's comments
     #  +comment new comment
     def add_comment(comment)
-      self.comments << comment.save(self.archive_name) # should we overload the << method?
+      self.comments << comment.save(self.archive_name) # TODO: should we overload the << method?
     end
 
-    # Permanent link for the article
+    # Make a permanent link for the article
     def permalink
-      link = self.file_name.gsub('.article', '')
-      "/#{published_at.year}/#{published_at.month}/#{published_at.day}/#{escape(link)}"
+      link = self.file_name.gsub(/\.article$|\.markdown$|\.md$|\.mdown$|\.mkd$|\.mkdn$/, '')
+      "/#{publish_date.year}/#{publish_date.month}/#{publish_date.day}/#{escape(link)}"
     end
 
-    # Returns the absolute path of the Article's file
+    # Returns the absolute path to the article file
     def expand_path
       return "#{self.archive_expand_path}/#{self.file_name}"
     end
 
-    # Returns the full path of the article's archive
+    # Returns the full path to the article archive (directory)
     def archive_expand_path
       return unless archive = self.archive_name
       return "#{Aerial.repo.working_dir}/#{Aerial.config.articles.dir}/#{archive}"
@@ -113,7 +114,7 @@ module Aerial
       end
     end
 
-    # Find the single article given the id
+    # Find a single article by id
     #   +id+ the blob id
     #   +options+
     def self.find_by_id(article_id, options = {})
@@ -126,8 +127,8 @@ module Aerial
       raise "Article not found"
     end
 
-    # Find the article given the blob id.
-    # This is a more efficient way of find and Article
+    # Find an article by blob id
+    # This is a more efficient way of finding an article
     # However, we won't know anything else about the article such as the filename, tree, etc
     #   +id+ of the blob
     def self.find_by_blob_id(id, options = {})
@@ -139,7 +140,7 @@ module Aerial
       raise "Article doesn't exists"
     end
 
-    # Returns the articles with the given tag
+    # Returns all articles by tag
     #   +tag+ the article category
     def self.find_by_tag(tag, options = {})
       articles = []
@@ -151,7 +152,8 @@ module Aerial
       return articles
     end
 
-    # Find a single article given the article's permalink value
+    # Find a single article by permalink
+    #   +link+
     def self.find_by_permalink(link, options={})
       if blog = Aerial.repo.tree/"#{Aerial.config.articles.dir}/"
         blog.contents.each do |entry|
@@ -162,19 +164,19 @@ module Aerial
       return false
     end
 
-    # Find all the articles with the given month and date
+    # Find all the articles by year and month
     def self.find_by_date(year, month, options ={})
       articles = []
       self.find_all.each do |article|
-        if article.published_at.year == year.to_i &&
-            article.published_at.month == month.to_i
+        if article.publish_date.year == year.to_i &&
+            article.publish_date.month == month.to_i
           articles << article
         end
       end
       return articles
     end
 
-    # Find all the articles in the reposiotory
+    # Find all the articles in the repository
     def self.find_all(options={})
       articles = []
       if blog = Aerial.repo.tree/"#{Aerial.config.articles.dir}/"
@@ -183,7 +185,7 @@ module Aerial
           articles << self.find_article(entry, options) if article
         end
       end
-      return articles.sort_by { |article| article.published_at}.reverse
+      return articles.sort_by { |article| article.publish_date}.reverse
     end
 
     # Look in the given tree, find the article
@@ -217,23 +219,19 @@ module Aerial
     def self.find_archives
       dates = []
       self.all.each do |article|
-        date = article.published_at
+        date = article.publish_date
         dates << [date.strftime("%Y/%m"), date.strftime("%B %Y")]
       end
       return dates.inject(Hash.new(0)) { |h,x| h[x] += 1; h }
     end
 
     # Extract the Article attributes from the file
+    #   +blob+
     def self.extract_article(blob, options={})
-      file                   = blob.data
-      article                = Hash.new
+      article                = self.extract_attributes(blob.data)
       article[:id]           = blob.id
-      article[:author]       = self.extract_header("author", file)
-      article[:title]        = self.extract_header("title", file)
-      article[:tags]         = self.extract_header("tags", file).split(/, /)
-      article[:published_at] = DateTime.parse(self.extract_header("published", file))
-      article[:body]         = self.scan_for_field(file, self.body_field)
-      article[:body_html]    = RDiscount::new( article[:body] ).to_html
+      article[:tags]         = article[:tags].split(/, /)
+      article[:body_html]    = RDiscount::new(article[:body]).to_html
       return article
     end
 

data/lib/aerial/base.rb

@@ -1,51 +1,43 @@
-CONFIG = YAML.load_file( File.join(AERIAL_ROOT, 'config', 'config.yml') ) unless defined?(CONFIG)
-
-require 'aerial/content'
-require 'aerial/article'
-require 'aerial/comment'
-require 'aerial/vendor/cache'
-require 'aerial/vendor/akismetor'
-require 'aerial/config'
-
 module Aerial
 
-  VERSION = '0.1.0'
-
-  class << self
-    attr_accessor :debug, :logger, :repo, :config
-
-    def log(str)
-      logger.debug { str } if debug
-    end
-  end
-
-  # Make sure git is added to the env path
-  ENV['PATH'] = "#{ENV['PATH']}:/usr/local/bin"
-  @logger ||= ::Logger.new(STDOUT)
-  @config ||= Aerial::Config.new(CONFIG)
-  @repo   ||= Grit::Repo.new(File.join(AERIAL_ROOT, '.'))
-  @debug  ||= false
-
   module Helper
 
-    # Defines the url for our application
-    def hostname
+    # Returns the current url
+    def url() request.url end
+
+    # Returns the request host
+    # TODO: just use request.host (http://rack.lighthouseapp.com/projects/22435/tickets/77-requesthost-should-answer-the-forwarded-host)
+    def host
       if request.env['HTTP_X_FORWARDED_SERVER'] =~ /[a-z]*/
         request.env['HTTP_X_FORWARDED_SERVER']
       else
-        request.env['HTTP_HOST']
+        request.host
       end
     end
 
-    # Returns the
+    # Returns the path
     def path
       base = "#{request.env['REQUEST_URI']}".scan(/\w+/).first
       return base.blank? ? "index" : base
     end
 
-    # Creates a complete link including the hostname
+    # Returns the absolute base url
+    def base_url
+      scheme = request.scheme
+      port = request.port
+      url = "#{scheme}://#{host}"
+      if scheme == "http" && port != 80 || scheme == "https" && port != 443
+        url << ":#{port}"
+      end
+      url << request.script_name
+    end
+
+    # Creates an absolute link
+    #  +link+ link to append to the baseurl
+    #  TODO: should we add more value to this? it seems like we might as well
+    #    just take care of this by appending the link to base_url in the app
     def full_hostname(link = "")
-      "http://#{hostname}#{link}"
+      "#{base_url}#{link}"
     end
 
     # Display the page titles in proper format

data/lib/aerial/comment.rb

@@ -4,8 +4,8 @@ module Aerial
   class Comment < Content
 
     attr_reader   :id,           :permalink, :article,      :spam,       :file_path
-    attr_accessor :archive_name, :spam,      :published_at, :name,       :referrer,
-                  :email,        :homepage,  :user_ip,      :user_agent, :file_name
+    attr_accessor :archive_name, :spam,      :publish_date, :name,       :referrer,
+                  :email,        :homepage,  :ip,           :user_agent, :file_name
 
     def initialize(atts = {})
       super
@@ -81,12 +81,12 @@ module Aerial
     def to_s
       me = ""
       me << "Author: #{self.author} \n" if self.author
-      me << "Published: #{self.published_at} \n" if self.published_at.to_s
+      me << "Publish Date: #{self.publish_date} \n" if self.publish_date.to_s
       me << "Email: #{self.email} \n" if self.email
       me << "Homepage: #{self.homepage} \n" if self.homepage
-      me << "User IP: #{self.user_ip} \n" if self.user_ip
+      me << "User IP: #{self.ip} \n" if self.ip
       me << "User Agent: #{self.user_agent} \n" if self.user_agent
-      me << "Spam?: #{self.spam} \n" if self.user_agent
+      me << "Spam?: #{self.spam} \n" if self.spam
       me << "\n#{self.body}" if self.body
       return me
     end
@@ -100,17 +100,8 @@ module Aerial
     # Create a new Comment instance with data from the given file
     def self.extract_comment_from(data, options = {})
       comment_file          = data.to_s
-      comment               = options
-      comment[:id]          = self.extract_header("id", comment_file)
-      comment[:user_ip]     = self.extract_header("ip", comment_file)
-      comment[:user_agent]  = self.extract_header("user-agent", comment_file)
-      comment[:referrer]    = self.extract_header("referrer", comment_file)
-      comment[:permalink]   = self.extract_header("permalink", comment_file)
-      comment[:author]      = self.extract_header("author", comment_file)
-      comment[:email]       = self.extract_header("email", comment_file)
-      comment[:homepage]    = self.extract_header("homepage", comment_file)
-      comment[:published_at]= DateTime.parse(self.extract_header("published", comment_file))
-      comment[:body]        = self.scan_for_field(comment_file, self.body_field)
+      comment               = self.extract_attributes(comment_file)
+      comment.merge!(options)
       return comment
     end
 
@@ -118,7 +109,7 @@ module Aerial
     def self.save_new(comment)
       return false unless comment && comment.archive_name
       comment.generate_name!
-      comment.published_at = DateTime.now
+      comment.publish_date = DateTime.now
       path = File.join(Aerial.config.articles.dir, comment.archive_name, comment.name)
       Dir.chdir(Aerial.repo.working_dir) do
         File.open(path, 'w') do |file|
@@ -136,7 +127,7 @@ module Aerial
     # Make sure the url is cleaned
     def sanitize_url
       return unless self.homepage
-      homepage.gsub!(/^(.*)/, 'http://\1') unless homepage =~ %r{^http://} or homepage.empty?
+      homepage.gsub!(/^(.*)/, 'http://\1') unless homepage =~ %r{^(http://|https://)} or homepage.empty?
     end
 
     # Try to prevent spam with akismet
@@ -144,7 +135,7 @@ module Aerial
       {
         :key                  => Aerial.config.akismet.key,
         :blog                 => Aerial.config.akismet.url,
-        :user_ip              => self.user_ip,
+        :user_ip              => self.ip,
         :user_agent           => self.user_agent,
         :referrer             => self.referrer,
         :permalink            => self.permalink,

data/lib/aerial/content.rb

@@ -6,7 +6,7 @@ module Aerial
   # Base class for all the site's content
   class Content
 
-    attr_reader :id, :author, :title, :body, :published_at, :archive_name, :file_name
+    attr_reader :id, :author, :title, :body, :publish_date, :archive_name, :file_name
 
     def initialize(atts = {})
       atts.each_pair { |key, value| instance_variable_set("@#{key}", value) if self.respond_to? key}
@@ -18,26 +18,17 @@ module Aerial
     # PROTECTED CLASS METHODS
     # =============================================================================================
 
-    # With the comment string, attempt to find the given field
-    #   +field+ the label before the ":"
-    #   +comment+ is the contents of the comment
-    def self.extract_header(field, content)
-      return self.scan_for_field(content, self.header_field_for(field))
-    end
-
-    # Returns the string that matches the given pattern
-    def self.scan_for_field(contents, pattern)
-      content = contents.scan(pattern).first.to_s.strip
-    end
-
-    # Returns the regular expression pattern for the header fields
-    def self.header_field_for(header)
-      exp = Regexp.new('^'+header+'\s*:(.*)$', Regexp::IGNORECASE)
-    end
-
-    # Returns the regular expression pattern for the body field
-    def self.body_field
-      exp = Regexp.new('^\n(.*)$', Regexp::MULTILINE)
+    def self.extract_attributes(content, options={})
+      attributes                = Hash.new
+      header, body = content.split(/\n\n/, 2)
+      attributes[:body] = body.strip if body
+      header.each do |line|
+        field, data = line.split(/:/, 2)
+        field = field.downcase.strip.gsub(' ', '_').gsub('-', '_')
+        attributes[field.to_sym] = data.to_s.strip
+      end
+      attributes[:publish_date] = DateTime.parse(attributes[:publish_date]) if attributes[:publish_date]
+      return attributes
     end
 
     # Look for <code> blocks and convert it for syntax highlighting