clayoven 0.1 → 0.2

data/bin/clayoven

@@ -6,12 +6,12 @@ require 'clayoven'
 
 case ARGV[0]
 when "httpd"
-  Httpd.start
+  Clayoven::Httpd.start
 when "imapd"
   while 1
-    mails = Imapd.poll
+    mails = Clayoven::Imapd.poll
     if not mails.empty?
-      Core.main
+      Clayoven.main
       mails.each { |mail|
         `git add .`
         puts `git commit -a -m "#{mail.filename}: new post\n\n#{mail.date}\n#{mail.msgid}"`
@@ -20,5 +20,5 @@ when "imapd"
     sleep 1800
   end
 else
-  Core.main
+  Clayoven.main
 end

data/lib/clayoven.rb

@@ -6,6 +6,9 @@ require 'clayoven/claytext'
 require 'clayoven/httpd'
 require 'clayoven/imapd'
 
+# Figures out the timestamp of the commit that introduced a specific
+# file.  If the file hasn't been checked into git yet, return the
+# current time.
 def when_introduced(filename)
   timestamp = `git log --reverse --pretty="%at" #{filename} 2>/dev/null | head -n 1`.strip
   if timestamp == ""
@@ -15,20 +18,23 @@ def when_introduced(filename)
   end
 end
 
-module Core
+module Clayoven
   class Page
     attr_accessor :filename, :permalink, :timestamp, :title, :topic, :body,
     :paragraphs, :target, :indexfill, :topics
 
+    # Writes out HTML pages.  Takes a list of topics to render
+    #
+    # Prints a "[GEN]" line for every file it writes out.
     def render(topics)
       @topics = topics
       @paragraphs = ClayText.process! @body
       Slim::Engine.set_default_options pretty: true, sort_attrs: false
       rendered = Slim::Template.new { IO.read("design/template.slim") }.render(self)
-      File.open(@target, mode="w") { |targetio|
+      File.open(@target, mode="w") do |targetio|
         nbytes = targetio.write(rendered)
         puts "[GEN] #{@target} (#{nbytes} bytes out)"
-      }
+      end
     end
   end
 
@@ -59,47 +65,50 @@ module Core
   end
 
   def self.main
-    if not File.exists? "index"
-      puts "error: index file not found; aborting"
-      exit 1
-    end
+    abort "error: index file not found; aborting" if not File.exists? "index"
 
-    config = ConfigData.new
+    config = Clayoven::ConfigData.new
     all_files = (Dir.entries(".") -
-                 [".", "..", ".clayoven", "design"]).reject { |entry|
+                 [".", "..", ".clayoven", "design"]).reject do |entry|
       config.ignore.any? { |pattern| %r{#{pattern}} =~ entry }
-    }
+    end
 
+    # We must have a "design" directory.  I don't plan on making this
+    # a configuration variable.
     if not Dir.entries("design").include? "template.slim"
-      puts "error: design/template.slim file not found; aborting"
-      exit 1
+      abort "error: design/template.slim file not found; aborting"
     end
 
+    # index_files are files ending in ".index" and "index"
+    # content_files are all other files (we've already applied ignore)
+    # topics is the list of topics.  We need it for the sidebar
     index_files = ["index"] + all_files.select { |file| /\.index$/ =~ file }
     content_files = all_files - index_files
-    topics = index_files.map { |file| file.split(".index")[0] }.uniq
+    topics = index_files.map { |file| file.split(".index")[0] }
 
-    # Next, look for stray files
+    # Look for stray files.  All content_files that don't have a valid
+    # topic before ":" (or don't have ";" in their filename at all)
     (content_files.reject { |file| topics.include? (file.split(":", 2)[0]) })
-      .each { |stray_entry|
+      .each do |stray_entry|
       content_files = content_files - [stray_entry]
       puts "warning: #{stray_entry} is a stray file or directory; ignored"
-    }
+    end
 
+    # Turn index_files and content_files into objects
     index_pages = index_files.map { |filename| IndexPage.new(filename) }
     content_pages = content_files.map { |filename| ContentPage.new(filename) }
 
-    # First, fill in all the page attributes
-    (index_pages + content_pages).each { |page|
+    # Fill in page.title and page.body by reading the file
+    (index_pages + content_pages).each do |page|
       page.title, page.body = (IO.read page.filename).split("\n\n", 2)
-    }
+    end
 
     # Compute the indexfill for indexes
-    topics.each { |topic|
+    topics.each do |topic|
       topic_index = index_pages.select { |page| page.topic == topic }[0]
       topic_index.indexfill = content_pages.select { |page|
         page.topic == topic }.sort { |a, b| b.timestamp <=> a.timestamp }
-    }
+    end
 
     (index_pages + content_pages).each { |page| page.render topics }
   end

data/lib/clayoven/claytext.rb

@@ -1,80 +1,109 @@
-class Paragraph
-  attr_accessor :content, :first, :type
+module ClayText
 
-  def initialize(content)
-    @content = content
-    @first = false
-    @type = :plain
-  end
+  # These are the values that Paragraph.type can take
+  PARAGRAPH_TYPES = [:plain, :emailquote, :codeblock, :header, :footer]
 
-  def is_first?
-    @first
-  end
-end
+  # see: http://php.net/manual/en/function.htmlspecialchars.php
+  HTMLESCAPE_RULES = {
+    "&" => "&",
+    "\"" => """,
+    "'" => "'",
+    "<" => "&lt;",
+    ">" => "&gt;"
+  }
 
-module ClayText
-  def self.mark_emailquote!(paragraph)
-    paragraph.type = :emailquote
-  end
+  # Key is used to match a paragraph, and value is the lambda
+  # that'll act on it.
+  PARAGRAPH_RULES = {
 
-  def self.mark_codeblock!(paragraph)
-    paragraph.type = :codeblock
-  end
+    # If all the lines in a paragraph, begin with "> ", the
+    # paragraph is marked as an :emailquote.
+    Proc.new { |line| line.start_with? "&gt; " } => lambda { |paragraph|
+      paragraph.type = :emailquote },
+
+    # If all the lines in a paragraph, begin with "   ", the paragraph is
+    # marked as an :coeblock
+    Proc.new { |line| line.start_with? "    " } => lambda { |paragraph|
+      paragraph.type = :codeblock },
+
+    # If all the lines in a paragraph, begin with " ", the paragraph
+    # is marked as :footer.  Also, a regex substitution runs on each
+    # line turning every link like http://a-url-over-67-characters
+    # to <a href="http://google.com">64-characters-of-the-li...</a>
+    Proc.new { |line| /^\[\d+\]: / =~ line } => lambda do |paragraph|
+      paragraph.type = :footer
+      paragraph.content.gsub!(%r{^(\[\d+\]:) (.*://(.*))}) do
+        "#{$1} <a href=\"#{$2}\">#{$3[0, 64]}#{%{...} if $3.length > 67}</a>"
+      end
+    end
+  }
 
-  def self.anchor_footerlinks!(paragraph)
-    paragraph.content.gsub!(%r{^(\[\d+\]:) (.*://(.*))}) {
-      "#{$1} <a href=\"#{$2}\">#{$3[0, 64]}#{%{...} if $3.length > 67}</a>"
-    }
-    paragraph.type = :footer
+  # A paragraph of text
+  #
+  # :content contains its content
+  # :fist asserts whether it's the first paragraph in the body
+  # :type can be one of PARAGRAPH_TYPES
+  class Paragraph
+    attr_accessor :content, :first, :type
+
+    def initialize(content)
+      @content = content
+      @first = false
+      @type = :plain
+
+      # Generate is_*? methods for PARAGRAPH_TYPES
+      Paragraph.class_eval do
+        ClayText::PARAGRAPH_TYPES.each do |type|
+          define_method("is_#{type.to_s}?") { @type == type }
+        end
+      end
+    end
+
+    def is_first?
+      @first
+    end
   end
 
+  # Takes a body of claytext, breaks it up into paragraphs, and
+  # applies various rules on it.
+  #
+  # Returns a list of Paragraphs
   def self.process!(body)
-    htmlescape_rules = {
-      "&" => "&amp;",
-      "\"" => "&quot;",
-      "'" => "&#39;",
-      "<" => "&lt;",
-      ">" => "&gt;"
-    }.freeze
-
-    paragraph_types = [:plain, :emailquote, :codeblock, :header, :footer]
-    paragraph_rules = {
-      Proc.new { |line| line.start_with? "&gt; " } => method(:mark_emailquote!),
-      Proc.new { |line| line.start_with? "    " } => method(:mark_codeblock!),
-      Proc.new { |line| /^\[\d+\]: / =~ line } => method(:anchor_footerlinks!)
-    }.freeze
 
     # First, htmlescape the body text
-    body.gsub!(/[&"'<>]/, htmlescape_rules)
+    body.gsub!(/[&"'<>]/, ClayText::HTMLESCAPE_RULES)
 
+    # Split the body into Paragraphs
     paragraphs = []
-    body.split("\n\n").each { |content|
+    body.split("\n\n").each do |content|
       paragraphs << Paragraph.new(content)
-    }
+    end
 
+    # Special matching for the first paragraph.  This paragraph will
+    # be marked header:
+    #
+    # (This is a really long first paragraph blah-blah-blah-blah-blah
+    # that spans to two lines)
     paragraphs[0].first = true
     if paragraphs[0].content.start_with? "(" and
         paragraphs[0].content.end_with? ")"
       paragraphs[0].type = :header
     end
 
-    # Paragraph-level processing
-    paragraphs.each { |paragraph|
-      paragraph_rules.each { |proc_match, callback|
+    # Apply the PARAGRAPH_RULES on all the paragraphs
+    paragraphs.each do |paragraph|
+      ClayText::PARAGRAPH_RULES.each do |proc_match, lambda_cb|
         if paragraph.content.lines.all? &proc_match
-          callback.call paragraph
+          lambda_cb.call paragraph
         end
-      }
-    }
-
-    # Generate is_*? methods for Paragraph
-    Paragraph.class_eval {
-      paragraph_types.each { |type|
-        define_method("is_#{type.to_s}?") { @type == type }
-      }
-    }
+      end
+    end
 
+    # body is the useless version.  If someone is too lazy to use all
+    # the paragraphs individually in their template, they can just use
+    # this.
     body = paragraphs.map(&:content).join("\n\n")
+    
     paragraphs
   end
 end

data/lib/clayoven/config.rb

@@ -1,24 +1,39 @@
 require 'yaml'
 
-class ConfigData
-  attr_accessor :rootpath, :rcpath, :ignorepath, :rc, :ignore
+module Clayoven
+  class ConfigData
+    attr_accessor :rootpath, :rcpath, :ignorepath, :rc, :ignore
 
-  def initialize
-    @rootpath = ".clayoven"
-    @rcpath = File.expand_path "~/.clayovenrc"
-    @ignorepath = "#{rootpath}/ignore"
-    @ignore = ["\\.html$", "~$", "^.\#", "^\#.*\#$",
-               "^\\.git$", "^\\.gitignore$", "^\\.htaccess$"]
-    @rc = nil
+    def initialize
+      @rootpath = ".clayoven"
+      Dir.mkdir @rootpath if not Dir.exists? @rootpath
 
-    Dir.mkdir @rootpath if not Dir.exists? @rootpath
-    if File.exists? @ignorepath
-      @ignore = IO.read(@ignorepath).split("\n")
-    else
-      File.open(@ignorepath, "w") { |ignoreio|
-        ignoreio.write @ignore.join("\n") }
-      puts "[NOTE] #{@ignorepath} populated with sane defaults"
+      initialize_ignore
+      initialize_rc
+    end
+
+    def initialize_ignore
+      @ignorepath = "#{rootpath}/ignore"
+
+      # Most common patterns that should sit in .clayoven/ignore.
+      # Written to the file when it doesn't exist.
+      @ignore = ["\\.html$", "~$", "^.\#", "^\#.*\#$",
+                 "^\\.git$", "^\\.gitignore$", "^\\.htaccess$"]
+
+      if File.exists? @ignorepath
+        @ignore = IO.read(@ignorepath).split("\n")
+      else
+        File.open(@ignorepath, "w") do |ignoreio|
+          ignoreio.write @ignore.join("\n")
+        end
+        puts "[NOTE] #{@ignorepath} populated with sane defaults"
+      end
+    end
+
+    def initialize_rc
+      @rcpath = File.expand_path "~/.clayovenrc"
+      @rc = nil
+      @rc = YAML.load_file @rcpath if File.exists? @rcpath
     end
-    @rc = YAML.load_file @rcpath if File.exists? @rcpath
   end
 end

data/lib/clayoven/httpd.rb

@@ -1,24 +1,31 @@
 require 'webrick'
 
-module Httpd
-  def self.start
-    port = 8000
-    callback = Proc.new { |req, res|
-      if %r{^/$} =~ req.path_info
-        res.set_redirect WEBrick::HTTPStatus::Found, "index.html"
-      end
-      if %r{^/([^.]*)$} =~ req.path_info
-        res.set_redirect WEBrick::HTTPStatus::Found, "#{$1}.html"
+module Clayoven
+  module Httpd
+    def self.start
+      port = 8000
+      callback = Proc.new do |req, res|
+
+        # A couple of URL rewriting rules.  Not real URL rewriting
+        # like .htaccess; just a HTTP redirect. / is rewritten to
+        # index.html, and anything-without-a-period is rewritten to
+        # that-thing.html.
+        if %r{^/$} =~ req.path_info
+          res.set_redirect WEBrick::HTTPStatus::Found, "index.html"
+        end
+        if %r{^/([^.]*)$} =~ req.path_info
+          res.set_redirect WEBrick::HTTPStatus::Found, "#{$1}.html"
+        end
       end
-    }
 
-    server = WEBrick::HTTPServer.new(:Port            => port,
-                                     :RequestCallback => callback,
-                                     :DocumentRoot    => Dir.pwd)
+      server = WEBrick::HTTPServer.new(:Port            => port,
+                                       :RequestCallback => callback,
+                                       :DocumentRoot    => Dir.pwd)
 
-    puts "clayoven serving at: http://localhost:#{port}"
+      puts "clayoven serving at: http://localhost:#{port}"
 
-    trap(:INT) { server.shutdown }
-    server.start
+      trap(:INT) { server.shutdown }
+      server.start
+    end
   end
 end

data/lib/clayoven/imapd.rb

@@ -1,46 +1,44 @@
 require 'net/imap'
 require_relative 'config'
 
-class Mail
-  attr_accessor :filename, :date, :msgid
+module Clayoven
+  # `clayoven impad` essentially calls Imapd.poll
+  # (but also calls Clayoven.main)
+  module Imapd
+    # Initialites a connection to the IMAP server, and fetches new
+    # messages.
+    #
+    # Returns an unnamed Struct with :filename, :date, :msgid fields
+    def self.poll
+      config = Clayoven::ConfigData.new
+      abort "error: #{config.rcpath} not found; aborting" if not config.rc
+      mails = []
+      server = Net::IMAP.new(config.rc["server"],
+                             {:port => config.rc["port"], :ssl => config.rc["ssl"]})
+      trap(:INT) { exit 1 }
+      server.login config.rc["username"], config.rc["password"]
+      puts "[NOTE] LOGIN successful"
+      server.examine "INBOX"
+      server.search(["ALL"]).each do |id|
+        message = server.fetch(id, ["ENVELOPE", "RFC822.TEXT"])[0]
 
-  def initialize(filename, date, msgid)
-    @filename = filename
-    @date = date
-    @msgid = msgid
-  end
-end
-
-module Imapd
-  def self.poll
-    config = ConfigData.new
-    if not config.rc
-      puts "error: #{config.rcpath} not found; aborting"
-      exit 1
-    end
-    mails = []
-    server = Net::IMAP.new(config.rc["server"],
-                           {:port => config.rc["port"], :ssl => config.rc["ssl"]})
-    trap(:INT) { exit 1 }
-    server.login config.rc["username"], config.rc["password"]
-    puts "[NOTE] LOGIN successful"
-    server.examine "INBOX"
-    server.search(["ALL"]).each { |id|
-      message = server.fetch(id, ["ENVELOPE", "RFC822.TEXT"])[0]
-      if message.attr["ENVELOPE"].sender[0].mailbox == "artagnon" and
-          message.attr["ENVELOPE"].sender[0].host == "gmail.com" and
-          message.attr["ENVELOPE"].sender[0].name == "Ramkumar Ramachandra"
-        date = message.attr["ENVELOPE"].date
-        msgid = message.attr["ENVELOPE"].message_id
-        title, filename = message.attr["ENVELOPE"].subject.split(" # ")
-        next if File.exists? filename
-        File.open(filename, "w") { |targetio|
-          targetio.write([title, message.attr["RFC822.TEXT"].delete("\r")].join "\n\n")
-        }
-        mails << Mail.new(filename, date, msgid)
+        # This block is only run if we receive email from the trusted
+        # sender (a configuration variable).
+        trustmailbox, trusthost = config.rc["trustfrom"].split("@")
+        if message.attr["ENVELOPE"].sender[0].mailbox == trustmailbox and
+            message.attr["ENVELOPE"].sender[0].host == trusthost
+          date = message.attr["ENVELOPE"].date
+          msgid = message.attr["ENVELOPE"].message_id
+          title, filename = message.attr["ENVELOPE"].subject.split(" # ")
+          next if File.exists? filename
+          File.open(filename, "w") do |targetio|
+            targetio.write([title, message.attr["RFC822.TEXT"].delete("\r")].join "\n\n")
+          end
+          mails << Struct.new(:filename, :date, :msgid).new(filename, date, msgid)
+        end
       end
-    }
-    server.disconnect
-    mails
+      server.disconnect
+      mails
+    end
   end
 end

metadata

@@ -1,7 +1,7 @@
 --- !ruby/object:Gem::Specification
 name: clayoven
 version: !ruby/object:Gem::Version
-  version: '0.1'
+  version: '0.2'
   prerelease: 
 platform: ruby
 authors: