patricia 0.0.1

checksums.yaml

@@ -0,0 +1,7 @@
+---
+SHA1:
+  metadata.gz: ef479d8eff067d6a70b52846c246763987cb72e8
+  data.tar.gz: 538feff310e1df73d5f52c79d6da00e054bd268a
+SHA512:
+  metadata.gz: e22e0b7aa71306f9e4015a98acedc315adf3bf21a38141b1f0f073918c0db23aa202e5fc43fcb38e0731e79755068a5fc86a44d290bc521c5d15bafa74fb952e
+  data.tar.gz: d704365bc2c6e17f7966870f16f07905232899e4c185f4eeca0c7bfe623a49db1ba187fbbff1c4dd51960ff63261fc6dbcc4218ff46f11b9758419c0c248ad89

data/.gitignore

@@ -0,0 +1,25 @@
+*.gem
+*.rbc
+.bundle
+.config
+.yardoc
+Gemfile.lock
+InstalledFiles
+_yardoc
+coverage
+doc/
+lib/bundler/man
+pkg
+rdoc
+spec/reports
+test/tmp
+test/version_tmp
+tmp
+*.bundle
+*.so
+*.o
+*.a
+mkmf.log
+bin/app_config.yml
+output
+spec/output

data/Gemfile

@@ -0,0 +1,12 @@
+source 'https://rubygems.org'
+
+# Specify your gem's dependencies in patricia.gemspec
+gemspec
+
+gem 'kramdown'
+gem 'org-ruby'
+gem 'redcloth'
+gem 'pandoc-ruby'
+gem 'rack'
+gem 'fileutils'
+gem 'sinatra'

data/LICENSE.txt

@@ -0,0 +1,22 @@
+Copyright (c) 2014 nounch
+
+MIT License
+
+Permission is hereby granted, free of charge, to any person obtaining
+a copy of this software and associated documentation files (the
+"Software"), to deal in the Software without restriction, including
+without limitation the rights to use, copy, modify, merge, publish,
+distribute, sublicense, and/or sell copies of the Software, and to
+permit persons to whom the Software is furnished to do so, subject to
+the following conditions:
+
+The above copyright notice and this permission notice shall be
+included in all copies or substantial portions of the Software.
+
+THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND,
+EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF
+MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND
+NONINFRINGEMENT. IN NO EVENT SHALL THE AUTHORS OR COPYRIGHT HOLDERS BE
+LIABLE FOR ANY CLAIM, DAMAGES OR OTHER LIABILITY, WHETHER IN AN ACTION
+OF CONTRACT, TORT OR OTHERWISE, ARISING FROM, OUT OF OR IN CONNECTION
+WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE SOFTWARE.

data/README.md

@@ -0,0 +1,77 @@
+# Patricia
+
+Patricia is a simple markup-based Wiki. You give it a directory full of
+markup files and it either
+
+- serves the markup files as dynamic HTML pages with a hierarchical list of
+  all pages in a handy sidebar (including a search box) or
+- generates a directory full of static HTML pages that you can serve
+  yourself.
+
+The first option is great for writing/previewing your markup files. You
+simply refresh the page and Patricia picks up the current state of the
+file. However, it is also perfectly fine to use this built-in server to
+serve your Wiki as a real website.
+
+Files of different supported markup languages can be wildly mixed in the
+markup directory, Patricia is able to figure it out as long as you use the
+right file extension. Static files (images/PDFs/video/...) in the markup
+directory are served as is, so you can link to them from any page and the
+links will not break.
+
+## Installation
+
+        gem install patricia
+
+## Quick Start
+
+Run
+
+        patricia /path/to/markup/dir -p 4321
+
+and point your browser to `http://localhost:4321/`. Patricia will tell you
+what to do from that point on.
+
+## Usage
+
+To serve a directory full of markup files (`dir`), run this:
+
+        patricia /path/to/dir
+
+To generate static HTML files in an output directory (`outputdir`), run
+this:
+
+        patricia /path/to/dir /path/to/outputdir
+
+To use your own stylesheets use the `--css` command line switch, to include
+your own JavaScript, use `--js`. If you want to use a custom port, the
+`--port` comes in handy.
+
+Run `patricia --help` to see a list of all options.
+
+## Markup Languages
+
+Patricia supports the following markup languages (supported file
+extensions in parentheses):
+
+- Markdown (`.md`, `.markdown`) via `kramdown`
+- Org (`.org`) via `org-ruby`
+- Textile (`.textile`) via `redcloth`
+- reStructuredText (`.rst`, `.rest`, `restx`) via `pandoc-ruby`
+
+To add support for a new language do this:
+
+0. *Write tests*
+1. Add a method with the markup language name to `Patricia::Converter`
+   (This function takes a markup string as input and returns a HTML string
+   as output)
+2. Associate this new method with the desired file extensions for the new
+   markup language by adding mappings to the
+   `Patricia::Converter.converters` hash.
+3. Add those file extensions to `PatriciaApp::App`'s
+   `settings.app_markdown_glob` in its `configure` block.
+4. Add the file extensions to the `settings.app_content_types` hash in
+   `PatriciaApp::App` and map them to the `text/plain` content type, if
+   possible, so that browsers will display them on a page instead of
+   prompting to download the file.
+5. *Make sure the tests pass*

