CarmineContraption 0.1.0 → 0.1.1

data/lib/carmine_contraption/runner.rb

@@ -1,6 +1,4 @@
-require_relative 'options'
-require_relative 'index'
-require_relative 'uploader'
+require_relative '../carmine_contraption'
 
 require 'pathname'
 require 'colorize'
@@ -12,107 +10,109 @@ module CarmineContraption
       @source = @options.source
       @destination = @options.destination
       @override = @options.override
-      @template =  Pathname.new('lib/templates/default.html.erb')
       @input_extensions = [".md", ".html"]
       @drafts_path = @source + 'drafts'
       @posts_path = @source + 'posts'
     end
 
-    def check_for_new_posts
-      @input_extensions.each do |input_extension|
-        Pathname.glob(@drafts_path + "*#{input_extension}") do |i|
-          post = ''
-          posted_filename = i.basename
-          move_completed_draft = false
-          File.foreach(i) do |line|
-            if line.downcase =~ /publish-now/
-              move_completed_draft = true
-              t = Time.now
-              post += 'Published: ' + t.strftime("%a, %d %b %Y %H:%M:%S %Z") + "\n"
-              posted_filename = "#{t.strftime('%Y%m%d')}-#{posted_filename}"
-            else
-              post += line
-            end
-          end
-          if move_completed_draft
-            puts "Publishing draft: #{posted_filename}".yellow
-            (@posts_path+posted_filename).open('w') {|f| f.write(post)}
-            `rm #{i}`
-            `lib/update_repo.sh #{@source} #{posted_filename}` if @options.update_repository
-            up = Uploader.new({access_key_id: @options.s3_access_key_id,
-                               secret_access_key: @options.s3_secret_access_key},
-                              @options.s3_target_bucket)
-            the_post = Post.from_file((@posts_path+posted_filename).to_s, input_extension)
-            tmp = []
-            the_post.media.each do |m|
-              puts "Uploading #{m.name}...".green
-              remote_name = "#{the_post.year}/#{the_post.month}/#{m.name}"
-              up.upload (m.update remote_path: remote_name)
-              tmp << (m.update remote_path: "http://#{@options.s3_target_bucket}/#{remote_name}")
+    def run
+      find_new_posts if @options.new_post_check
+      if @options.build_targets.has_value?(true)
+        @the_index = Index.new @source, @destination
+        @the_writer = Writer.new @the_index, @override
+        @options.build_targets.each { |k, v| send "build_#{k}" if v }
+      end
+    end
+
+    private
+      def find_new_posts
+        @input_extensions.each do |input_extension|
+          Pathname.glob(@drafts_path + "*#{input_extension}") do |i|
+            post = IO.read i
+            if is_draft_ready? post
+              post, posted_filename = timestamp_post post, i.basename
+              move_draft post, posted_filename, i
             end
-            the_post = the_post.update(media: tmp)
-            (@posts_path+posted_filename).open('w') { |f| f.write(the_post.formatted_output '') }
           end
         end
       end
-    end
 
-    def build_landing
-      all_paths = []
-      @input_extensions.each do |input_extension|
-        Pathname.glob(@posts_path + "*#{input_extension}") { | path | all_paths << path }
+      def is_draft_ready? post
+        /^publish-now\s*$/.match post.downcase
       end
