aerial 0.0.0

data/.gitignore

@@ -0,0 +1 @@
+lib/spec/repo

data/MIT-LICENSE

@@ -0,0 +1,22 @@
+Copyright (c) 2009, Matt Sears, Littlelines, LLC.
+
+Permission is hereby granted, free of charge, to any person
+obtaining a copy of this software and associated documentation
+files (the "Software"), to deal in the Software without
+restriction, including without limitation the rights to use,
+copy, modify, merge, publish, distribute, sublicense, and/or sell
+copies of the Software, and to permit persons to whom the
+Software is furnished to do so, subject to the following
+conditions:
+
+The above copyright notice and this permission notice shall be
+included in all copies or substantial portions of the Software.
+
+THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND,
+EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES
+OF MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND
+NONINFRINGEMENT. IN NO EVENT SHALL THE AUTHORS OR COPYRIGHT
+HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER LIABILITY,
+WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING
+FROM, OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR
+OTHER DEALINGS IN THE SOFTWARE.

data/README.md

@@ -0,0 +1,74 @@
+Aerial
+====
+
+Aerial is a simple, blogish, semi-static web application written in Sinatra.
+Designed for developers, there is no admin interface and no SQL database.
+Articles are written in your favorite text editor and versioned with Git.
+Comments are also stored as plain-text files and pushed to the remote
+repository when created. It uses Grit (http://github.com/mojombo/grit) to
+interface with local and remote Git repositories.
+
+Aerial was designed for small personal blogs and simple semi-static websites
+such as marketing sites. The main goals are to provide a no-fuss alternative
+with a basic set features.
+
+Aerial is still in active development.
+
+## Features #################################################################
+
+* Akismet spam filtering (see vendor/akismetor.rb)
+* Page caching (see vendor/cache.rb)
+* Support for Markdown
+* Vlad deployment tasks
+* YAML configuration
+* 100% code coverage
+
+## Requirements #############################################################
+
+* sinatra (for awesomeness)
+* git (http://git-scm.com)
+* grit (interface to git)
+* yaml (for configuration)
+* rdiscount (markdown-to-html)
+* Haml (can easily be switch to erb, or whatever)
+* jQuery (http://jquery.com)
+
+## Source ###################################################################
+
+Grit's Git repo is available on GitHub, which can be browsed at:
+
+    http://github.com/mattsears/aerial
+
+and cloned with:
+
+    git clone git://github.com/mattsears/aerial.git
+
+## Getting Started ###########################################################
+
+Install the following Rubygems:
+
+    sudo gem install sinatra rack thin rdiscount grit haml
+
+Add your custom settings to the configuration file:
+
+    config/config.yml
+
+Run the bootstrap Rake task to get started with a sample article
+
+    rake bootstrap
+
+Now open your browser to:
+
+    http://localhost:4567
+
+## Todo  #####################################################################
+
+* Enable/disable comments for an article.
+* Limit the number of comments for an article.
+* Improve bootstrap tasks
+* Add more details to this README
+
+## License ###################################################################
+
+Aerial is Copyright © 2009 Matt Sears, Littlelines. It is free software,
+and may be redistributed under the terms specified in the MIT-LICENSE file.

data/Rakefile

@@ -0,0 +1,96 @@
+# $:.unshift(File.dirname(__FILE__) + '/../../../lib')
+
+require 'rubygems'
+require 'spec/version'
+require 'spec/rake/spectask'
+require 'cucumber/rake/task'
+
+AERIAL_ROOT = "."
+require File.join(AERIAL_ROOT, 'lib', 'aerial')
+
+# Rspec setup
+desc "Run all specs"
+Spec::Rake::SpecTask.new do |t|
+  t.spec_files = FileList['lib/spec/**/*_spec.rb']
+end
+
+namespace :spec do
+  desc "Run all specs with rcov"
+  Spec::Rake::SpecTask.new('rcov') do |t|
+    t.spec_files = FileList['lib/spec/**/*_spec.rb']
+    t.rcov = true
+    t.rcov_dir = 'coverage'
+    t.rcov_opts = ['--exclude',
+                   "lib/spec.rb,spec\/spec,bin\/spec,examples,\.autotest,#{ENV['GEM_HOME']}"]
+  end
+end
+
+desc "Setup the directory structure"
+task :bootstrap do
+  Rake::Task['setup:articles_directory'].invoke
+  Rake::Task['setup:views_directory'].invoke
+  Rake::Task['setup:public_directory'].invoke
+  Rake::Task['run'].invoke
+end
+
+desc 'Run Aerial in development mode'
+task :run do
+  exec "ruby lib/aerial.rb"
+end
+
+namespace :setup do
+
+  desc "Copy over a sample article"
+  task :articles_directory do
+    puts "* Creating article directory in " + Aerial.config.views.dir
+    article_dir = File.join(AERIAL_ROOT, 'lib','spec','fixtures',
+                            'articles', 'sample-article')
+    FileUtils.mkdir_p( Aerial.config.articles.dir )
+    FileUtils.cp_r(article_dir, Aerial.config.articles.dir )
+    Aerial::Git.commit(Aerial.config.articles.dir, "Initial import of first article")
+  end
+
+  task :public_directory do
+    puts "* Creating public directory in " + Aerial.config.public.dir
+    FileUtils.cp_r(File.join(AERIAL_ROOT, 'lib', 'spec',
+                             'fixtures', 'public'),
+                   Aerial.config.public.dir )
+  end
+
+  task :views_directory do
+    puts "* Creating views directory in " + Aerial.config.views.dir
+    FileUtils.cp_r(File.join(AERIAL_ROOT, 'lib', 'spec',
+                             'fixtures',  'views'),
+                   Aerial.config.views.dir )
+  end
+end
+
+# Cucumber setup
+Cucumber::Rake::Task.new(:features) do |t|
+  t.cucumber_opts = "--format pretty"
+end
+
+# Vlad setup
+begin
+  require "vlad"
+  Vlad.load(:app => nil, :scm => "git")
+rescue LoadError
+  # do nothing
+end
+
+
+begin
+  require 'jeweler'
+  Jeweler::Tasks.new do |gemspec|
+    gemspec.name = "aerial"
+    gemspec.summary = "A simple, blogish software build with Sinatra, jQuery, and uses Git for data storage  "
+    gemspec.description = "A simple, blogish software build with Sinatra, jQuery, and uses Git for data storage  "
+    gemspec.email = "matt@mattsears.com"
+    gemspec.homepage = "http://github.com/mattsears/aerial"
+    gemspec.description = "A simple, blogish software build with Sinatra, jQuery, and uses Git for data storage"
+    gemspec.authors = ["Matt Sears"]
+  end
+  Jeweler::GemcutterTasks.new
+rescue LoadError
+  puts "Jeweler not available. Install it with: sudo gem install technicalpickles-jeweler -s http://gems.github.com"
+end

data/VERSION

@@ -0,0 +1 @@
+0.0.0

data/config/config.yml

@@ -0,0 +1,19 @@
+title: ""
+subtitle: ""
+name:  ""
+author: ""
+email:  ""
+
+articles:
+  dir: "app/articles"
+
+public:
+  dir: "public"
+
+views:
+  dir: "app/views"
+  default: "home"
+
+akismet:
+  key: ""
+  url: ""

data/config/deploy.rb

@@ -0,0 +1,50 @@
+# =============================================================================
+# VLAD VARIABLES
+# =============================================================================
+
+set :application, ""
+set :repository,  ""
+set :deploy_to, ""
+set :user, ""
+set :domain, ""
+set :app_command, "/etc/init.d/apache2"
+
+desc 'Deploy the app!'
+task :deploy do
+  Rake::Task["vlad:update"].invoke
+  Rake::Task["vlad:setup_repo"].invoke
+  Rake::Task["vlad:update_config"].invoke
+end
+
+desc 'Sync local and production code'
+remote_task :remote_pull do
+  run "cd #{current_release}; #{git_cmd} pull origin master"
+end
+
+namespace :vlad do
+
+  desc 'Restart Passenger'
+  remote_task :start_app do
+    run "touch #{current_release}/tmp/restart.txt"
+  end
+
+  desc 'Restarts the apache servers'
+  remote_task :start_web do
+    run "sudo #{app_command} restart"
+  end
+
+  desc 'Copy the git repo over'
+  remote_task :setup_repo do
+    run "cp -fR #{scm_path}/repo/.git #{current_release}/. "
+    run "cd #{current_release}; #{git_cmd} checkout master"
+  end
+
+  desc 'Upload the configuration script'
+  remote_task :update_config do
+    run "mkdir #{current_release}/config" rescue nil
+    rsync "config/config.yml", "#{current_release}/config/config.yml"
+  end
+
+end
+
+

data/lib/aerial.rb

@@ -0,0 +1,100 @@
+libdir = File.dirname(__FILE__)
+$LOAD_PATH.unshift(libdir) unless $LOAD_PATH.include?(libdir)
+AERIAL_ROOT = File.join(File.dirname(__FILE__), '..') unless defined? AERIAL_ROOT
+
+# System requirements
+require 'rubygems'
+require 'grit'
+require 'yaml'
+require 'sinatra'
+require 'rdiscount'
+require 'aerial/base'
+
+before do
+  # kill trailing slashes for all requests except '/'
+  request.env['PATH_INFO'].gsub!(/\/$/, '') if request.env['PATH_INFO'] != '/'
+end
+
+# Configuration
+configure do
+  set :views  => Aerial.config.theme_directory
+  set :public => Aerial.config.public.dir
+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,
+    :user_ip     => request.ip
+  }))
+
+  @article.comments << comment.save(@article.archive_name)
+  cache_expire( @article.permalink )
+  status 204
+end

