contraption 0.2.0

data/lib/contraption/location.rb

@@ -0,0 +1,81 @@
+require_relative '../contraption'
+require 'pathname'
+
+module Contraption
+  class Location
+    def initialize path="."
+      @pn = Pathname.new path
+    end
+
+    def list ext=/.*/
+      ext = Array(ext).join('|')
+      ext = Regexp.new ext
+      pn.find
+        .reject { |f| f == pn }
+        .select { |f| ext.match f.extname }
+        .map{ |f| f.basename.to_s }
+    end
+
+    def path
+      pn.to_s
+    end
+
+    def read file_name
+      complete_name = pn+file_name
+      return :file_does_not_exist unless complete_name.exist?
+      return :file_not_readable unless complete_name.readable?
+
+      return complete_name.read unless block_given?
+      complete_name.open("r") { |f| yield f }
+    end
+
+    def cd directory
+      l = Location.new(pn+directory)
+      l.create!  unless l.pn.directory?
+      l
+    end
+
+    def create!
+      pn.mkpath unless exist?
+    end
+
+    def remove file_name
+      complete_name = pn+file_name
+      return :file_does_not_exist unless complete_name.exist?
+
+      complete_name.delete
+    end
+
+    def write file_name, content
+      complete_name = pn+file_name
+      return :file_already_exists if complete_name.exist?
+
+      complete_name.dirname.mkpath unless complete_name.dirname.exist?
+
+      complete_name.open("w:UTF-8") {|f| f.print content}
+    end
+
+    def == other_location
+      path == other_location.path
+    end
+
+    def exist?
+      pn.exist?
+    end
+
+    def readable?
+      pn.readable?
+    end
+
+    def writable?
+      pn.writable?
+    end
+
+    def executable?
+      pn.executable?
+    end
+
+    protected
+      attr_reader :pn
+  end
+end

data/lib/contraption/options.rb

@@ -0,0 +1,56 @@
+require 'optparse'
+require 'yaml'
+
+require_relative 'location'
+
+module Contraption
+
+  DEFAULT_SOURCE      = "content"
+  DEFAULT_DESTINATION = "public_html"
+  DEFAULT_CONFIG_FILE = Pathname.new("~/.contraption.yaml").expand_path
+
+  class Options
+    attr_reader :values
+
+    def initialize args
+      @values = {
+                 source:               DEFAULT_SOURCE,
+                 destination:          DEFAULT_DESTINATION,
+                 s3_access_key_id:     nil,
+                 s3_secret_access_key: nil,
+                 s3_target_bucket:     nil
+      }
+      @values.merge!(YAML.load_file(DEFAULT_CONFIG_FILE)) if DEFAULT_CONFIG_FILE.file?
+      @values.each_pair {|k, v| @values[k] = Location.new(v) if %i[source destination].include? k}
+      parse(args)
+    end
+
+    private
+      def method_missing m, *a, &b
+        values.fetch(m) { super }
+      end
+
+      def parse args
+        OptionParser.new do |opts|
+          opts.banner = "Usage: contraption [ options ]"
+          opts.on("-d", "--destination path", "Path to destination") do |path|
+            @values[:destination] = Location.new path
+          end
+          opts.on("-s", "--source path", "Path to source") do |path|
+            @values[:source] = Location.new path
+          end
+          opts.on("--generate-config-file", "Create YAML file containing configuration options") do
+            DEFAULT_CONFIG_FILE.open('w+') {|f| f.write(@values.to_yaml) }
+            exit
+          end
+          begin
+            opts.parse!(args)
+          rescue OptionParser::ParseError => e
+            STDERR.puts e.message, "\n", opts
+            exit(1)
+          end
+        end
+      end
+
+  end
+end

data/lib/contraption/post.rb

