mill 0.1 → 0.3

data/lib/mill/error.rb

@@ -0,0 +1,7 @@
+module Mill
+
+  class Error < RuntimeError
+
+  end
+
+end

data/lib/mill/html_helpers.rb

@@ -1,91 +1,59 @@
 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|
+  LinkElementsXPath = '//@href | //@src'
+
+  def html_document(type=:html4_transitional, &block)
+    doc = Nokogiri::HTML::Document.new
+    doc.encoding = 'UTF-8'
+    doc.internal_subset.remove
+    case type
+    when :html4_transitional
+      doc.create_internal_subset('html', '-//W3C//DTD HTML 4.01 Transitional//EN', 'http://www.w3.org/TR/html4/loose.dtd')
+    when :html5
+      doc.create_internal_subset('html', nil, nil)
+    else
+      raise "Unknown HTML type: #{type.inspect}"
+    end
+    Nokogiri::HTML::Builder.with(doc) do |doc|
       yield(doc)
     end
-    builder.doc
+    doc
   end
 
   def html_fragment(&block)
     html = Nokogiri::HTML::DocumentFragment.parse('')
     Nokogiri::HTML::Builder.with(html) do |html|
-      yield(html)
+      yield(html) if block_given?
     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}"
+    if str.strip.empty?
+      html = html_fragment
+    else
+      html = Nokogiri::HTML::Document.parse(str) { |config| config.strict }
+      check_errors(html)
     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
+  def parse_html_fragment(str)
+    html = Nokogiri::HTML::DocumentFragment.parse(str) { |config| config.strict }
+    check_errors(html)
+    html
   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,
-      }
+  def check_errors(html)
+    html.errors.each do |error|
+      raise Mill::Error, "HTML error #{error}" unless error.message =~ /Tag .+? invalid$/
     end
   end
 
+  def find_link_elements(html)
+    html.xpath(LinkElementsXPath)
+  end
+
   def replace_element(html, xpath, &block)
     html.xpath(xpath).each do |elem|
       elem.replace(yield(elem))
@@ -145,6 +113,15 @@ module HTMLHelpers
     end
   end
 
+  def link_if(state, html, &block)
+    elem = html_fragment { |h| yield(h) }
+    if state
+      html.a(href: uri) { html << elem.to_html }
+    else
+      html << elem.to_html
+    end
+  end
+
   class PreText < String
 
     def to_html
@@ -157,8 +134,21 @@ module HTMLHelpers
 
   class ::String
 
-    def to_html
-      Nokogiri::HTML::DocumentFragment.parse(RubyPants.new(self).to_html).to_html
+    Converters = {
+      nil => RubyPants,
+      smart_quotes: RubyPants,
+      markdown: Kramdown::Document,
+      textile: RedCloth,
+      pre: PreText,
+    }
+
+    def to_html(options={})
+      converter = Converters[options[:mode]] or raise "Unknown to_html mode: #{options[:mode].inspect}"
+      html = Nokogiri::HTML::DocumentFragment.parse(converter.new(self).to_html)
+      if !options[:multiline] && (p_elem = html.at_xpath('p'))
+        html = p_elem.children.to_html
+      end
+      html.to_html
     end
 
   end

data/lib/mill/navigator.rb

@@ -1,4 +1,4 @@
-class Mill
+module Mill
 
   class Navigator
 
@@ -7,76 +7,52 @@ class Mill
       attr_accessor :uri
       attr_accessor :title
 
-      def initialize(params={})
-        params.each { |k, v| send("#{k}=", v) }
-      end
-
-      def uri=(uri)
+      def initialize(uri:, title: nil)
         @uri = Addressable::URI.parse(uri)
+        @title = title
       end
 
     end
 
-    attr_accessor :items
-
-    def initialize(params={})
-      @items = []
-      params.each { |k, v| send("#{k}=", v) }
+    def initialize(items: [])
+      @items = Hash[
+        items.map do |uri, title|
+          item = Item.new(uri: uri, title: title)
+          [item.uri, item]
+        end
+      ]
     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
+    def items
+      @items.values
     end
 
     def first_item
-      @items.first
+      @items.values.first
     end
 
     def last_item