data/lib/aerial/article.rb

@@ -0,0 +1,241 @@
+module Aerial
+
+  class Article < Content
+
+    attr_reader :comments, :id,         :tags,      :archive_name, :body_html,
+                :meta,     :updated_on, :published, :file_name
+
+    # =============================================================================================
+    # PUBLIC CLASS METHODS
+    # =============================================================================================
+
+    # Find all articles, including drafts
+    def self.all(options={})
+      self.find_all
+    end
+
+    # A quick way to load an article
+    #   +id+ of the blob
+    def self.open(id, options = {})
+      self.find_by_blob_id(id, options)
+    end
+
+    # Find a single article
+    #   +id+ of the blob
+    def self.find(id, options={})
+      self.find_by_id(id, options)
+    end
+
+    # Find a single article
+    #   +name+ of the article file
+    def self.with_name(name, options={})
+      self.find_by_name(name, options)
+    end
+
+    # Find articles by tag
+    #   +tag+ category
+    def self.with_tag(tag, options={})
+      self.find_by_tag(tag, options)
+    end
+
+    # Find articles by month and year
+    #   +year+ of when article was published
+    #   + month+ of when the article was published
+    def self.with_date(year, month, options={})
+      self.find_by_date(year, month, options)
+    end
+
+    # Return an article given its permalink value
+    #   +link+ full path of the link
+    def self.with_permalink(link, options={})
+      self.find_by_permalink(link, options)
+    end
+
+    # Find the most recent articles
+    def self.recent(options={})
+      limit = options.delete(:limit) || 4
+      self.find_all(options).first(limit)
+    end
+
+    # Return true if the article file exists
+    def self.exists?(id)
+      self.find_by_name(id) ? true : false
+    end
+
+    # Return all the tags assigned to the articles
+    def self.tags
+      self.find_tags
+    end
+
+    # Calculate the ar
+    def self.archives
+      self.find_archives
+    end
+
+    # =============================================================================================
+    # PUBLIC INSTANCE METHODS
+    # =============================================================================================
+
+    # 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?
+    end
+
+    # Permanent link for the article
+    def permalink
+      link = self.file_name.gsub('.article', '')
+      "/#{published_at.year}/#{published_at.month}/#{published_at.day}/#{escape(link)}"
+    end
+
+    # Returns the absolute path of the Article's file
+    def expand_path
+      return "#{self.archive_expand_path}/#{self.file_name}"
+    end
+
+    # Returns the full path of the article's archive
+    def archive_expand_path
+      return unless archive = self.archive_name
+      return "#{Aerial.repo.working_dir}/#{Aerial.config.articles.dir}/#{archive}"
+    end
+
+    private
+
+    # =============================================================================================
+    # PRIVATE CLASS METHODS
+    # =============================================================================================
+
+    # Find a single article given the article name
+    #   +name+ file name
+    def self.find_by_name(name, options={})
+      if tree = Aerial.repo.tree/"#{Aerial.config.articles.dir}/#{name}"
+        return self.find_article(tree)
+      end
+    end
+
+    # Find the single article given the id
+    #   +id+ the blob id
+    #   +options+
+    def self.find_by_id(article_id, options = {})
+      if blog = Aerial.repo.tree/"#{Aerial.config.articles.dir}"
+        blog.contents.each do |entry|
+          article = self.find_article(entry, options)
+          return article if article.id == article_id
+        end
+      end
+      raise "Article not found"
+    end
+
+    # Find the article given the blob id.
+    # This is a more efficient way of find and 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 = {})
+      blob = Aerial.repo.blob(id)
+      if blob.size > 0
+        attributes = self.extract_article(blob, options)
+        return Article.new(attributes) if attributes
+      end
+      raise "Article doesn't exists"
+    end
+
+    # Returns the articles with the given tag
+    #   +tag+ the article category
+    def self.find_by_tag(tag, options = {})
+      articles = []
+      self.find_all.each do |article|
+        if article.tags.include?(tag)
+          articles << article
+        end
+      end
+      return articles
+    end
+
+    # Find a single article given the article's permalink value
+    def self.find_by_permalink(link, options={})
+      if blog = Aerial.repo.tree/"#{Aerial.config.articles.dir}/"
+        blog.contents.each do |entry|
+          article = self.find_article(entry, options)
+          return article if article.permalink == link
+        end
+      end
+      return false
+    end
+
+    # Find all the articles with the given month and date
+    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
+          articles << article
+        end
+      end
+      return articles
+    end
+
+    # Find all the articles in the reposiotory
+    def self.find_all(options={})
+      articles = []
+      if blog = Aerial.repo.tree/"#{Aerial.config.articles.dir}/"
+        blog.contents.first( options[:limit] || 100 ).each do |entry|
+          article = self.find_article(entry, options)
+          articles << self.find_article(entry, options) if article
+        end
+      end
+      return articles.sort_by { |article| article.published_at}.reverse
+    end
+
+    # Look in the given tree, find the article
+    #   +tree+ repository tree
+    #   +options+ :blob_id
+    def self.find_article(tree, options = {})
+      comments = []
+      attributes = nil
+      tree.contents.each do |archive|
+        if archive.name =~ /article/
+          attributes = self.extract_article(archive, options)
+          attributes[:archive_name] = tree.name
+          attributes[:file_name] = archive.name
+        elsif archive.name =~ /comment/
+          comments << Comment.open(archive.data, :file_name => archive.name)
+        end
+      end
+      return Article.new(attributes.merge(:comments => comments)) if attributes
+    end
+
+    # Find all the tags assign to the articles
+    def self.find_tags
+      tags = []
+      self.all.each do |article|
+        tags.concat(article.tags)
+      end
+      return tags.uniq
+    end
+
+    # Create a histogram of article archives
+    def self.find_archives
+      dates = []
+      self.all.each do |article|
+        date = article.published_at
+        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
+    def self.extract_article(blob, options={})
+      file                   = blob.data
+      article                = Hash.new
+      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
+      return article
+    end
+
+  end
+end