@@ -0,0 +1,69 @@
+require_relative 'header'
+
+require 'redcarpet'
+
+module Contraption
+  class Post
+    class << self
+      def build data=""
+        data = data.to_s
+
+        splitted = data.split(/\n\n/, 2)
+        Post.new Header.from(splitted.first), translate_markdown(splitted.last)
+      rescue ArgumentError => e
+        Post.new Header.from(""), ""
+      end
+
+      def translate_markdown content
+        Redcarpet::Markdown.new(Redcarpet::Render::HTML).render(content)
+      end
+    end
+
+    def publish link_handlers=[]
+      links = list_links
+
+      links.map! do |link|
+        h = link_handlers.select{|l| l.protocol == link.first.to_sym}
+        if h.length > 1
+          raise "Multiple link handlers for #{link.first} protocol"
+        elsif h.length == 0
+          nil
+        else
+          h = h.first
+          [link, h.handle(link)]
+        end
+      end.compact!
+
+      update_links links
+
+      Post.new( metadata.update({publication_date: Time.now}), body)
+    end
+
+    attr_reader :body, :metadata
+    private
+      def initialize  metadata="", body=""
+        @body = body
+        @metadata = metadata
+      end
+
+      def method_missing m, *a, &b
+        metadata.public_send(m, *a, &b)
+      end
+
+      def list_links
+        links = []
+        body.scan(/="([^"]*)"/) do |link|
+          links << link.first.split('://', 2)
+        end
+        links
+      end
+
+      def update_links new_links
+        new_links.each do |link|
+          orig = link.first.join('://')
+          new  = link.last.join('://')
+          @body.gsub!("=\"#{orig}\"", "=\"#{new}\"")
+        end
+      end
+  end
+end

data/lib/contraption/repository.rb

@@ -0,0 +1,58 @@
+require_relative "post"
+require_relative "formatter"
+require_relative "catalog"
+
+module Contraption
+  class Repository
+    attr_reader :formatter
+
+    def initialize path
+      @path = path
+      validate
+      construct_locations
+      @formatter = Formatter.new @formats_source
+    end
+
+    def validate
+      raise "Invalid source directory structure in #{@path}" unless valid_layout?
+    end
+
+    def valid_layout?
+      @path.exist? and @path.list.include? "drafts" and @path.list.include? "posts"
+    end
+
+    def drafts
+      @drafts_source.list
+    end
+
+    def posts
+      Catalog.new( @posts_source.list.map{|p| Post.build(@posts_source.read p)} )
+    end
+
+    def static_files
+      @static_source.path
+    end
+
+    def completed_drafts
+      drafts.map{|draft| [draft, @drafts_source.read(draft)]}
+            .each_with_object([]) do |draft, result|
+              result << draft.first if Post.build(draft.last).new?
+            end
+    end
+
+    def finalize_completed_drafts link_handlers=[]
+      completed_drafts.map{|draft| [draft, Post.build(@drafts_source.read(draft)).publish(link_handlers)]}
+                      .each do |filename, post|
+                        @posts_source.write post.publication_date.strftime("%Y%m%d-")+post.filename, @formatter.format(post, :raw)
+                        @drafts_source.remove filename
+                      end
+    end
+
+    def construct_locations
+      @drafts_source  = @path.cd("drafts")
+      @posts_source   = @path.cd("posts")
+      @formats_source = @path.cd("formats")
+      @static_source  = @path.cd("static")
+    end
+  end
+end

data/lib/contraption/rss_builder.rb

@@ -0,0 +1,30 @@
+require 'rss/maker'
+
+module Contraption
+  class RSSBuilder
+    def initialize posts
+      @posts = posts
+    end
+
+    def to_rss
+      RSS::Maker.make('2.0') do |maker|
+        maker.channel.author = 'Casey Robinson'
+        maker.channel.updated = Time.now.to_s
+        maker.channel.link = 'http://rampantmonkey.com/rss'
+        maker.channel.title = 'Rampant Monkey - Everything'
+        maker.channel.description = 'Everything published on rampantmonkey.com'
+
+        @posts.most_recent(-1).each do |post|
+          maker.items.new_item do |item|
+            item.link = "http://rampantmonkey.com/#{post.publication_date.strftime('%Y/%m')}/#{post.filename('.html')}"
+            item.title = post.title
+            item.pubDate = post.publication_date.to_s
+            item.updated = post.publication_date.to_s
+            item.description = post.summary
+            item.content_encoded = post.body
+          end
+        end
+      end
+    end
+  end
+end

