Shamusworld >> Repos - ardour-manual-diverged/blob - _plugins/manual.rb

   1 require 'erb'
   2 require 'fileutils'
   3 require 'tmpdir'
   4 require 'pp'
   5
   6 module Manual
   7
   8   DIRECTORY_ENTRIES = {}
   9
  10   def self.traverse_data(entries, directory_sort = false, paths = [], key_paths = [], &block)
  11
  12     entries.map do |entry|
  13
  14       entry = entry.dup
  15
  16       if entry[:type] == 'directory'
  17         entry[:children] = traverse_data(entry[:children], directory_sort, paths + [entry[:name]], key_paths + [entry[:key]], &block)
  18       end
  19       block_given? ? block.call(entry) : entry
  20     end
  21   end
  22
  23   def self.traverse(path, directory_sort = false, paths = [], key_paths = [], &block)
  24
  25       entries = Dir.glob(File.join(path,'*'))
  26
  27       entries.sort_by! { |e| File.directory?(e) ? 1 : 0  } if directory_sort
  28
  29       entries.map do |entry|
  30           is_dir = File.directory?(entry)
  31
  32           data = extract_data(is_dir ? "#{entry}.html" : entry)
  33
  34           short_title = data['menu_title'] || data['title']
  35
  36           name = entry[/[^\/]+$/] # filename
  37           key = name.sub(/^[0-9]+(\-|_)/,'').sub(/\.[^\.]+$/,'') # slug
  38           my_paths = paths + [name]
  39           my_key_paths = key_paths + [key]
  40           url = '/' + my_key_paths.join('/') + '/'
  41
  42           without_extension = entry.sub(/\.[^\/\/]+$/,'')
  43
  44           h = {
  45               name: name,
  46               title: data['title'] || key,
  47               menu_title: short_title || key,
  48               key: key,
  49               filename: entry,
  50               type: is_dir ? 'directory' : 'file',
  51               url: url
  52           }
  53
  54           if is_dir
  55               h.update \
  56                   children: traverse(entry, directory_sort, my_paths, my_key_paths, &block)
  57           else
  58               h.update extension: File.extname(name), has_dir: File.directory?(without_extension)
  59           end
  60
  61           if is_dir
  62             DIRECTORY_ENTRIES[url] = h
  63           end
  64
  65           block_given? ? block.call(h) : h
  66       end.compact
  67     end
  68
  69     def self.extract_data(filename)
  70       if File.exists?(filename) and !File.directory?(filename) and first3 = File.open(filename) { |fd| fd.read(3) } and first3 == '---'
  71         blah = filename.sub(/^_manual\//,'')
  72         page = Jekyll::Page.new(@site, '_manual', File.dirname(blah), File.basename(blah))
  73         page.data
  74       else
  75         {}
  76       end
  77     end
  78
  79   class ManualPage < Jekyll::Page
  80     def initialize(*args)
  81       super
  82     end
  83   end
  84
  85   class ManualGenerator < Jekyll::Generator
  86
  87     safe true
  88
  89     def generate(site)
  90       source = site.config['source']
  91       destination = site.config['destination']
  92
  93       manual_dir = '_manual'
  94
  95       # now we need to turn our raw input files into something for jekyll to process
  96       # everything is in a directory with it's name and all content is in index.html files
  97       # the tmpdir gets removed at the end of this block automatically
  98
  99       Dir.mktmpdir do |tmpdir|
 100
 101         Manual.traverse manual_dir, true do |entry|
 102           output_filename = File.join(tmpdir, entry[:url], "index#{entry[:extension]}")
 103
 104           FileUtils.mkdir_p File.dirname(output_filename)
 105
 106           next unless entry[:type] == 'file'
 107
 108           File.open(output_filename, 'w+') do |f|
 109             f << File.read(entry[:filename])
 110           end
 111
 112           relative_filename = File.join(entry[:url], "index#{entry[:extension]}")
 113
 114           site.pages << Jekyll::Page.new(site, tmpdir, File.dirname(relative_filename), File.basename(relative_filename))
 115         end
 116
 117       end
 118     end
 119
 120   end
 121
 122   class ManualChildPageTag < Liquid::Tag
 123     def render(context)
 124       current = context['page.url'].sub(/[^\/]+$/,'')
 125
 126       if entry = DIRECTORY_ENTRIES[current]
 127
 128         path = File.join(entry[:filename], '*')
 129
 130         entries = entry[:children].map do |child|
 131           "<li><a href='#{child[:url]}'>#{child[:title]}</a></li>"
 132         end.uniq
 133
 134         "<ul>#{entries.join}</ul>"
 135       end
 136     end
 137   end
 138
 139   # generates a big <dl> list of the manual page stucture
 140
 141   class ManualTOCTag < Liquid::Tag
 142
 143     def process_hierarchy(items_a, items_b)
 144       current = true
 145       position = nil
 146       level = -1
 147
 148       [items_a.length,items_b.length].max.times do |i|
 149         a = items_a[i]
 150         b = items_b[i]
 151
 152         current = false if a != b
 153
 154         # start incrementing this when we don't have either a or b
 155         level += 1 if !a || !b
 156
 157         if a && b
 158           return [false] if a != b
 159         elsif a
 160           position = :parent
 161         elsif b
 162           position = :child
 163         end
 164       end
 165       position ? [current, position, level + 1] : [current]
 166     end
 167
 168     def render(context)
 169
 170       @source = '_manual' #context.registers[:site].source
 171
 172       @@data_tree ||= Manual.traverse(@source)
 173
 174       @site = context.registers[:site]
 175       current = context['page.url'].sub(/[^\/]+$/,'')
 176
 177       current_a = current.split('/').reject(&:empty?)
 178
 179       tree = Manual.traverse_data(@@data_tree) do |entry|
 180
 181           url = entry[:url]
 182
 183           url_a = url.split('/').reject(&:empty?)
 184
 185           depth = url_a.length
 186           is_current, position, level = *process_hierarchy(current_a, url_a)
 187
 188           # this massively speeds up build time by not including the whole menu tree for each page
 189           next if depth > 1 && current_a[0] != url_a[0]
 190
 191           css_classes = []
 192           css_classes << 'active' if is_current
 193           css_classes << position.to_s if position
 194           css_classes << "#{position}-#{level}" if position && level
 195           css_classes << 'other' unless is_current || position || level
 196
 197           css_classes << "level-#{depth}"
 198           css_classes = css_classes.join(' ')
 199
 200           if entry[:type] == 'directory'
 201
 202               erb = ::ERB.new <<-HTML
 203                   <dt class="<%= css_classes %>">
 204                       <a name="<%= entry[:url] %>" href="<%= entry[:url] %>"><%= entry[:menu_title] %></a>
 205                   </dt>
 206                   <dd class="<%= css_classes %>">
 207                       <% if entry[:children].any? %>
 208                         <dl>
 209                             <%= entry[:children].join %>
 210                         </dl>
 211                       <% end %>
 212                   </dd>
 213               HTML
 214
 215               erb.result(binding)
 216           else
 217
 218               directory_filename = entry[:filename].sub(/\.[^\/\.]+$/,'')
 219
 220               unless entry[:has_dir]
 221
 222                 erb = ::ERB.new <<-HTML
 223                     <dt class="<%= css_classes %>">
 224                         <a name="<%= entry[:url] %>" href="<%= entry[:url] %>"><%= entry[:menu_title] %></a>
 225                     </dt>
 226                     <dd class="<%= css_classes %>">
 227                     </dd>
 228                 HTML
 229
 230                 erb.result(binding)
 231              end
 232           end
 233       end
 234
 235       "<dl>#{tree.join}</dl>"
 236
 237     end
 238
 239
 240   end
 241
 242 end
 243
 244 Liquid::Template.register_tag('tree', Manual::ManualTOCTag)
 245 Liquid::Template.register_tag('children', Manual::ManualChildPageTag)