data/Rakefile

@@ -0,0 +1,2 @@
+require "bundler/gem_tasks"
+

data/bin/patricia

@@ -0,0 +1,48 @@
+#!/usr/bin/env ruby
+
+
+require 'rack'
+require 'yaml'
+require_relative '../lib/patricia'
+
+
+config = {
+  :css_dir => CLI.options[:css],
+  :js_dir => CLI.options[:js],
+  :markup_dir => CLI.options[:markup_dir],
+  :tooltips => CLI.options[:tooltips],
+}
+config_file = File.dirname(__FILE__) + '/app_config.yml'
+# The thread ensures that the config file is written before the Sinatra app
+# starts.
+config_writer = Thread.new do
+  begin
+    File.delete(config_file)
+  rescue
+    # Ignore.
+  end
+  File.open(config_file, 'w') do |f|
+    f.write(config.to_yaml)
+  end
+end
+
+# Wait for the config file to be written.
+config_writer.join
+
+if CLI.options[:output_dir]
+  css_dir = CLI.options[:css]
+  js_dir = CLI.options[:js]
+  css = Dir[css_dir + '/**/*.css'].collect { |x| x.sub(/#{css_dir}/, '') }
+  js = Dir[js_dir + '/**/*.js'].collect { |x| x.sub(/#{js_dir}/, '') }
+  patricia = Patricia::Wiki.new(CLI.options[:markup_dir], :output_dir =>
+                                CLI.options[:output_dir], :css =>
+                                css, :js => js)
+  patricia.render
+else
+  require_relative '../lib/patricia/app'
+  app = Rack::Builder.new do
+    use PatriciaApp::App
+    run Proc.new { |env| [404, {'Content-Type' => 'text/html'}, ['404']] }
+  end
+  Rack::Handler::WEBrick.run app, :Port => CLI.options[:port] || 4321
+end

data/lib/patricia/app.rb

@@ -0,0 +1,258 @@
+require 'sinatra/base'
+require 'yaml'
+
+
+module PatriciaApp
+  class App < Sinatra::Base
+
+    def self.generate_routes
+      # CSS
+      settings.app_css.each do |dir|
+        get dir do
+          content_type 'text/css'
+          File.new(File.join(settings.app_css_dir, dir)).readlines
+        end
+      end
+
+      # JS
+      settings.app_js.each do |dir|
+        get dir do
+          content_type 'text/js'
+          File.new(File.join(settings.app_js_dir, dir)).readlines
+        end
+      end
+    end
+
+    configure do
+      begin
+        config_file = File.expand_path('../../../bin/app_config.yml',
+                                       __FILE__)
+        app_configs = YAML.load_file(config_file)
+        markup_dir = app_configs[:markup_dir]
+        set :environment, 'production'
+        set :app_markup_dir, markup_dir
+        set :app_markdown_glob, '.{md,markdown,org,textile,rst,rest,restx}'
+        set :app_css_path, '/patricia.css'
+        set :app_js_path, '/patricia.js'
+        set :app_public_folder, app_configs[:public_folder]
+        set :app_tooltips, app_configs[:tooltips]
+        # CSS
+        if app_configs[:css_dir] != nil
+          set :app_css_dir, app_configs[:css_dir]
+          css_paths = Dir[app_configs[:css_dir] + '/**/*.css']
+            .collect do |path|
+            path.gsub(/#{app_css_dir}/, '')
+          end
+          set :app_css, css_paths
+        else
+          set :app_css_dir, ''
+          set :app_css, []
+        end
+        # JS
+        if app_configs[:js_dir] != nil
+          set :app_js_dir, app_configs[:js_dir]
+          js_paths = Dir[app_configs[:js_dir] + '/**/*.js']
+            .collect do |path|
+            path.gsub(/#{app_js_dir}/, '')
+          end
+          set :app_js, js_paths
+        else
+          set :app_js_dir, ''
+          set :app_js, []
+        end
+        # Content types
+        set :app_content_types, {
+          'png' => 'image/png',
+          'jpg' => 'image/jpeg',
+          'jpeg' => 'image/jpeg',
+          'gif' => 'image/gif',
+          'bmp' => 'image/bmp',
+          'torrent' => 'image/x-bittorrent',
+          'svg' => 'image/svg+xml',
+          'xml' => 'application/xml',
+          'atom' => 'application/atom-xml',
+          'zip' => 'application/zip',
+          'bz' => 'application/x-bzip',
+          'bz2' => 'application/x-bzip2',
+          'gzip' => 'application/gzip',
+          'pdf' => 'application/pdf',
+          'sh' => 'application/x-sh',
+          '7z' => 'application/x-7z-compressed',
+          'swf' => 'application/x-shockwave-flash',
+          'avi' => 'video/x-msvideo',
+          'txt' => 'text/plain',
+          'css' => 'text/css',
+          'csv' => 'text/csv',
+          # Send markup source files
+          #
+          # One can argue if this is semantically correct (alternative:
+          # `plain/x-markdown;charset=UTF-8'), but as there is no official
+          # final specification and this solution comes with the highest
+          # browser-compatibility, it is preferred.
+          'md' => 'text/plain',
+          'markdown' => 'text/plain',
+          'org' => 'text/plain',
+          'textile' => 'text/plain',
+          'rst' => 'text/plain',
+          'rest' => 'text/plain',
+          'rstx' => 'text/plain',
+        }
+        self.generate_routes
+      rescue
+        # Ignore.
+      end
+    end
+
+    helpers do
+      def build_toc
+        Patricia::Wiki.new(settings.app_markup_dir).build_toc
+      end
+
+      def generate_page_title
+        capitalize_all(File.basename(settings.app_markup_dir).gsub(/-/,
+                                                                   ' '))
+      end
+
+      def capitalize_all(string)
+        string.split.inject([]) do |result, token|
+          result << token[0].capitalize + token[1..-1]
+        end.join(' ')
+      end
+    end
+
+    get '/' do
+      @html = Patricia::Converter .to_html(File.dirname(__FILE__) +
+                                           '/views/wiki/welcome.md')
+      @toc = build_toc
+      @title = generate_page_title
+      @page_title = ''
+      @breadcrumb = ''
+      @stylesheets = settings.app_css
+      @javascripts = settings.app_js
+      haml 'wiki/page'.to_sym, :layout => :application
+    end
+
+    get %r{/404/?} do
+      haml '404'.to_sym, :layout => :application
+    end
+
+    get %r{/patricia/search/?} do
+      haml :search, :layout => :application
+    end
+
+    post %r{/patricia/search/?} do
+      @previous_search_query = params[:search_query] || ''
+      if params[:case_sensitive]
+        search_query = %r{#{params[:search_query]}}
+        @previous_search_query_was_sensitive = true
+      else
+        search_query = %r{#{params[:search_query]}}i
+        @previous_search_query_was_sensitive = false
+      end
+      # Search all markup files
+      @results = []
+      paths = Dir[File.join(settings.app_markup_dir, '/**/*' +
+                            settings.app_markdown_glob)]
+      paths.each do |path|
+        if File.read(path)
+          p = path.gsub(/#{settings.app_markup_dir}/, '')
+          file_name = File.basename(p, '.*')
+          no_ext = File.join(File.dirname(p), file_name).sub(/^\.\//, '')
+          beautiful_file_name = capitalize_all(file_name.gsub(/-/, ' '))
+          beautiful_path = no_ext.split('/').collect do |s|
+            capitalize_all(s.gsub(/-/, ' '))
+          end.join(' > ')
+          content = File.read(path)
+          lines = content.split("\n").length
+          if content =~ search_query
+            @results << [beautiful_file_name, '/' + no_ext, beautiful_path,
+                         lines]
+          end
+        end
+      end
+      haml :search, :layout => :application
+    end
+
+    get settings.app_css_path do
+      pwd = File.dirname(__FILE__)
+      css = ''
+      [
+       '/assets/stylesheets/bootstrap.min.css',
+       '/assets/stylesheets/app.css',
+      ].each do |path|
+        css << File.read(pwd + path) + "\n\n"
+      end
+      content_type 'text/css'
+      css
+    end
+
+    get settings.app_js_path do
+      pwd = File.dirname(__FILE__)
+      js = ''
+      files =
+        [
+         '/assets/javascripts/jquery-1.11.0.min.js',
+         '/assets/javascripts/bootstrap.min.js',
+         '/assets/javascripts/app.js',
+        ]
+      files << '/assets/javascripts/tooltips.js' if settings.app_tooltips
+      files.each do |path|
+        js << File.read(pwd + path) + "\n\n"
+      end
+      content_type 'text/javascript'
+      js
+    end
+
+    get %r{/(.*)} do |path|
+      # This assumes that there are not two or more files with the same
+      # file name, but different extensions (e.g. `/smart/green/frog.md'
+      # and `/smart/green/frog.markdown'). If so, it will chose the one it
+      # finds first.
+      # If this becomes a problem in the future, one could send a
+      # disambiguation page with links to each of the files for this
+      # request.
+      begin
+        file_path = Dir[settings.app_markup_dir + '/' + path +
+                        settings.app_markdown_glob].first
+        @markup_url = file_path.gsub(/#{settings.app_markup_dir}/, '')
+        @html = Patricia::Converter.to_html(file_path)
+        @toc = build_toc
+        arrow = ' > '
+        @title = generate_page_title
+        @breadcrumb = capitalize_all(File.dirname(path).gsub(/\//, ' '))
+        breadcrumb_array = @breadcrumb.split
+        if breadcrumb_array.length >= 1 && breadcrumb_array.first !~ /\./
+          @breadcrumb = breadcrumb_array.inject([]) do |result, token|
+            result << capitalize_all(token.gsub(/-/, ' '))
+          end.join(arrow) + arrow
+        else
+          @breadcrumb = ''
+        end
+        @stylesheets = settings.app_css
+        @javascripts = settings.app_js
+        @page_title = capitalize_all(File.basename(path).gsub(/-/, ' '))
+          .split.join(' ')
+        haml 'wiki/page'.to_sym, :layout => :application
+      rescue
+        file_path = File.join(settings.app_markup_dir, path)
+        if File.exists?(file_path)
+          ext = File.extname(path).gsub(/\./, '')
+          # Try to guess the correct content type for popular content
+          # types.
+          content_type settings.app_content_types[ext] ||
+            'application/octet-stream'
+          send_file(file_path)
+        else
+          redirect to('/404')
+        end
+      end
+    end
+
+    # `patricia.rb' already defines this, but redefining it here decouples
+    # the web app from the static file generator.
+    def _without_extension(path)
+      path.sub(/\..*$/, '')
+    end
+
+  end
+end

data/lib/patricia/assets/javascripts/app.js

@@ -0,0 +1,170 @@
+$(document).ready(function() {
+
+  // Helpers
+
+  $.fn.elementText = function() {
+    var str = '';
+    $(this).contents().each(function() {
+      if ($(this).nodeType == 3) {
+        str += $(this).textContent || $(this).innerText || '';
+      }
+    });
+    return str;
+  };
+
+
+  // Sidebar expanding
+
+  var self = $(this);
+  self.sidebarExpanded = false;
+  self.originalSidebarStyle = {
+    'width': '',
+    'position': '',
+    'box-shadow': '',
+  };
+  self.originalSidebarLeftMargin = parseInt($('#p-sidebar').css(
+    'margin-left'));
+  self.sidebarLeftMarginAnimationWidth = 10;
+  self.sidebarExpandedStyle = {
+    'width': '80%',
+    'right': '20px',
+    'position': 'absolute',
+    'box-shadow': '0 0 0 9999px rgba(0, 0, 0, 0.3)',
+  };
+  self.sidebarWidthToggleOriginalText =
+    $('#p-sidebar-width-toggle').text();
+  self.sidebarWidthToggleExpandedText = 'Narrow sidebar';
+  self.previousScrollPosition = null;
+
+  self.toggleSidebarWidth = function() {
+    if (self.sidebarExpanded) {
+      self.sidebarExpanded = false;
+      $('#p-sidebar-width-toggle')
+        .text(self.sidebarWidthToggleOriginalText);
+      $('#p-sidebar').css(self.originalSidebarStyle);
+      // Scroll to the previous scroll position.
+      $('html').scrollTop(self.previousScrollPosition);
+    } else {
+      self.sidebarExpanded = true;
+      $('#p-sidebar-width-toggle')
+        .text(self.sidebarWidthToggleExpandedText);
+      $('#p-sidebar').css(self.sidebarExpandedStyle);
+      // Scroll to thetop of the page.
+      self.previousScrollPosition = $('html').scrollTop();
+      $('html').scrollTop(0);
+    }
+  };
+
+  $('#p-sidebar-width-toggle').click(function(e) {
+    e.preventDefault();
+    self.toggleSidebarWidth();
+  });
+
+  // Collapse the sidebar when clicking on a link while the sidebar is
+  // expanded. So when hitting the back button the sidebar will be
+  // collapsed. This is moreintuitive.
+  $('#toc a').click(function() {
+    if (self.sidebarExpanded) {
+      self.toggleSidebarWidth();
+    }
+  });
+
+  // Keybinding
+  $('body').append(
+    '\
+<div id="help-box">\
+<p class="text-right"><a class="btn btn-default btn-xs help-box-toggle"\
+href="/">Close</a></p>\
+<h2 class="text-center">Key bindings</h2>\
+<br/>\
+<p><code>?</code><span>: Toggle key bindings help</span></p>\
+<p><code>w</code><span>: Toggle sidebar width</span></p>\
+<p><code>s</code><span>: Select sidebar search box</span></p>\
+<p><code>Esc</code><span>: Unselect sidebar search box</span></p>\
+<p><code>p</code><span>: Go to page search page</span></p>\
+</div>\
+'
+  );
+  self.helpBox = $('#help-box');
+  self.helpBox.hide();
+  self.helpBox.css({
+    'position': 'fixed',
+    'background-color': '#FAFAFA',
+    'color': '#686868',
+    'top': '50%',
+    'left': '50%',
+    'width': '500px',
+    'height': '400px',
+    'margin-left': '-200px',
+    'margin-top': '-300px',
+    'z-index': '9999',
+    'padding': '10px',
+    'box-shadow': '0 0 0 9999px rgba(0, 0, 0, 0.2)',
+    'border': '1px solid #ACACAC',
+  });
+  $('#p-sidebar-search-box').parent().find('a:first').parent().prepend('\
+<a href="/" class="text-muted btn-xs help-box-toggle">Key bindings\
+</a>');
+  $('.help-box-toggle').click(function(e) {
+    e.preventDefault();
+    self.helpBox.toggle();
+  })
+  $(document).keypress(function(e) {
+    // 119: w   - Toggle sidebar width
+    // 115: s   - Select sidebar search box
+    // 0:   Esc - Unselect sidebar search box
+    // 112: s   - Go to page search page
+    // 63:  ?   - Toggle key bindings help
+    if (e.target.nodeName != 'INPUT' && e.target.nodeName != 'TEXTAREA') {
+      if (e.which == 119) {
+        self.toggleSidebarWidth();
+      } else if (e.which == 115) {
+        $('#p-sidebar-search-box').select();
+      } else if (e.which == 112) {
+        window.location = $('#p-page-search-link').attr('href');
+      } else if (e.which == 63) {
+        $('#help-box').toggle();
+      }
+    } else if (e.target.id == 'sidebar-search-box') {
+      if (e.which == 0) {
+        $('#p-sidebar-search-box').blur();
+      }
+    }
+  });
+
+
+  // Skip `Key bindings' and `Widen sidebar' links when navigation using
+  // TAB.
+  $('#p-sidebar-search-box').parent().find('a').slice(0,2)
+    .each(function(index) {
+      $(this).attr('tabindex', '9999');
+      // Add tooltips
+      var title = '';
+      if (index == 0) {
+        title = 'Shortcut: "?"';
+      } else if (index == 1) {
+        title = 'Shortcut: "w"';
+      }
+      $(this).attr('title', title);
+      $(this).attr('data-toggle', 'tooltip');
+      $(this).attr('data-placement', 'top');
+    });
+
+
+  // Search
+
+  $('#p-sidebar-search-box').keyup(function() {
+    var filter = $(this).val().toLowerCase();
+
+    $('#p-sidebar li').each(function() {
+      var text = $(this).text().toLowerCase();
+
+      if (text.match(filter)) {
+        $(this).show()
+      } else {
+        $(this).hide();
+      }
+    });
+  });
+
+});