-      most_recent = all_paths.sort.last
-      most_recent_extension = most_recent.extname
-      the_post = Post.from_file most_recent, most_recent_extension
-      landing_template = Pathname.new('lib/templates/landing_page.html')
-      output = landing_template.open('r').read
-      output.gsub!(/\#\{title\}/, the_post.title)
-      output.gsub!(/\#\{summary\}/, the_post.summary)
-      link = "#{the_post.year}/#{the_post.month}/#{the_post.guid}.html"
-      output.gsub!(/\#\{link\}/, link)
-      (@destination + "index.html").open('w:UTF-8') {|f| f.write(output) }
-      puts "Rendering #{@destination}index.html".blue
-    end
 
-    def build_monthly
-      @the_index.build_monthly_archives
-      @the_index.write_monthly_archives
-    end
+      def timestamp_post post, filename
+        t = Time.now
+        post.gsub!(/^publish-now\s*$/, "Published: #{t.strftime "%a, %d %b %Y %H:%M:%S %Z"}\n")
+        posted_filename = "#{t.strftime('%Y%m%d')}-#{filename}"
+        return post, posted_filename
+      end
 
-    def build_yearly
-      @the_index.build_yearly_archives
-      @the_index.write_yearly_archives
-    end
+      def move_draft post, filename, draft_name
+        puts "Publishing draft: #{filename}".yellow
+        (@posts_path+filename).open('w') {|f| f.write(post)}
+        `rm #{draft_name}`
+        `lib/update_repo.sh #{@source} #{filename}` if @options.update_repository
+        the_post = Post.from_file((@posts_path+filename).to_s, File.extname(draft_name))
+        the_post = upload_media the_post
+        (@posts_path+filename).open('w') { |f| f.write(the_post.formatted_output Formatter.new(@source+"formats"), :raw) }
+      end
 
-    def build_tag
-      @the_index.build_tag_archives
-      @the_index.write_tag_archives
-      @the_index.write_tag_cloud
-    end
+      def upload_media post
+        up = Uploader.new({access_key_id: @options.s3_access_key_id,
+                           secret_access_key: @options.s3_secret_access_key},
+                          @options.s3_target_bucket)
+        post.update(media: post.media.map do |m|
+            puts "Uploading #{m.name}...".green
+            remote_path = post.published.strftime "%Y/%m/"
+            up.upload (m.update remote_path: remote_path)
+            m.update remote_path: "http://#{@options.s3_target_bucket}/#{remote_path}"
+          end
+        )
+      end
 
-    def build_individual
-      @the_index.write_individual_posts
-    end
+      def build_landing
+        all_paths = []
+        @input_extensions.each do |input_extension|
+          Pathname.glob(@posts_path + "*#{input_extension}") { | path | all_paths << path }
+        end
+        most_recent = all_paths.sort.last
+        most_recent_extension = most_recent.extname
+        the_post = Post.from_file most_recent, most_recent_extension
+        landing_template = Pathname.new('lib/templates/landing_page.html')
+        output = landing_template.open('r').read
+        output.gsub!(/\#\{title\}/, the_post.title)
+        output.gsub!(/\#\{summary\}/, the_post.summary)
+        link = "#{the_post.published.strftime "%Y/%m/"}#{the_post.guid}.html"
+        output.gsub!(/\#\{link\}/, link)
+        (@destination + "index.html").open('w:UTF-8') {|f| f.write(output) }
+        puts "Rendering #{@destination}index.html".blue
+      end
 
-    def build_index
-      @the_index.build_yearly_archives
-      @the_index.build_monthly_archives
-      @the_index.write_main_page
-    end
+      def build_monthly
+        @the_writer.write_monthly_archives
+      end
 
-    def build_rss
-      @the_index.build_tag_archives
-      @the_index.write_rss
-    end
+      def build_yearly
+        @the_writer.write_yearly_archives
+      end
 
-    def run
-      check_for_new_posts if @options.new_post_check
-      if @options.build_targets.has_value?(true)
-        @the_index = Index.new @posts_path, @destination, @template, @override
-        @the_index.find_all_posts
-        @options.build_targets.each { |k, v| send "build_#{k}" if v }
+      def build_tag
+        @the_writer.write_tag_archives
+        @the_writer.write_tag_cloud
       end
-    end
+
+      def build_individual
+        @the_writer.write_individual_posts
+      end
+
+      def build_index
+        @the_writer.write_main_page
+      end
+
+      def build_rss
+        @the_writer.write_rss
+      end
+
   end
 end

data/lib/carmine_contraption/version.rb

@@ -1,3 +1,3 @@
 module CarmineContraption
-  VERSION = '0.1.0'
+  VERSION = '0.1.1'
 end

data/lib/carmine_contraption/writer.rb

@@ -0,0 +1,132 @@
+require_relative '../carmine_contraption'
+
+module CarmineContraption
+  class Writer
+    def initialize the_index, override
+      @index = the_index
+      @templater = Formatter.new(the_index.base + "templates")
+      @formatter = Formatter.new(the_index.base + "formats")
+      @override = override
+    end
+
+    def write_rss
+      puts "Updating RSS feed".blue
+      content = format_post_collection all_posts.reverse, :rss
+      feed_path = destination + "rss.xml"
+      write_file feed_path, content, false, :rss
+    end
+
+    def write_individual_posts
+      all_posts.each do |the_post|
+        path = post_path the_post
+        write_file path, the_post.formatted_output(@formatter) unless ( path.exist? and !@override )
+      end
+    end
+
+    def write_main_page
+      content = ""
+      content << format_post_collection(all_posts[-8..-1].reverse)
+      content << create_archive_links
+      write_file destination + "recent.html", content
+    end
+
+    def write_monthly_archives
+      monthly_archives.each_key do |k|
+        d = build_date_from_key k
+        path = destination + d.year.to_s + d.month.to_s
+        path.mkpath
+        content = format_archive_for_month d, k
+        write_file path+"index.html", content, true
+      end
+    end
+
+    def write_tag_archives
+      path = destination + "tags"
+      path.mkpath
+      tag_archives.keys.each { |k| write_tag_archive k, path }
+      write_tag_feeds
+    end
+
+    def write_yearly_archives
+      yearly_archives.keys.each do |k|
+        path = destination + k
+        path.mkpath
+        content = archive_heading "ARCHIVE FOR '<emph>#{k}</emph>'"
+        content << format_post_collection(yearly_archives[k])
+        write_file path+"index.html", content, true
+      end
+    end
+
+    def write_tag_cloud
+      path = destination + "tags" + "index.html"
+      content = archive_heading "TAG_CLOUD"
+      content += "<section class=\"tag_cloud \">\n"
+      max = longest_tag
+      tag_archives.sort_by{|k,v| k}.each do |k, v|
+        content << scale_tag(k, v.length, max)
+      end
+      content += "</section>\n"
+      write_file path, content
+    end
+
+    private
+      def method_missing method, *args, &block
+        return @index.send method, *args, &block if @index.respond_to? method
+        super
+      end
+
+      def post_path the_post
+        path = destination + the_post.published.strftime("%Y") + the_post.published.strftime("%m")
+        path.mkpath
+        path += "#{the_post.guid}.html"
+      end
+
+      def format_post_collection posts, formatting_method=nil
+        posts.inject("") { |c, post| c << post.formatted_output(@formatter, formatting_method) }
+      end
+
+      def scale_tag k, tag_length, max
+        size = (1+tag_length.to_f/max) * 0.8
+        %Q{<span style="font-size: #{size}em;"><a href="tags/#{k.gsub(' ', '_').downcase}.html">#{k.gsub('_', ' ')}</a></span>\n}
+      end
+
+      def write_tag_archive k, path
+        content = archive_heading "ARCHIVE FOR '<emph>#{k.upcase.gsub '_', ' ' }</emph>'"
+        content << format_post_collection(tag_archives[k].reverse)
+        write_file path + "#{k.gsub(' ', '_').downcase}.html", content, true
+      end
+
+      def write_file file, content='', supress_message=false, method=:default
+        puts "Rendering #{file}".blue unless supress_message
+        file.open('w:UTF-8') { |f| f.write @templater.format(content, method) }
+      end
+
+      def write_tag_feeds
+        rss_base_path = destination+"rss"
+        rss_base_path.mkpath
+        tag_archives.keys.each do |k|
+          content = format_post_collection tag_archives[k].reverse, :rss
+          write_file (rss_base_path + "#{k}.xml"), content, true, :rss
+        end
+      end
+
+      def create_archive_links
+        content = %Q{<section class="archive_title">\n<h2>Archives</h2>\n<section class="archives">\n}
+        content << monthly_archives.keys.reverse.map do |k|
+          d = build_date_from_key k
+          %Q{<a href="/#{d.year}/#{d.month}/" class="nohover">#{d.strftime "%b"} #{d.year}</a>\n}
+        end .join("\n")
+        content << %Q{</section>\n</section>\n}
+      end
+
+
+      def format_archive_for_month m, k
+          content = archive_heading "ARCHIVE FOR '<emph>#{m.strftime "%^b"} #{m.year}</emph>'"
+          content << format_post_collection(monthly_archives[k])
+      end
+
+      def archive_heading text
+        "<h1 class=\"archive\">#{text}</h1>\n<hr class=\"subtleSep\" />\n"
+      end
+  end
+end

data/test/data/formats/raw.html.erb

@@ -0,0 +1,8 @@
+<%= context.title %>
+<%= "="*context.title.length %>
+Type: <%= context.type %>
+Published: <%= context.published %>
+Tags: <%= context.tags.join ', ' %>
+Summary: <%= context.summary %>
+
+<%= context.content %>

data/test/lib/carmine_contraption/test_error.rb

@@ -0,0 +1,19 @@
+require_relative '../../test_helper'
+
+module CarmineContraption
+  class TestError < Test::Unit::TestCase
+    context "Error Hierarchy" do
+      should "be subclasssed from standard error" do
+        assert Error.ancestors.include? StandardError
+      end
+
+      should "be namespaced" do
+        assert Error.name.include? "::"
+      end
+
+      should "have CarmineContraption namespace" do
+        assert_equal Error.name.to_s.split("::").first, "CarmineContraption"
+      end
+    end
+  end
+end

data/test/lib/carmine_contraption/test_formatter.rb

@@ -0,0 +1,59 @@
+require_relative '../../test_helper'
+
+module CarmineContraption
+  class TestFormatter < Test::Unit::TestCase
+    context "basics" do
+      should "exist" do
+        assert_not_nil Formatter.new
+      end
+
+      should "find formats" do
+        f = Formatter.new "test/data/formats"
+        f.formats.each do |t|
+          assert [:raw].include?(t), "#{t} not expected"
+        end
+        assert_equal 1, f.formats.size
+      end
+    end
+
+    context "format method" do
+      setup do
+        @f = Formatter.new "test/data/formats"
+        path = 'test/data/posts/20121209-test.md'
+        @post = Post.from_file(path)
+        @post_content = IO.read(path)
+      end
+
+      should "raise error about missing format" do
+        assert_raise MissingFormat do
+          @f.format @post, :a
+        end
+      end
+
+      should "not raise error when given valid format" do
+        assert_nothing_raised MissingFormat do
+          @f.format @post, :raw
+        end
+      end
+
+      should "return formatted post" do
+        expected =  "Testing... Testing...\n\n"
+        expected << "======================\n"
+        expected << "Type: Article\n\n"
+        expected << "Published: 2012-12-09T19:37:58-05:00\n"
+        expected << "Tags: test\n"
+        expected << "Summary: Testing.\n\n\n"
+        expected << "Testing whether the markdown support works.\n\n\n\n"
+        expected << "Code sample\n\n"
+        expected << "    #include<iostream>\n\n\n\n"
+        expected << "    int main(){\n\n"
+        expected << "    std::cout << \"Hello World.\\n\";\n\n"
+        expected << "    return 0;\n\n"
+        expected << "    }\n\n\n\n"
+        expected << "Some __bold text__.\n\n"
+        assert_equal expected, @f.format(@post, :raw)
+      end
+    end
+
+  end
+end

data/test/lib/carmine_contraption/test_index.rb

@@ -0,0 +1,4 @@
+require_relative '../../test_helper'
+
+class TestIndex < Test::Unit::TestCase
+end

data/test/{test_media.rb → lib/carmine_contraption/test_media.rb}

@@ -1,6 +1,4 @@
-require 'test/unit'
-require 'shoulda'
-require_relative '../lib/carmine_contraption/media'
+require_relative '../../test_helper'
 
 module CarmineContraption
   class TestMedia < Test::Unit::TestCase

data/test/{test_options.rb → lib/carmine_contraption/test_options.rb}

@@ -1,7 +1,4 @@
-require 'test/unit'
-require 'shoulda'
-require 'pathname'
-require_relative '../lib/carmine_contraption/options'
+require_relative '../../test_helper'
 
 class TestOptions < Test::Unit::TestCase