Rules

#!/usr/bin/env ruby

# A few helpful tips about the Rules file:
#
# * The order of rules is important: for each item, only the first matching
#   rule is applied.
#
# * Item identifiers start and end with a slash (e.g. “/about/” for the file
#   “content/about.html”). To select all children, grandchildren, … of an
#   item, use the pattern “/about/*/”; “/about/*” will also select the parent,
#   because “*” matches zero or more characters.

require "cgi"
require "uri"
require "curb"
require "json"

class Nanoc3::Filter
  class Peek < Nanoc3::Filter
    identifier :peek
    def run(content, params={})
      puts "#{content.length} bytes of content."
      content
    end
  end

  class NoSlides < Nanoc3::Filter
    identifier :noslides
    def run(content, params={})
      @output = content.dup.gsub(/^.*§.*$/,'');
      @output
    end
  end

  class SlideBreaks < Nanoc3::Filter
    identifier :slide_breaks
    def run(content, params={})
      @string = content.dup

      @pending = ""
      @output = "<a name='slide-1'></a>"
      i = 2

      until @string.empty?
        match = scan_until /^(<h[123].*?>|<hr>+|^(<p>)*§(<.p>)*)$/m

        break if !match

        @output << match.pre_match

        @output << "\n<a class='slide_break' name='slide-#{i}' href='slide.html#slide-#{i}'>▻</a>\n\n"
        i += 1
        if match[0] =~ /§/ then
          # discard match
        else 
          @output << match[0]
        end
      end # untile @string.empty?

      @output << @string
      @output << ""

      @output
    end

    def scan_until(regex)
      match = @string.match(regex)
      return unless match
      @string = match.post_match
      match
    end
  end


  class Slides < Nanoc3::Filter
    identifier :slides
    def run(content, params={})
      @string = content.dup

      @output = "<div class='slide'>"
      @pending = ""

      until @string.empty?
        match = scan_until /^(<h[123].*?>|<hr>+|^(<p>)*§(<.p>)*)$/m

        break if !match

        @output << match.pre_match

        @output << "</div>\n<div class='slide'>\n\n"
        if match[0] =~ /§/ then
          #puts "ignore #{match[0]}"
          # discard match
        else 
          @output << match[0]
        end
      end

      @output << @string
      @output << "</div>"

      @output
    end

    def scan_until(regex)
      match = @string.match(regex)
      return unless match
      @string = match.post_match
      match
    end
  end



  class PatternTester < Nanoc3::Filter
    identifier :pattern_tester

    def run(content, params={})
      @string = content.dup

      @output = ""
      @pending = ""

      until @string.empty?
        match = scan_until /(<patterntester(?: name="(.*?)")?(?: pattern="(.*?)")?>|\z)/m

        @pending << match.pre_match
        flush
        replace_with_link match[2], match[3]
      end
      flush

      @output
    end

    def scan_until(regex)
      match = @string.match(regex)
      return unless match
      @string = match.post_match
      match
    end

    def replace_with_link(name, pattern)
      match = scan_until %r{</patterntester>}
      if match and match.pre_match then
        data = match.pre_match;
        data_params = data.split(/\n/).map{|d| "list[]=#{d}" }.join("&")
        out = "<a href='/images/match.html?pattern=#{URI.escape(pattern).gsub(/\+/, '%2B')}&listname=#{URI.escape name}&#{URI.escape data_params}'>RegEx Tester: /#{CGI.escapeHTML(pattern).gsub(/\|/, "&#124;")}/</a>"
        @output << out
      end
    end

    def flush
      @output << @pending
      @pending = ""
    end
  end


  class CodeBlocks < Nanoc3::Filter
    identifier :code_blocks
    LANGUAGES = { "ruby" => "ruby", "sql" => "sql", "javascript" => "javascript", "php" => "php",
                  "css" => "css", "plain" => "plain", "erb" => "ruby; html-script: true", "htmlcode" => "html",
                  "markup" => "xml", "xml" => "xml", "shell" => "shell", "yaml" => "yaml", "dtd"=> "html", "apache" => "ruby" }

    def run(content, params={})
      @string = content.dup

      @output = ""
      @pending = ""

      languages = LANGUAGES.keys.join("|")

      until @string.empty?
        # match = scan_until /(\+(\S.+?\S?)\+|<(#{languages})(?: filename=["']([^"']*)["'])?(?: caption=["']([^"']*)["'])?>|\z)/m
        match = scan_until /(<(#{languages})(?: filename=["']([^"']*)["'])?(?: caption=["']([^"']*)["'])?>|\z)/m

        @pending << match.pre_match

        if match[1] # whole <language> tag
          flush
          generate_brushes match[2], LANGUAGES[match[2]], match[3], match[4]
        else
          flush
          generate_brushes 'htmlcode', LANGUAGES['htmlcode'], match[3], match[4]
        end
      end

      flush

      @output
    end

    def scan_until(regex)
      match = @string.match(regex)
      return unless match
      @string = match.post_match
      match
    end

    def generate_brushes(tag, replace, filename, caption)
      match = scan_until %r{</#{tag}>}
      if match and match.pre_match then
        code = match.pre_match;
        if code.match(/<\/javascript>/)  then
          puts "this is an ERROR!"
        elsif match = code.match(/^__\|__$/)  then
          code1 = match.pre_match
          code2 = match.post_match
          @output << %{<div class="example twopane">\n}
          @output << %{<div class="filename">#{filename}</div>\n} if filename
          @output << %{<h4 class="caption">#{replace.capitalize} Code <small>#{caption}</small></h4>\n} if caption
          @output << %{<pre class="lang-#{replace} prettyprint linenums left">} 
          @output << CGI.escapeHTML(code1) << %{</pre>}
          @output << %{<pre class="lang-#{replace} prettyprint linenums right">} 
          @output << CGI.escapeHTML(code2) << %{</pre>}
          @output << %{<div class="clearfix"></div></div>\n}
        else 
          @output << %{<div class="example">\n}
          @output << %{<div class="filename">#{filename}</div>\n} if filename
          @output << %{<h4 class="caption">#{replace.capitalize} Code <small>#{caption}</small></h4>\n} if caption
          @output << %{<pre class="lang-#{replace} prettyprint linenums">} 
          @output << CGI.escapeHTML(code) << %{</pre>}
          @output << %{</div>\n}
        end
      end
    end

    def flush
      @output << @pending
      @pending = ""
    end
  end
end

Nanoc3::Filter.register '::Nanoc3::Filter::PatternTester', :pattern_tester
Nanoc3::Filter.register '::Nanoc3::Filter::CodeBlocks',    :code_blocks
Nanoc3::Filter.register '::Nanoc3::Filter::Slides',        :slides
Nanoc3::Filter.register '::Nanoc3::Filter::NoSlides',      :noslides
Nanoc3::Filter.register '::Nanoc3::Filter::SlideBreaks',  :slide_breaks
Nanoc3::Filter.register '::Nanoc3::Filter::Peek',          :peek

preprocess do
  @chapterOrder = [
    "das-web-und-html",
    "css", 
    "css-layout", 
    "urls",
    "formulare", 
    "javascript-dom", 
    "jquery", 
    "---",
    "kommandozeile", 
    "git", 
    "http", 
    "php-vorbereitung", 
    "wordpress",
    "php",
    "php-mysql",
    "session",
    "php-mysql-2",
    "---",
    "javascript",
    "applied-javascript",
    "security",
    "xml",
    "json",
    "php-mysql-3",
    "qualitaet",
    "---",
    "apache", 
  ]

  @chapters = {}

  @github_users = {
    "bjelline" =>  nil
  }

  @items.each do |item|
    item[:chapter] = item[:filename].split('/')[1] 
    item[:chapter_title] = item[:chapter].gsub(/-/, " ").gsub(/Qualitaet/, 'Qualität')   # .upcase
    item[:github] = "bjelline"
  end

  @github_users.each do |username, wat|
    #request = Curl::Easy.http_get("https://api.github.com/users/"+username)
    #request.perform
    @github_users[ username ] = {} #JSON.parse(request.body_str)
  end


  @groupedItems = @items.group_by {|item| item[:chapter]}

  @orderedItems = []

  last_folder = 0
  @chapterOrder.each do |folder|
    if folder == "---" then 
      @chapters[ last_folder ][ :separator ] = true
    else 
      myitems = @groupedItems[ folder ]
      @chapters[ folder ] = {}
      if ! @groupedItems[folder].nil? then
        @chapters[ folder ][ :items ] = @groupedItems[folder].sort_by {|i| i.attributes[:order] || 0 }
        @orderedItems = @orderedItems + @chapters[ folder ][ :items ]
      end
      @chapters[ folder ][ :title ] = folder.gsub(/-/, " ").gsub(/Qualitaet/,"Qualität").split(' ').map {|w| w.capitalize }.join(' ')
      @chapters[ folder ][ :folder ] = folder
      if last_folder != 0 and @chapters[ last_folder ] then
        @chapters[ last_folder ][ :separator ] = false
      end
    end
    last_folder=folder
  end
  
  @items.each do |item|
    i = item[:ordinal_index] = @orderedItems.index(item)
    if i
      item[:next_item] = @orderedItems[ i+1 ]
      item[:previous_item] = @orderedItems[ i-1 ]
    end
    item[:github_user] = @github_users[ item[:github] ]
  end

  @site.config[:chapters] = @chapters
end

compile '/assets/*' do
  # don’t filter or layout
end

compile '/images/*' do
  # don’t filter or layout
end

filters = {
  :markdown => :kramdown,
  :md       => :kramdown,
  :html     => :erb
}

# Index files in each content directory
route "/*/dex" do
  item.identifier.sub("dex/", "") + 'index.html'
end

# Just the homepage
route "/dex" do
  item.identifier.sub("dex/", "") + 'index.html'
end

compile '*' do
  # filter :noslides
  filter :pattern_tester
  filter :code_blocks
  filter filters[item[:extension].to_sym] || item[:extension].to_sym
  if item[:homepage]
    layout 'home'
  elsif item.identifier.match /\/dex\/$/
    layout 'dex'
  else
    filter :slide_breaks
    layout 'default'
  end
end

route '*' do
  #p [item.identifier, item[:extension], item.binary?]
  if item.binary? || item[:extension] == 'css' || item[:extension] == 'js' || item[:extension] == 'png' || item[:extension] == 'html' || item[:extension] == 'xml'
    # /foo/ -> /foo.ext
    #p item.identifier.chop + '.' + item[:extension]
    item.identifier.chop + '.' + item[:extension]
  elsif item[:extension] == 'html'
    item.identifier.chop + '.' + item[:extension]
  else
    # /foo/ -> /foo/index.html
    item.identifier + 'index.html'
  end
end

compile '/assets/*', :rep => :slide do
  # don’t filter or layout
end

compile '/images/*', :rep => :slide  do
end

compile '*', :rep => :slide do
  filter :pattern_tester
  filter :code_blocks
  filter :kramdown
  #filter filters[item[:extension].to_sym] || item[:extension].to_sym
  filter :slides
  if item[:homepage]
  elsif item.identifier.match /\/dex\/$/
  else
    layout 'slide'
  end
end

route '*', :rep => :slide do
  if item.binary? || item[:extension] == 'css' || item[:extension] == 'js' || item[:extension] == 'png' || item[:extension] == 'xml' || item[:extension] == 'html'
    nil
  elsif item[:homepage]
    nil
  elsif item.identifier.match /\/dex\/$/
    nil
  else
    # /foo/ -> /foo/index.html
    item.identifier + 'slide.html'
  end
end

layout '*', :erb