data/lib/contraption/runner.rb

@@ -0,0 +1,60 @@
+require_relative 'repository'
+require_relative 'site'
+require_relative 's3_uploader'
+require_relative 'http_handler'
+
+module Contraption
+  class Runner
+    def initialize options
+      @options = options
+    end
+
+    def run!
+      source.finalize_completed_drafts handlers
+      site.build_all_individuals
+      site.build_month_pages
+      site.build_year_pages
+      site.build_tag_pages
+      site.build_tag_cloud
+      site.build_recent
+      site.build_landing
+      site.build_rss
+      copy_static_files
+    end
+
+    private
+    def formatter
+      @formatter ||= source.formatter
+    end
+
+    def posts
+      @posts ||= source.posts
+    end
+
+    def site
+      @site ||= Site.new @options.destination, posts, formatter
+    end
+
+    def source
+      @source ||= Repository.new @options.source
+    end
+
+    def copy_static_files
+      `cp -r #{source.static_files}/* #{site.root}` unless (Dir[source.static_files.to_s + "/*"]).length == 0
+    end
+
+    def handlers
+      if @options.s3_access_key_id
+        [
+          HttpHandler.new,
+          S3Uploader.new({access_key_id: @options.s3_access_key_id,
+                          secret_access_key: @options.s3_secret_access_key},
+                          @options.s3_target_bucket,
+                          @options.source)
+        ]
+      else
+        [ HttpHandler.new]
+      end
+    end
+  end
+end

data/lib/contraption/s3_uploader.rb

@@ -0,0 +1,30 @@
+require 'aws/s3'
+require 'pathname'
+
+module Contraption
+  class S3Uploader
+    def initialize connection_args={}, target_bucket, path
+      AWS::S3::Base.establish_connection! connection_args
+      @target_bucket = target_bucket
+      @path = path.cd "drafts"
+    end
+
+    def protocol
+      :s3
+    end
+
+    def handle request
+      local_path = Pathname.new(@path.path) + request.last
+      if local_path.exist?
+        upload local_path, request.last
+        ["http:", "#{@target_bucket}/#{request.last}"]
+      else
+        raise "#{request.last} does not exist"
+      end
+    end
+
+    def upload local_path, remote_path
+      AWS::S3::S3Object.store(remote_path, open(local_path), @target_bucket, :access => :public_read, 'Cache-Control' => 'max-age=3136000')
+    end
+  end
+end

data/lib/contraption/site.rb