-      @items.last
+      @items.values.last
     end
 
     def previous_item(uri)
-      index = find_item_index_by_uri(uri)
-      if index && index > 0
-        @items[index - 1]
-      else
-        nil
+      if (item = @items[uri])
+        i = @items.values.index(item)
+        if i > 0
+          return @items.values[i - 1]
+        end
       end
+      nil
     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)
+      if (item = @items[uri])
+        i = @items.values.index(item)
+        if i < @items.length - 1
+          return @items.values[i + 1]
+        end
       end
+      nil
     end
 
   end

data/lib/mill/resource.rb

@@ -1,68 +1,103 @@
-class Mill
+module Mill
 
   class Resource
 
+    FileTypes = []
+
     attr_accessor :input_file
     attr_accessor :output_file
+    attr_accessor :type
     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)
+    attr_accessor :site
+
+    def initialize(input_file: nil,
+                   output_file: nil,
+                   type: nil,
+                   date: nil,
+                   public: false,
+                   content: nil,
+                   site: nil)
+      if input_file
+        @input_file = Path.new(input_file)
+        @date = input_file.mtime.to_datetime
+      else
+        @date = DateTime.now
+      end
+      @output_file = Path.new(output_file) if output_file
+      @type = type
+      self.date = date if date
+      self.public = public
+      @content = content
+      @site = site
     end
 
-    def date=(x)
-      @date = case x
-      when String
-        DateTime.parse(x)
-      when Time
-        DateTime.parse(x.to_s)
-      when Date, DateTime
-        x
+    def date=(date)
+      @date = case date
+      when String, Time
+        DateTime.parse(date.to_s)
+      when Date, DateTime, nil
+        date
       else
-        raise "Can't assign date: #{x.inspect}"
+        raise Error, "Can't assign 'date' attribute: #{date.inspect}"
       end
     end
 
-    def public=(x)
-      @public = case x
+    def public=(public)
+      @public = case public
       when 'false', FalseClass
         false
       when 'true', TrueClass
         true
       else
-        raise "Can't assign public: #{x.inspect}"
+        raise Error, "Can't assign 'public' attribute: #{public.inspect}"
+      end
+    end
+
+    def public?
+      @public
+    end
+
+    def inspect
+      "<%p> input_file: %p, output_file: %p, type: %p, date: %s, public: %p, content: <%p>" % [
+        self.class,
+        @input_file ? @input_file.relative_to(@site.input_dir).to_s : nil,
+        @output_file ? @output_file.relative_to(@site.output_dir).to_s : nil,
+        @type.to_s,
+        @date.to_s,
+        @public,
+        @content && @content.class,
+      ]
+    end
+
+    def find_sibling_resources(klass=nil)
+      # parent_uri = parent_uri
+      @site.resources.select do |resource|
+        resource != self &&
+          (klass.nil? || resource.kind_of?(klass)) &&
+          resource.parent_uri == parent_uri
       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
+      raise Error, "#{@input_file}: No output file defined for #{self.class}" unless @output_file
+      path = '/' + @output_file.relative_to(@site.output_dir).to_s
       path.sub!(%r{/index\.html$}, '/')
-      path.sub!(%r{\.html$}, '') if @mill.shorten_uris
-      Addressable::URI.parse(path)
+      path.sub!(%r{\.html$}, '') if @site.shorten_uris
+      Addressable::URI.encode(path, Addressable::URI)
+    end
+
+    def parent_uri
+      uri + '.'
     end
 
     def absolute_uri
-      @mill.site_uri + uri
+      @site.site_uri + uri
     end
 
     def tag_uri
-      @mill.tag_uri + uri
+      @site.tag_uri + uri
     end
 
     def change_frequency
@@ -74,40 +109,24 @@ class Mill
     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)
+      # implemented in subclass
     end
 
     def build
+      # implemented in subclass
+    end
+
+    def save
       @output_file.dirname.mkpath
-      if (c = final_content)
+      if (content = final_content)
         # ;;warn "#{uri}: writing #{@input_file} to #{@output_file}"
-        @output_file.write(c.to_s)
+        @output_file.write(content.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"
+        raise Error, "Can't build resource without content or input file: #{uri}"
       end
     end