mill 0.1

data/lib/mill/file_types.rb

@@ -0,0 +1,30 @@
+class Mill
+
+  FileTypes = {
+    text: %w{
+      text/plain
+      text/html
+    },
+    image: %w{
+      image/gif
+      image/jpeg
+      image/png
+      image/tiff
+      image/vnd.microsoft.icon
+      image/x-icon
+    },
+    generic: %w{
+      text/css
+      application/font-sfnt
+      application/x-font-opentype
+      application/x-font-otf
+      application/x-font-truetype
+      application/x-font-ttf
+      application/javascript
+      application/x-javascript
+      text/javascript
+      application/pdf
+    },
+  }
+
+end

data/lib/mill/html_helpers.rb

@@ -0,0 +1,166 @@
+module HTMLHelpers
+
+  class HTMLError < Exception; end
+
+  IgnoreErrors = %Q{
+    <table> lacks "summary" attribute
+    <img> lacks "alt" attribute
+    <form> proprietary attribute "novalidate"
+    <input> attribute "type" has invalid value "email"
+    <input> attribute "tabindex" has invalid value "-1"
+  }.split(/\n/).map(&:strip)
+
+  def html_document(&block)
+    builder = Nokogiri::HTML::Builder.new(encoding: 'utf-8') do |doc|
+      yield(doc)
+    end
+    builder.doc
+  end
+
+  def html_fragment(&block)
+    html = Nokogiri::HTML::DocumentFragment.parse('')
+    Nokogiri::HTML::Builder.with(html) do |html|
+      yield(html)
+    end
+    html
+  end
+
+  def parse_html(str)
+    html = Nokogiri::HTML::Document.parse(str) { |config| config.strict }
+    html.errors.each do |error|
+      next if error.message =~ /^Tag (.*?) invalid$/
+      raise HTMLError, "HTML error at line #{error.line}, column #{error.column}: #{error.message}"
+    end
+    html
+  end
+
+  def tidy_html(html, &block)
+    html_str = html.to_s
+    tidy = TidyFFI::Tidy.new(html_str, char_encoding: 'UTF8')
+    errors = parse_tidy_errors(tidy).reject do |error|
+      IgnoreErrors.include?(error[:error])
+    end
+    unless errors.empty?
+      full_error = StringIO.new('')
+      full_error.puts "invalid HTML:"
+      html_lines = html_str.split(/\n/)
+      errors.each do |error|
+        full_error.puts "\t#{error[:msg]}:"
+        html_lines.each_with_index do |html_line, i|
+          if i >= [0, error[:line] - 2].max && i <= [error[:line] + 2, html_lines.length].min
+            if i == error[:line]
+              output = [
+                error[:column] > 0 ? (html_line[0 .. error[:column] - 1]) : '',
+                Term::ANSIColor.negative,
+                html_line[error[:column]],
+                Term::ANSIColor.clear,
+                html_line[error[:column] + 1 .. -1],
+              ]
+            else
+              output = [html_line]
+            end
+            full_error.puts "\t\t%3s: %s" % [i + 1, output.join]
+          end
+        end
+        if block_given?
+          yield(full_error.string)
+        else
+          STDERR.print(full_error.string)
+        end
+        raise HTMLError, "HTML error: #{error[:msg]}" if error[:type] == :error
+      end
+    end
+  end
+
+  def parse_tidy_errors(tidy)
+    return [] unless tidy.errors
+    tidy.errors.split(/\n/).map do |error_str|
+      error_str =~ /^line (\d+) column (\d+) - (.*?): (.*)$/ or raise "Can't parse error: #{error_str}"
+      {
+        msg: error_str,
+        line: $1.to_i - 1,
+        column: $2.to_i - 1,
+        type: $3.downcase.to_sym,
+        error: $4.strip,
+      }
+    end
+  end
+
+  def replace_element(html, xpath, &block)
+    html.xpath(xpath).each do |elem|
+      elem.replace(yield(elem))
+    end
+  end
+
+  def amazon_button(asin)
+    html_fragment do |html|
+      html.a(href: "http://www.amazon.com/dp/#{asin}") do
+        html.img(src: '/images/buy1._V46787834_.gif', alt: 'Buy from Amazon.com')
+      end
+    end
+  end
+
+  def paypal_button(id)
+    html_fragment do |html|
+      html.form(action: 'https://www.paypal.com/cgi-bin/webscr', method: 'post') do
+        html.input(
+          type: 'hidden',
+          name: 'cmd',
+          value: '_s-xclick')
+        html.input(
+          type: 'hidden',
+          name: 'hosted_button_id',
+          value: id)
+        html.input(
+          type: 'image',
+          src: 'https://www.paypalobjects.com/en_US/i/btn/btn_buynow_LG.gif',
+          name: 'submit',
+          alt: 'PayPal - The safer, easier way to pay online!')
+        html.img(
+          alt: '',
+          border: 0,
+          width: 1,
+          height: 1,
+          src: 'https://www.paypalobjects.com/en_US/i/scr/pixel.gif')
+      end
+    end
+  end
+
+  def google_analytics(tracker_id)
+    html_fragment do |html|
+      html.script(type: 'text/javascript') do
+        html << %Q{
+          var gaJsHost = (("https:" == document.location.protocol) ? "https://ssl." : "http://www.");
+          document.write(unescape("%3Cscript src='" + gaJsHost + "google-analytics.com/ga.js' type='text/javascript'%3E%3C/script%3E"));
+        }
+      end
+      html.script(type: 'text/javascript') do
+        html << %Q{
+          try {
+            var pageTracker = _gat._getTracker("#{tracker_id}");
+            pageTracker._trackPageview();
+          } catch(err) {}
+        }
+      end
+    end
+  end
+
+  class PreText < String
+
+    def to_html
+      html_fragment do |html|
+        html.pre(self)
+      end
+    end
+
+  end
+
+  class ::String
+
+    def to_html
+      Nokogiri::HTML::DocumentFragment.parse(RubyPants.new(self).to_html).to_html
+    end
+
+  end
+
+end