@@ -0,0 +1,85 @@
+require_relative 'tag_cloud'
+require_relative 'rss_builder'
+
+module Contraption
+  class Site
+    def initialize location, posts, formats
+      @location = location
+      @formats = formats
+      @posts = posts
+    end
+
+    def build_all_individuals
+      @posts.each.to_a.each { |i| build_individual i }
+    end
+
+    def build_individual i
+      post_location = @location.cd(post_path i)
+      context = build i
+      page = @formats.format(context, :page)
+      post_location.write(i.filename('.html'), page)
+    end
+
+    def build_month_pages
+      build_pages_by(:month) {|m| "#{m.year}/#{"%02d" % m.month}"}
+    end
+
+    def build_year_pages
+      build_pages_by(:year) {|y| y.year.to_s}
+    end
+
+    def build_tag_pages
+      build_pages_by(:tag) {|t| "tags/#{Tag.new(t).to_url}"}
+    end
+
+    def build_recent
+      recent_posts = @posts.most_recent 8
+      combined_posts = build recent_posts
+      write_as_page combined_posts, @location, 'recent.html'
+    end
+
+    def build_landing
+      content = @formats.format({most_recent: @posts.most_recent.first}, :landing_page)
+      @location.write('index.html', content)
+    end
+
+    def build_tag_cloud
+      tag_cloud = TagCloud.new @posts
+      content = @formats.format({content: tag_cloud.to_s}, :tag_cloud)
+      path = @location.cd 'tags'
+      write_as_page content, path
+    end
+
+    def build_rss
+      feed = RSSBuilder.new(@posts).to_rss
+      @location.write 'rss', feed
+    end
+
+    def root
+      @location.path
+    end
+
+    private
+    def build collection
+      Array(collection).map {|p| @formats.format p}.join
+    end
+
+    def build_pages_by type, &determine_path
+      @posts.public_send("by_#{type}".to_sym).each_pair do |key, posts|
+        path = @location.cd determine_path.call key
+        combined_posts = build posts
+        intermediate_page = @formats.format({content: combined_posts, key: key}, type.to_sym)
+        write_as_page intermediate_page, path
+      end
+    end
+
+    def post_path post
+      post.publication_date.strftime('%Y') + '/' + post.publication_date.strftime('%m')
+    end
+
+    def write_as_page content, path, name='index.html'
+      page = @formats.format(content, :page)
+      path.write(name, page)
+    end
+  end
+end

data/lib/contraption/tag.rb

@@ -0,0 +1,20 @@
+module Contraption
+  class Tag
+    def initialize text
+      @display_text = text.to_s
+    end
+
+    def to_s
+      @display_text
+    end
+
+    def to_url
+      @display_text.downcase
+                   .gsub ' ', '-'
+    end
+
+    def to_sym
+      @display_text.to_sym
+    end
+  end
+end

data/lib/contraption/tag_cloud.rb

@@ -0,0 +1,35 @@
+module Contraption
+  class TagCloud
+    def initialize posts
+      @posts = posts
+    end
+
+    def to_s
+      @posts.by_tag
+            .each_pair
+            .map {|k, v| [tag_link(k), tag_size(v.length)]}
+            .map {|el| scale el}
+            .join "\n"
+    end
+
+    private
+    def tag_link tag
+      tag = Tag.new tag
+      %Q{<a href="tags/#{tag.to_url}/index.html">#{tag.to_s}</a>}
+    end
+
+    def scale element
+      link = element.first
+      size = element.last
+      %Q{<span style="font-size: #{size}em;">#{link}</span>}
+    end
+
+    def max
+      @posts.by_tag.each_pair.map {|k, v| v.length}.max
+    end
+
+    def tag_size length
+      (1 + length.to_f/max) * 0.8
+    end
+  end
+end

data/lib/contraption/version.rb

@@ -0,0 +1,3 @@
+module Contraption
+  VERSION = "0.2.0"
+end

data/lib/contraption.rb

@@ -0,0 +1,14 @@
+require "contraption/version"
+require "contraption/post"
+require "contraption/header"
+require "contraption/catalog"
+require "contraption/location"
+require "contraption/runner"
+require "contraption/tag"
+require "contraption/tag_cloud"
+
+module Contraption
+  Year  = Struct.new :year
+  Month = Struct.new :year, :month
+  Day   = Struct.new :year, :month, :day
+end

data/spec/contraption/lib/catalog_spec.rb

@@ -0,0 +1,105 @@
+require_relative '../../../lib/contraption/catalog'
+require 'date'
+
+module Contraption
+  describe Catalog do
+    context "item storage" do
+      before (:each) do
+        @items = %w[a b c d e f g]
+        @c = Catalog.new @items
+      end
+
+      it "stores items" do
+        @c.items.should eq @items
+      end
+
+      it "stores new items" do
+        @c << "P"
+        @c.items.should eq(@items << "P")
+      end
+
+      it "delegates #each to @items" do
+        @c.each.to_a.should eq @items
+      end
+    end
+
+    context "date grouping" do
+      let(:item_1)  { stub(publication_date: Date.new(2012, 2, 1)) }
+      let(:item_2)  { stub(publication_date: Date.new(2012, 1, 1)) }
+      let(:item_3)  { stub(publication_date: Date.new(2013, 1, 7)) }
+      let(:item_4)  { stub(publication_date: Date.new(2013, 1, 8)) }
+      let(:catalog) { Catalog.new [item_1, item_2, item_3, item_4] }
+
+      it "groups items by year" do
+        catalog.by_year.should eq ({
+          Year.new(2012) => [item_1, item_2],
+          Year.new(2013) => [item_3, item_4]
+        })
+      end
+
+      it "groups items by month" do
+        catalog.by_month.should eq ({
+          Month.new(2012, 2) => [item_1],
+          Month.new(2012, 1) => [item_2],
+          Month.new(2013, 1) => [item_3, item_4]
+        })
+      end
+
+      it "groups items by passed block" do
+        catalog.by_day.should eq ({
+          Day.new(2012, 2, 1) => [item_1],
+          Day.new(2012, 1, 1) => [item_2],
+          Day.new(2013, 1, 7) => [item_3],
+          Day.new(2013, 1, 8) => [item_4]
+        })
+      end
+
+      context "#most_recent" do
+        it "returns the most recently published item" do
+          catalog.most_recent.should eq [item_4]
+        end
+
+        it "returns the 3 most recently published items" do
+          catalog.most_recent(3).should eq [item_4, item_3, item_1]
+        end
+
+        it "returns all posts given a negative parameter" do
+          catalog.most_recent(-1).should eq [item_4, item_3, item_1, item_2]
+        end
+      end
+    end
+
+    context "tag grouping" do
+      let(:item_1)  { stub(tags: %w[a b c]) }
+      let(:item_2)  { stub(tags: [])}
+      let(:item_3)  { stub(tags: %w[a d]) }
+      let(:item_4)  { stub(tags: %w[b c d]) }
+      let(:item_5)  { stub(tags: %w[c e]) }
+      let(:catalog) { Catalog.new [item_1, item_2, item_3, item_4, item_5] }
+
+      it "groups all items tagged with 'a'" do
+        catalog.by_tag[:a].should eq [item_1, item_3]
+      end
+
+      it "groups all items tagged with 'b'" do
+        catalog.by_tag[:b].should eq [item_1, item_4]
+      end
+
+      it "groups all items tagged with 'c'" do
+        catalog.by_tag[:c].should eq [item_1, item_4, item_5]
+      end
+
+      it "groups all items tagged with 'd'" do
+        catalog.by_tag[:d].should eq [item_3, item_4]
+      end
+
+      it "groups all items tagged with 'e'" do
+        catalog.by_tag[:e].should eq [item_5]
+      end
+    end
+
+    it "includes enumerable" do
+      Catalog.included_modules.should include Enumerable
+    end
+  end
+end

data/spec/contraption/lib/formatter_spec.rb

@@ -0,0 +1,30 @@
+require_relative '../../../lib/contraption/formatter'
+
+module Contraption
+  describe Formatter do
+    it "accepts a source location" do
+      source = "/some/path/"
+      source.stub(:list).and_return([])
+      Formatter.new source
+    end
+
+    context "#formats" do
+      it "contains a list of available formats" do
+        source = double()
+        source.stub(:list).with('.erb').and_return(%w[article.erb link.erb])
+        f = Formatter.new source
+        f.formats.should eq %i[article link]
+      end
+    end
+
+    context "#format" do
+      it "raises an error if format does not exist" do
+        source = double()
+        source.stub(:list).and_return([])
+        f = Formatter.new source
+        context = Struct.new(:type).new(:article)
+        expect {f.format(context)}.to raise_error(ArgumentError)
+      end
+    end
+  end
+end