cameroncox-git-blog 0.0.1

data/README

@@ -0,0 +1,105 @@
+git-blog
+========
+
+git-blog intends to be blogging, simplified. You'll write your posts in your
+favorite text editor, with your favorite markup. Then save the post's file,
+`git-add` the post, and then `git-push origin master`. git-blog, running on
+your server, will catch the push and parse the post to your static HTML blog.
+Fast, no dynamic code being run on every load, free post versioning (git
+revisions), free sections (git branches), freedom of mind.
+
+Philosophy & goals
+------------------
+
+git-blog will never be featureful, but it will also never be bloated. I doubt
+I will ever do anything more than parsing the posts to static HTML on every
+git-push.
+
+Preparing git-blog
+------------------
+
+To prepare a new git-blog, run this task from the cloned git-blog repository, replacing `~/Documents/Blog` (my personal favorite location) the name of the folder where you want your blog to exist locally:
+
+    rake create[~/Documents/Blog]
+
+After this is complete, move to that folder (something along the lines of `cd ~/Documents/Blog`), and then add any remote repositories to which you wish to push your blog. Most likely, this will include the server hosting your blog to the web. The simplest setup to push to this server is an SSH connection - if you have SSH access to your server/host, you can run this to set up git-blog for pushing:
+
+    git-remote add blog username@host.tld:/path/to/server/blog/folder
+
+This will prepare a remote named 'blog' to which you can push your changes. In addition, if you use [GitHub](http://github.com "GitHub - free Git repository hosting"), you can also push your blog there. Create a new repository on GitHub, and then use this to automatically set up that remote for you:
+
+    rake github[github_username,github_repo]
+
+Now, you'll want to set up the server to host git-blog - this is fairly simple, about equable to setting up git-blog locally. The only addition, after creating the blog's directory on the server the same as you did locally (`rake create[/path/to/server/blog/folder]`, from within the git-blog clone dir on your server), is preparing the post-receive hook. It's really simple - change directory to your new blog's folder on the server, and run this:
+
+    rake servable
+
+Using git-blog
+--------------
+
+Once your new blog is prepared, you'll want to write a post. Writing a new post is quite simple - run `rake post`, and it will open your favorite `$EDITOR` with a post prepared to edit.
+
+You're free to format your blog posts however you want - at the moment there are parsers set up for Markdown, Textile, and Haml - and support for plain text and plain X)HTML. The only restriction when formatting, is that your post's title is on the very first line, formatted plainly in whatever way your parser supports. This title will not appear in the final post, and will instead be sent to the post template.
+
+Once you've finished editing your post, save it, and close the window or exit the editor (whatever is appropriate for your editor of choice) - it will automatically add the new post to the index, and then commit it. You can repeat this process if you want to post more posts before pushing them to the server.
+
+Now just push your beautiful new post(s) to the server:
+
+    git-push blog
+
+I suggest you run `rake deploy` before comitting any new posts / changes to post - if you have a syntax error in one of your posts, the parser may not like it, and it's preferable to catch this before you commit the changes and push them to your blog.
+
+git-blog will automatically re-parse all of your posts, and create an index file for your blog, after you git-push to the server. They're going to end up as simple static HTML, so there's nearly no load on your server when a page is visited - this makes a git-blog inherently faster and cheaper to run than any dynamic blog (such as Wordpress or Expression Engine) could ever be.
+
+Customizing git-blog
+--------------------
+
+Your git-blog's design is all stored in the same repository as your posts - it consists of, simply, two Haml files that are rendered with the posts. One, `post.haml`, is the layout framework into which your posts' content will be pushed; and the other, `index.haml`, is the framework for the index page of your blog. Customizing the look and feel of your blog is as simple as modifying these two files to your liking, see the defaults for an example.
+
+The git-blog rakefile itself is meant to be very hackable, and if you want to add further functionality - a different parsing system for your favorite markup, or extensions to the existing parsers for your frequently-used markup, or new blog features such as comments, trackbacks, feeds, and so on... it's as simple as fiddling around with git-blog's core. Don't be afraid, it's meant to be broken! If you *do* end up adding something cool to git-blog, I would very much appreciate it if you told me, I'll gladly link to your github fork from this README for other users to see.
+
+Getting
+-------
+
+The authoritative source for this project is available at
+<http://github.com/elliottcable/git-blog>. You can clone your own copy with the
+following command:
+
+    git clone git://github.com/elliottcable/git-blog.git
+
+If you want to make changes to the codebase, you need to fork your own github
+repository for said changes. Send a pullrequest to [elliottcable][5]
+when you've got something ready for the master that you think should be
+integrated into the root source.
+
+Bugs or feature requests can be submitted by forking a repository as
+previously described, and then using [ditz][6] to add an issue.
+
+  [5]: <http://github.com/elliottcable> (elliottcable on GitHub)
+  [6]: <http://ditz.rubyforge.org/> (Ditz issue tracking)
+
+Requirements
+------------
+
+To run git-blog, you need git (obviously) - on a Macintosh, you can install it using MacPorts as follows:
+
+    sudo port install git-core
+
+On a Linux or Windows machine, you're a bit more on your own, as I don't know how to install it on Windows, and I'm assuming a person using a Linux distrib is proficient enough to figure it out. In addition, you need the following gems:
+
+* `gem install git`
+* `gem install haml` (if you wish to create your templates or write your posts in haml)
+* `gem install RedCloth` (if you wish to write your posts in Textile)
+* One of the following Markdown libraries (if you wish to write your posts in Markdown)
+** `sudo gem install rdiscount`
+** `sudo gem install rpeg-markdown`
+** `sudo gem install maruku`
+** `sudo gem install BlueCloth`
+
+
+To develop and contribute to git-blog, you also need:
+
+* `gem install rspec`
+* `gem install rake`
+* `gem install rcov`
+* `gem install technomancy-ditz --source=http://gems.github.com`z

data/Rakefile

@@ -0,0 +1,31 @@
+require 'rubygems'
+require 'rake'
+require 'rake/gempackagetask'
+
+gem_spec = Gem::Specification.new do |s|
+  s.name = %q{git-blog}
+  s.version = "0.0.1"
+ 
+  s.specification_version = 2 if s.respond_to? :specification_version=
+ 
+  s.required_rubygems_version = Gem::Requirement.new(">= 0") if s.respond_to? :required_rubygems_version=
+  s.authors = ["Cameron Cox", "Elliot Cable"]
+  s.date = %q{2008-06-30}
+  s.description = %q{yet another git-blog}
+  s.email = %q{cameroncox@gmail.com}
+  s.executables = ["git-blog"]
+  s.extra_rdoc_files = ["README", "LICENSE"]
+  s.files = ["LICENSE", "README", "Rakefile", "bin/git-blog", "lib/git-blog.rb", "lib/git-blog/application.rb", "lib/git-blog/parser.rb", "lib/git-blog/parser.rb", "lib/git-blog/extlib.rb", "lib/git-blog/extlib/file.rb", "lib/git-blog/extlib/string.rb", "lib/git-blog/extlib/symbol.rb", "lib/git-blog/parser/haml.rb", "lib/git-blog/parser/textile.rb", "lib/git-blog/parser/markdown.rb", "lib/git-blog/parser/html.rb", "prepped/.gitignore", "prepped/design/index.html.haml", "prepped/design/post.html.haml", "prepped/design/style.sass", "prepped/post-receive.hook", "prepped/posts/welcome_to_your_git_blog.markdown", "prepped/posts/.gitignore"]
+  s.has_rdoc = false
+  s.homepage = %q{http://github.com/cameroncox/git-blog/}
+  s.require_paths = ["lib", "prepped"]
+  s.rubyforge_project = %q{git-blog}
+  s.rubygems_version = %q{1.1.1}
+  s.summary = %q{yet another git-blog}
+end
+
+Rake::GemPackageTask.new(gem_spec) do |p|
+  p.gem_spec = gem_spec
+  p.need_tar = true
+  p.need_zip = true
+end

data/bin/git-blog

@@ -0,0 +1,4 @@
+#!/usr/bin/env ruby
+$: << File.expand_path(File.join(File.dirname(__FILE__), "..", "lib"))
+require 'git-blog'
+GitBlog::Application.start 

data/lib/git-blog.rb

@@ -0,0 +1,24 @@
+%w( git-blog/extlib git-blog/application ).each { |dep| require dep }
+
+require 'git'
+require 'haml'
+require 'sass'
+
+module GitBlog
+  class << self
+    def title_regex
+      {
+        'xhtml'     => /^<[^>]+>(.*)<[^>]+>$/,
+        'haml'      => /^%[^\s\{]+(?:\{[^\}]\})? (.*)$/,
+        'textile'   => /^h\d(?:[^\s\{]|\{[^\}]*\})*\. (.*)$/,
+        'markdown'  => /^(.*)$/ # Also works for other
+      }      
+    end
+    
+    def root
+      File.expand_path( File.dirname(__FILE__) / '..'  )
+    end
+  end
+end
+
+require 'git-blog/parser'

data/lib/git-blog/application.rb

@@ -0,0 +1,251 @@
+%w( rubygems fileutils thor ).each { |dep| require dep }
+         
+include FileUtils
+
+module GitBlog
+  class Application < Thor                                   
+    def initialize(*args)
+      self.path = File.expand_path('.')
+      super(*args)
+    end
+
+    def path=(path)
+      @path = path
+    end
+     
+    def path
+      @path
+    end 
+        
+    def git_blog(path)
+      until (@blog = Git.open path rescue false)
+        Git.init path
+      end
+      
+      @blog
+    end
+    
+    desc "bootstrap [PATH]", "bootstrap the given directory"
+    def bootstrap(path = nil)        
+      self.path = path unless path.nil? 
+      blog = git_blog(self.path)
+      
+      cd path
+      mkdir 'posts'
+      mkdir 'design'
+      mkdir 'output'
+      
+      cp GitBlog.root / :prepped / '.gitignore', path
+      %w( welcome_to_your_git_blog.markdown .gitignore ).each do |file|
+        cp GitBlog.root / :prepped / :posts / file, 'posts'
+      end
+      
+      %w( index.html.haml post.html.haml style.sass ).each do |file|
+        cp GitBlog.root / :prepped / :design / file, 'design'
+      end
+
+      Dir['**/**'].each do |file|
+        if File.directory? file
+          chmod 0775, file
+        else
+          chmod 0664, file
+        end
+      end  
+      
+      chmod 0775, '.git'
+      chmod 0664, '.gitignore'
+      chmod 0664, :posts / '.gitignore'
+
+      blog.add
+      blog.commit_all 'A bird... a plan... no, a git-blog'   
+    end # bootstrap
+
+    desc "github [USERNAME] [REPO]", "attach the blog to a github repository, can also clone an existing git-blog repository"
+    def github(username, repo)     
+      github_url = "git@github.com:#{username.downcase}/#{repo.downcase}.git"
+  
+      if File.directory? File.join(self.path, 'posts') && 
+        (blog = git_blog(self.path))
+    
+        github = blog.add_remote 'github', github_url
+        blog.push github
+      else
+        system 'git-init'
+        system "git-remote add -f github #{github_url}"
+        system 'git checkout -b master github/master'
+      end
+    end # github
+
+    desc "post [OPT TITLE]", "create and open for editting a new post"
+    def post(title = nil)
+      @resume = false # don't resume and overwrite by default
+      temporary_post = :post_in_progress.markdown  
+
+      unless title.nil?
+        temporary_post = title.slugify.to_sym.markdown
+      end
+      
+      if File.file? temporary_post
+        puts '** You have an unfinished post from before, do you want to '
+        puts '(r)esume it, or overwrite it with a (n) one?'
+        case STDIN.gets 
+        when /r/i
+          @resume = true
+        when /n/i
+          # do nothing
+        else
+          raise 'Invalid choice, aborting'
+        end
+      end # if
+      
+      unless @resume
+        File.open( temporary_post, File::RDWR|File::TRUNC|File::CREAT, 0664 ) do |p|
+          p.puts  'Replace this text with your title!'
+          p.puts  '=================================='
+          p.print "\n"
+          p.close
+        end
+      end
+                                                 
+      if ENV['VISUAL']
+        system "#{ENV['VISUAL']} #{temporary_post}"
+      elsif File.file? '/usr/bin/mate'
+        system "/usr/bin/mate -w #{temporary_post}"
+      end
+      
+      first_line = File.open( temporary_post, File::RDONLY).gets.chomp
+      markup = case first_line
+        when /^\</        then 'xhtml'
+        when /^\%/        then 'haml'
+        when /^\#|h\d\./  then 'textile'
+        else                   'markdown'
+      end
+      
+      title = (first_line.match GitBlog.title_regex[markup])[1]
+      path  = :posts / title.slugify.send(markup.to_sym)
+      mv temporary_post, path
+
+      blog = Git.open File.expand_path('.')
+      blog.add path
+      blog.commit "New post: #{title}"
+      
+    end # post
+               
+    desc "clobber", "remove all generated xhtml files"
+    def clobber
+      Dir['output/**/*.xhtml'].each do |file|
+        rm_f file
+      end
+    end # clobber
+                 
+    desc "build", "build the index, and all posts, along with any sass files" 
+    def build
+      clobber
+      build_posts
+      build_index
+      
+      Dir[:design / '*.sass'].each do |sass|
+        template = IO.read sass
+        parsed = Sass::Engine.new(template).render
+        
+        destination = :output / sass.gsub(/design/, '').gsub(/.sass/, '.css')
+        File.open(destination, File::RDWR|File::TRUNC|File::CREAT, 0664) do |f|
+          f.puts parsed
+          f.close
+          
+          puts "~ #{sass} -> #{destination}"
+        end
+      end
+    end # build
+       
+    desc "push_changes [REMOTE]", "push changes to the remote"
+    def push_changes(remote_name = nil)
+      remote_name = remote.nil?? 'github' : remote_name
+      blog        = git_blog(self.path)
+      remote      = blog.remote remote_name
+      blog.push remote
+      puts "Changes pushed to #{remote_name}"
+    end # push_changes
+    
+    desc "make_servable", "prepare the blog to be served (configures hooks)"
+    def make_servable
+      mv '.git' / :hooks / 'post-receive', '.git' / :hooks / 'post-receive.old'
+      cp GitBlog.root / :prepped / 'post-receive.hook', '.git' / :hooks / 'post-receive'
+      chmod 0775, '.git' / :hooks / 'post-receive'
+      
+      puts "~ git-blog is prepared for serving (git post-receive hook prepared)"
+    end
+       
+    def force_checkout
+      puts 'Forcing update of working copy...'
+      system 'git-checkout -f master'
+    end # force_checkout 
+                                    
+    def post_receieve
+      force_checkout
+      build
+    end # post_receieve
+        
+    protected
+       
+      def build_posts
+        unless File.directory? 'output/archive'
+          mkdir 'output/archive'
+        end
+
+        Dir['posts/*.*'].each do |path|
+          markup  = File.extname(path).downcase.gsub(/^\./, '')
+          content = IO.read path
+          first_line = content.match(/^(.*)\n/)[1]
+
+          post_title = (first_line.match GitBlog.title_regex[markup])[1]
+          parsed = begin
+            require "git-blog" / "parser" / markup.downcase
+            parser = GitBlog::Parser.const_get(markup.gsub(/\b\w/){$&.upcase})
+            parser.send :parse, content
+          end
+
+          template = IO.read :design / 'post.html'.haml
+
+          completed = Haml::Engine.new(template, :filename => :design / 'post.html'.haml).
+            to_html(Object.new, { :content => parsed, :title => post_title })
+
+          completed = GitBlog::Parser.fix_pres(completed)
+
+          destination = :output / :archive / path.gsub(/posts/, '').gsub(/.#{markup}$/, '.xhtml')
+          File.open(destination, File::RDWR|File::TRUNC|File::CREAT, 0664) do |f|
+            f.puts completed
+            f.close
+          end      
+
+          puts "~ #{path} => #{destination} (as #{markup})"
+        end
+      end
+    
+      def build_index
+        blog = git_blog(self.path)
+        
+        entries = blog.log.select { |e| e.message =~ /New post: / }
+        posts   = []
+        entries.map do |entry|
+          title = entry.message.match(/New post: (.*)$/)[1]
+          posts << { :title => title, :slug => title.slugify }
+        end                                                   
+        
+        template = IO.read :design / 'index.html'.haml
+        
+        completed = Haml::Engine.new(template, :filename => :design / 'index.html'.haml).
+          to_html(Object.new, :posts => posts)
+          
+        destination = :output / :index.xhtml
+        
+        File.open destination, File::RDWR|File::TRUNC|File::CREAT, 0664 do |f|
+          f.puts completed
+          f.close
+        end
+           
+        puts "~ index.xhtml compiled"
+      end # build_index
+      
+  end # Application
+end #GitBlog

data/lib/git-blog/extlib.rb

@@ -0,0 +1,3 @@
+require 'git-blog/extlib/file'
+require 'git-blog/extlib/symbol' 
+require 'git-blog/extlib/string' 

data/lib/git-blog/extlib/file.rb

@@ -0,0 +1,12 @@
+class File
+  Extensions = %r=^(markdown|textile|haml|sass|css|html|xhtml|rb|txt|text|atom|rss|xml)$=i
+  module Extension
+    def method_missing(meth, *args)
+      if Extensions =~ meth.to_s
+        [self, '.', meth.to_s].join
+      else
+        super
+      end # if
+    end # method_missing
+  end # Extension
+end # File

data/lib/git-blog/extlib/string.rb

@@ -0,0 +1,18 @@
+module GitBlog
+  module Extlib
+    module String
+      def slugify
+        self.gsub(/([\s]+)/, '_').gsub(/([^a-z0-9_]+)/i, '').downcase
+      end 
+      
+      def /(path)
+        File.join(self, path.to_s)
+      end
+    end
+  end
+end
+
+class String
+  include File::Extension
+  include GitBlog::Extlib::String
+end

data/lib/git-blog/extlib/symbol.rb

@@ -0,0 +1,14 @@
+module GitBlog
+  module Extlib
+    module Symbol
+      def /(path)
+        File.join(self.to_s, path.to_s)
+      end # def
+    end # Symbol
+  end # Extlib
+end # GitBlog
+
+class Symbol           
+  include File::Extension
+  include GitBlog::Extlib::Symbol
+end

data/lib/git-blog/parser.rb

@@ -0,0 +1,9 @@
+module GitBlog
+  module Parser
+    def self.fix_pres(string)
+      string.gsub %r!([ \t]*)<pre>(.*?)</pre>!m do |match|
+        match.gsub(/^#{$1}/, '')
+      end
+    end # self.fix_pres
+  end # Parser
+end # GitBlog

data/lib/git-blog/parser/haml.rb

@@ -0,0 +1,12 @@
+require 'haml'
+
+module GitBlog
+  module Parser
+    module Haml
+      def self.parse input
+        input.gsub!(/^(.*)(\n\s+)*\n/m, '')
+        ::Haml::Engine.new(input).render
+      end
+    end
+  end
+end

data/lib/git-blog/parser/html.rb

@@ -0,0 +1,10 @@
+module GitBlog
+  module Parser
+    module HTML
+      def self.parse input
+        input.gsub!(/^(.*)(\n\s+)*\n/m, '')
+        input
+      end
+    end
+  end
+end

data/lib/git-blog/parser/markdown.rb

@@ -0,0 +1,34 @@
+# Maruku
+begin
+  require 'maruku'
+  Markdown = Maruku
+  
+# rpeg-markdown
+rescue LoadError
+  begin
+    require 'markdown'
+  
+  # Discount
+  rescue LoadError
+    begin
+      require 'rdiscount'
+      Markdown = RDiscount
+    
+    # BlueCloth
+    rescue LoadError
+      require 'bluecloth'
+      Markdown = BlueCloth
+    end
+  end
+end
+
+module GitBlog
+  module Parser
+    module Markdown
+      def self.parse input
+        input.gsub!(/^(.*)\n=+(\n\s+)*\n/m, '')
+        ::Markdown.new(input).to_html
+      end
+    end
+  end
+end

data/lib/git-blog/parser/textile.rb

@@ -0,0 +1,12 @@
+require 'redcloth'
+
+module GitBlog
+  module Parser
+    module Textile
+      def self.parse(input)
+        input.gsub!(/^(.*)(\n\s+)*\n/m, '')
+        ::RedCloth.new(input).to_html
+      end
+    end
+  end
+end

data/prepped/design/index.html.haml

@@ -0,0 +1,18 @@
+!!! xml
+!!! 1.1
+%html{:xmlns => 'http://www.w3.org/1999/xhtml', 'xml:lang' => 'en', 'xml:dir' => 'ltr'}
+  %head
+    %meta{ :'http-equiv' => 'Content-Type', :content => 'application/xhtml+xml; charset=utf-8' }
+    %title yet another git-blog
+    %link{ :rel => 'stylesheet', :href => '/style.css', :type => 'text/css; charset=utf-8' }
+    / %link{ :rel => 'alternate',  :href => '/index.rss', :type => 'application/rss+xml', :title => 'Feed (RSS 2.0)'  }
+  %body
+    %h1 yet another git-blog
+    %ol#posts
+      - posts.each do |post|
+        %li
+          %a{ :href => "/archive/#{post[:slug]}.html", :title => post[:title] }= post[:title] 
+          
+    #footer
+      :markdown
+        powered by [git-blog](http://github.com/elliottcable/git-blog "elliottcable's git-blog on GitHub"), by [elliottcable](http://elliottcable.name "elliottcable")                                                                         

data/prepped/design/post.html.haml

@@ -0,0 +1,17 @@
+!!! xml
+!!! 1.1
+%html{ :xmlns => 'http://www.w3.org/1999/xhtml', :'xml:lang' => 'en' :'xml:dir' => 'ltr' }
+  %head
+    %meta{ :'http-equiv' => 'Content-Type', :content => 'application/xhtml+xml; charset=utf-8' }
+    %title= title
+    %link{ :rel => 'stylesheet', :href => '/style.css', :type => 'text/css; charset=utf-8' }
+    / %link{ :rel => 'alternate',  :href => '/index.rss', :type => 'application/rss+xml', :title => 'Feed (RSS 2.0)'  }
+  %body
+  
+    %h1= title
+    #content
+      = content
+
+    #footer
+      :markdown
+        return [home](../ "blog root") | powered by [git-blog](http://github.com/elliottcable/git-blog "elliottcable's git-blog on GitHub"), by [elliottcable](http://elliottcable.name "elliottcable")

data/prepped/design/style.sass

@@ -0,0 +1,31 @@
+body
+  :width    45em
+  :margin   auto
+  :font
+    :family "Georiga", "Times New Roman", "Times", "Serif";
+    :size   11pt/1.6
+    
+h1
+  :text-align     center
+  :font
+    :family       "Helvetica Neue", Arial, Helvetica, Geneva, sans-serif
+  :text-transform uppercase
+  
+#posts
+  
+  li
+    :list-style-type  none
+    :text-align       center
+    :font-size        150%
+    
+#footer
+  :padding    auto 5px
+  :background #FFF
+  :position   fixed
+  :bottom     0
+  :right      0
+  :font-size  85%
+  
+  p
+    :margin   0 !important
+    :padding  0 !important

data/prepped/post-receive.hook

@@ -0,0 +1,4 @@
+#!/bin/bash
+GIT_DIR=$(pwd) # I do not know, for the life of me, why this is necessary.
+cd ../
+git-blog post_receive

data/prepped/posts/welcome_to_your_git_blog.markdown

@@ -0,0 +1,4 @@
+Welcome to your git-blog
+========================
+
+Welcome to your [git-blog](http://github.com/elliottcable/git-blog "elliottcable's git-blog - GitHub") powered blog! Type `rake -T` in your local blog directory to get started *(-:*

metadata

@@ -0,0 +1,77 @@
+--- !ruby/object:Gem::Specification 
+name: cameroncox-git-blog
+version: !ruby/object:Gem::Version 
+  version: 0.0.1
+platform: ruby
+authors: 
+- Cameron Cox
+- Elliot Cable
+autorequire: 
+bindir: bin
+cert_chain: []
+
+date: 2008-06-30 00:00:00 -07:00
+default_executable: 
+dependencies: []
+
+description: yet another git-blog
+email: cameroncox@gmail.com
+executables: 
+- git-blog
+extensions: []
+
+extra_rdoc_files: 
+- README
+- LICENSE
+files: 
+- LICENSE
+- README
+- Rakefile
+- bin/git-blog
+- lib/git-blog.rb
+- lib/git-blog/application.rb
+- lib/git-blog/parser.rb
+- lib/git-blog/extlib.rb
+- lib/git-blog/extlib/file.rb
+- lib/git-blog/extlib/string.rb
+- lib/git-blog/extlib/symbol.rb
+- lib/git-blog/parser/haml.rb
+- lib/git-blog/parser/textile.rb
+- lib/git-blog/parser/markdown.rb
+- lib/git-blog/parser/html.rb
+- prepped/.gitignore
+- prepped/design/index.html.haml
+- prepped/design/post.html.haml
+- prepped/design/style.sass
+- prepped/post-receive.hook
+- prepped/posts/welcome_to_your_git_blog.markdown
+- prepped/posts/.gitignore
+has_rdoc: false
+homepage: http://github.com/cameroncox/git-blog/
+post_install_message: 
+rdoc_options: []
+
+require_paths: 
+- lib
+- prepped
+required_ruby_version: !ruby/object:Gem::Requirement 
+  requirements: 
+  - - ">="
+    - !ruby/object:Gem::Version 
+      version: "0"
+  version: 
+required_rubygems_version: !ruby/object:Gem::Requirement 
+  requirements: 
+  - - ">="
+    - !ruby/object:Gem::Version 
+      version: "0"
+  version: 
+requirements: []
+
+rubyforge_project: git-blog
+rubygems_version: 1.2.0
+signing_key: 
+specification_version: 2
+summary: yet another git-blog
+test_files: []
+