data/lib/mill/navigator.rb

@@ -0,0 +1,84 @@
+class Mill
+
+  class Navigator
+
+    class Item
+
+      attr_accessor :uri
+      attr_accessor :title
+
+      def initialize(params={})
+        params.each { |k, v| send("#{k}=", v) }
+      end
+
+      def uri=(uri)
+        @uri = Addressable::URI.parse(uri)
+      end
+
+    end
+
+    attr_accessor :items
+
+    def initialize(params={})
+      @items = []
+      params.each { |k, v| send("#{k}=", v) }
+    end
+
+    def item_states_for_uri(uri, &block)
+      current_item = within_item = nil
+      if (item = @items.find { |item| item.uri.relative? && item.uri == uri })
+        current_item = item
+      else
+        within_item = @items.select do |item|
+          item.uri.relative? && uri.path.start_with?(item.uri.path)
+        end.sort_by do |item|
+          item.uri.path.count('/')
+        end.last
+      end
+      @items.each do |item|
+        if item == current_item
+          state = :current
+        elsif item == within_item
+          state = :within
+        else
+          state = :other
+        end
+        yield(item, state)
+      end
+    end
+
+    def first_item
+      @items.first
+    end
+
+    def last_item
+      @items.last
+    end
+
+    def previous_item(uri)
+      index = find_item_index_by_uri(uri)
+      if index && index > 0
+        @items[index - 1]
+      else
+        nil
+      end
+    end
+
+    def next_item(uri)
+      index = find_item_index_by_uri(uri)
+      if index && index < @items.length - 1
+        @items[index + 1]
+      else
+        nil
+      end
+    end
+
+    def find_item_index_by_uri(uri)
+      if (item = @items.find { |item| item.uri == uri })
+        @items.index(item)
+      end
+    end
+
+  end
+
+end

data/lib/mill/resource.rb

@@ -0,0 +1,116 @@
+class Mill
+
+  class Resource
+
+    attr_accessor :input_file
+    attr_accessor :output_file
+    attr_accessor :date
+    attr_accessor :public
+    attr_accessor :content
+    attr_accessor :mill
+
+    def self.type
+      # implemented by subclass
+    end
+
+    def initialize(params={})
+      params.each { |k, v| send("#{k}=", v) }
+    end
+
+    def input_file=(p)
+      @input_file = Path.new(p)
+    end
+
+    def output_file=(p)
+      @output_file = Path.new(p)
+    end
+
+    def date=(x)
+      @date = case x
+      when String
+        DateTime.parse(x)
+      when Time
+        DateTime.parse(x.to_s)
+      when Date, DateTime
+        x
+      else
+        raise "Can't assign date: #{x.inspect}"
+      end
+    end
+
+    def public=(x)
+      @public = case x
+      when 'false', FalseClass
+        false
+      when 'true', TrueClass
+        true
+      else
+        raise "Can't assign public: #{x.inspect}"
+      end
+    end
+
+    def uri
+      raise "#{@input_file}: No output file defined for #{self.class}" unless @output_file
+      path = '/' + @output_file.relative_to(@mill.output_dir).to_s
+      path.sub!(%r{/index\.html$}, '/')
+      path.sub!(%r{\.html$}, '') if @mill.shorten_uris
+      Addressable::URI.parse(path)
+    end
+
+    def absolute_uri
+      @mill.site_uri + uri
+    end
+
+    def tag_uri
+      @mill.tag_uri + uri
+    end
+
+    def change_frequency
+      :weekly
+    end
+
+    def final_content
+      @content
+    end
+
+    def load
+      raise "#{uri} (#{self.class}): no content" unless @input_file || @content
+      self.date ||= @input_file ? @input_file.mtime : DateTime.now
+      @mill.update_resource(self)
+    end
+
+    def build
+      @output_file.dirname.mkpath
+      if (c = final_content)
+        # ;;warn "#{uri}: writing #{@input_file} to #{@output_file}"
+        @output_file.write(c.to_s)
+        @output_file.utime(@date.to_time, @date.to_time)
+      elsif @input_file
+        # ;;warn "#{uri}: copying #{@input_file} to #{@output_file}"
+        @input_file.copy(@output_file)
+      else
+        raise "Can't build resource without content or input file: #{uri}"
+      end
+      validate
+    end
+
+    def validate
+      if (schema = @mill.schema_for_type(self.class.type))
+        validate_xml(schema)
+      end
+    end
+
+    def validate_xml(schema)
+      doc = Nokogiri::XML::Document.parse(@output_file.open)
+      errors = doc.errors + schema.validate(doc)
+      unless errors.empty?
+        errors.each do |error|
+          warn "[#{error.file}:#{error.line}:#{error.column}] #{error}"
+        end
+        raise "#{uri}: Validation failed"
+      end
+    end
+
+  end
+
+end

data/lib/mill/resources/feed.rb

@@ -0,0 +1,63 @@
+# see http://www.sitemaps.org/protocol.php
+
+class Mill
+
+  class Resource
+
+    class Feed < Resource
+
+      include HTMLHelpers
+
+      def self.type
+        :feed
+      end
+
+      def load
+        resources = @mill.public_resources.sort_by(&:date)
+        builder = Nokogiri::XML::Builder.new do |xml|
+          xml.feed(xmlns: 'http://www.w3.org/2005/Atom') do
+            xml.id(@mill.tag_uri)
+            xml.generator(*@mill.feed_generator)
+            xml.title(@mill.site_title)
+            xml.link(rel: 'alternate', type: 'text/html',             href: @mill.home_resource.uri)
+            xml.link(rel: 'self',      type: 'application/atom+xml',  href: uri)
+            xml.author do
+              xml.name(@mill.feed_author_name)
+              xml.uri(@mill.feed_author_uri)
+              xml.email(@mill.feed_author_email)
+            end
+            xml.updated(resources.last.date.iso8601)
+            resources.each do |resource|
+              xml.entry do
+                xml.title(resource.title) if resource.title
+                xml.link(rel: 'alternate', href: resource.uri)
+                xml.id(resource.tag_uri)
+                xml.updated(resource.date.iso8601)
+                xml.published(resource.date.iso8601)
+                if (resource.respond_to?(:feed_summary))
+                  type, data = resource.feed_summary
+                  xml.summary(type: type) { xml.cdata(data) } if type && data
+                end
+                if (resource.respond_to?(:feed_content))
+                  type, data = resource.feed_content
+                  xml.content(type: type) { xml.cdata(data) }
+                end
+              end
+            end
+          end
+        end
+        @content = builder.doc
+        super
+      end
+
+      def link_html
+        html_fragment do |html|
+          html.link(href: uri, rel: 'alternate', type: 'application/atom+xml')
+        end
+      end
+
+    end
+
+  end
+
+end