Merge wiki into docs/ directory

docs/Adding-documentations-to-DevDocs.md

@@ -0,0 +1,22 @@
+Adding a documentation may look like a daunting task but once you get the hang of it, it's actually quite simple. Don't hesitate to ask for help on the [mailing list](https://groups.google.com/d/forum/devdocs) if you ever get stuck.
+
+**Note:** please read the [contributing guidelines](https://github.com/Thibaut/devdocs/blob/master/.github/CONTRIBUTING.md) before submitting a new documentation.
+
+1. Create a subclass of `Docs::UrlScraper` or `Docs::FileScraper` in the `lib/docs/scrapers/` directory. Its name should be the [PascalCase](http://api.rubyonrails.org/classes/String.html#method-i-camelize) equivalent of the filename (e.g. `my_doc` → `MyDoc`)
+2. Add the appropriate class attributes and filter options (see the [Scraper Reference](https://github.com/Thibaut/devdocs/wiki/Scraper-Reference) page).
+3. Check that the scraper is listed in `thor docs:list`.
+4. Create filters specific to the scraper in the `lib/docs/filters/[my_doc]/` directory and add them to the class's [filter stacks](https://github.com/Thibaut/devdocs/wiki/Scraper-Reference#filter-stacks). You may create any number of filters but will need at least the following two:
+   * A [`CleanHtml`](https://github.com/Thibaut/devdocs/wiki/Filter-Reference#cleanhtmlfilter) filter whose task is to clean the HTML markup (e.g. adding `id` attributes to headings) and remove everything superfluous and/or nonessential.
+   * An [`Entries`](https://github.com/Thibaut/devdocs/wiki/Filter-Reference#entriesfilter) filter whose task is to determine the pages' metadata (the list of entries, each with a name, type and path).
+   The [Filter Reference](https://github.com/Thibaut/devdocs/wiki/Filter-Reference) page has all the details about filters.
+5. Using the `thor docs:page [my_doc] [path]` command, check that the scraper works properly. Files will appear in the `public/docs/[my_doc]/` directory (but not inside the app as the command doesn't touch the index). `path` in this case refers to either the remote path (if using `UrlScraper`) or the local path (if using `FileScraper`).
+6. Generate the full documentation using the `thor docs:generate [my_doc] --force` command. Additionally, you can use the `--verbose` option to see which files are being created/updated/deleted (useful to see what changed since the last run), and the `--debug` option to see which URLs are being requested and added to the queue (useful to pin down which page adds unwanted URLs to the queue).
+7. Start the server, open the app, enable the documentation, and see how everything plays out.
+8. Tweak the scraper/filters and repeat 5) and 6) until the pages and metadata are ok.
+9. To customize the pages' styling, create an SCSS file in the `assets/stylesheets/pages/` directory and import it in both `application.css.scss` AND `application-dark.css.scss`. Both the file and CSS class should be named `_[type]` where [type] is equal to the scraper's `type` attribute (documentations with the same type share the same custom CSS and JS). _(Note: feel free to submit a pull request without custom CSS/JS)_
+10. To add syntax highlighting or execute custom JavaScript on the pages, create a file in the `assets/javascripts/views/pages/` directory (take a look at the other files to see how it works).
+11. Add the documentation's icon in the `public/icons/docs/[my_doc]/` directory, in both 16x16 and 32x32-pixels formats. It'll be added to the icon sprite after your pull request is merged.
+
+If the documentation includes more than a few hundreds pages and is available for download, try to scrape it locally (e.g. using `FileScraper`). It'll make the development process much faster and avoids putting too much load on the source site. (It's not a problem if your scraper is coupled to your local setup, just explain how it works in your pull request.)
+
+Finally, try to document your scraper and filters' behavior as much as possible using comments (e.g. why some URLs are ignored, HTML markup removed, metadata that way, etc.). It'll make updating the documentation much easier.

docs/Filter-Reference.md

@@ -0,0 +1,226 @@
+---
+
+**Table of contents:**
+
+* [Overview](https://github.com/Thibaut/devdocs/wiki/Filter-Reference#overview)
+* [Instance methods](https://github.com/Thibaut/devdocs/wiki/Filter-Reference#instance-methods)
+* [Core filters](https://github.com/Thibaut/devdocs/wiki/Filter-Reference#core-filters)
+* [Custom filters](https://github.com/Thibaut/devdocs/wiki/Filter-Reference#custom-filters)
+  - [CleanHtmlFilter](https://github.com/Thibaut/devdocs/wiki/Filter-Reference#cleanhtmlfilter)
+  - [EntriesFilter](https://github.com/Thibaut/devdocs/wiki/Filter-Reference#entriesfilter)
+
+## Overview
+
+Filters use the [HTML::Pipeline](https://github.com/jch/html-pipeline) library. They take an HTML string or [Nokogiri](http://nokogiri.org/) node as input, optionally perform modifications and/or extract information from it, and then outputs the result. Together they form a pipeline where each filter hands its output to the next filter's input. Every documentation page passes through this pipeline before being copied on the local filesystem.
+
+Filters are subclasses of the [`Docs::Filter`](https://github.com/Thibaut/devdocs/blob/master/lib/docs/core/filter.rb) class and require a `call` method. A basic implementation looks like this:
+
+```ruby
+module Docs
+  class CustomFilter < Filter
+    def call
+      doc
+    end
+  end
+end
+```
+
+Filters which manipulate the Nokogiri node object (`doc` and related methods) are _HTML filters_ and must not manipulate the HTML string (`html`). Vice-versa, filters which manipulate the string representation of the document are _text filters_ and must not manipulate the Nokogiri node object. The two types are divided into two stacks within the scrapers. These stacks are then combined into a pipeline that calls the HTML filters before the text filters (more details [here](https://github.com/Thibaut/devdocs/wiki/Scraper-Reference#filter-stacks)). This is to avoid parsing the document multiple times.
+
+The `call` method must return either `doc` or `html`, depending on the type of filter.
+
+## Instance methods
+
+* `doc` [Nokogiri::XML::Node]  
+  The Nokogiri representation of the container element.  
+  See [Nokogiri's API docs](http://www.rubydoc.info/github/sparklemotion/nokogiri/Nokogiri/XML/Node) for the list of available methods.
+
+* `html` [String]  
+  The string representation of the container element.
+
+* `context` [Hash] **(frozen)**  
+  The scraper's `options` along with a few additional keys: `:base_url`, `:root_url`, `:root_page` and `:url`.
+
+* `result` [Hash]  
+  Used to store the page's metadata and pass back information to the scraper.  
+  Possible keys:
+
+  - `:path` — the page's normalized path
+  - `:store_path` — the path where the page will be stored (equal to `:path` with `.html` at the end)
+  - `:internal_urls` — the list of distinct internal URLs found within the page
+  - `:entries` — the [`Entry`](https://github.com/Thibaut/devdocs/blob/master/lib/docs/core/models/entry.rb) objects to add to the index
+
+* `css`, `at_css`, `xpath`, `at_xpath`  
+  Shortcuts for `doc.css`, `doc.xpath`, etc.
+
+* `base_url`, `current_url`, `root_url` [Docs::URL]  
+  Shortcuts for `context[:base_url]`, `context[:url]`, and `context[:root_url]` respectively.
+
+* `root_path` [String]  
+  Shortcut for `context[:root_path]`.
+
+* `subpath` [String]  
+  The sub-path from the base URL of the current URL.  
+  _Example: if `base_url` equals `example.com/docs` and `current_url` equals `example.com/docs/file?raw`, the returned value is `/file`._
+
+* `slug` [String]  
+  The `subpath` removed of any leading slash or `.html` extension.  
+  _Example: if `subpath` equals `/dir/file.html`, the returned value is `dir/file`._
+
+* `root_page?` [Boolean]  
+  Returns `true` if the current page is the root page.
+
+* `initial_page?` [Boolean]  
+  Returns `true` if the current page is the root page or its subpath is one of the scraper's `initial_paths`.
+
+## Core filters
+
+* [`ContainerFilter`](https://github.com/Thibaut/devdocs/blob/master/lib/docs/filters/core/container.rb) — changes the root node of the document (remove everything outside)
+* [`CleanHtmlFilter`](https://github.com/Thibaut/devdocs/blob/master/lib/docs/filters/core/clean_html.rb) — removes HTML comments, `<script>`, `<style>`, etc.
+* [`NormalizeUrlsFilter`](https://github.com/Thibaut/devdocs/blob/master/lib/docs/filters/core/normalize_urls.rb) — replaces all URLs with their fully qualified counterpart
+* [`InternalUrlsFilter`](https://github.com/Thibaut/devdocs/blob/master/lib/docs/filters/core/internal_urls.rb) — detects internal URLs (the ones to scrape) and replaces them with their unqualified, relative counterpart
+* [`NormalizePathsFilter`](https://github.com/Thibaut/devdocs/blob/master/lib/docs/filters/core/normalize_paths.rb) — makes the internal paths consistent (e.g. always end with `.html`)
+* [`CleanLocalUrlsFilter`](https://github.com/Thibaut/devdocs/blob/master/lib/docs/filters/core/clean_local_urls.rb) — removes links, iframes and images pointing to localhost (`FileScraper` only)
+* [`InnerHtmlFilter`](https://github.com/Thibaut/devdocs/blob/master/lib/docs/filters/core/inner_html.rb) — converts the document to a string
+* [`CleanTextFilter`](https://github.com/Thibaut/devdocs/blob/master/lib/docs/filters/core/clean_text.rb) — removes empty nodes
+* [`AttributionFilter`](https://github.com/Thibaut/devdocs/blob/master/lib/docs/filters/core/attribution.rb) — appends the license info and link to the original document
+* [`TitleFilter`](https://github.com/Thibaut/devdocs/blob/master/lib/docs/filters/core/title.rb) — prepends the document with a title (disabled by default)
+* [`EntriesFilter`](https://github.com/Thibaut/devdocs/blob/master/lib/docs/filters/core/entries.rb) — abstract filter for extracting the page's metadata
+
+## Custom filters
+
+Scrapers can have any number of custom filters but require at least the two described below.
+
+**Note:** filters are located in the [`lib/docs/filters`](https://github.com/Thibaut/devdocs/tree/master/lib/docs/filters/) directory. The class's name must be the [CamelCase](http://api.rubyonrails.org/classes/String.html#method-i-camelize) equivalent of the filename.
+
+### `CleanHtmlFilter`
+
+The `CleanHtml` filter is tasked with cleaning the HTML markup where necessary and removing anything superfluous or nonessential. Only the core documentation should remain at the end.
+
+Nokogiri's many jQuery-like methods make it easy to search and modify elements — see the [API docs](http://www.rubydoc.info/github/sparklemotion/nokogiri/Nokogiri/XML/Node).
+
+Here's an example implementation that covers the most common use-cases:
+
+```ruby
+module Docs
+  class MyScraper
+    class CleanHtmlFilter < Filter
+      def call
+        css('hr').remove
+        css('#changelog').remove if root_page?
+
+        # Set id attributes on <h3> instead of an empty <a>
+        css('h3').each do |node|
+          node['id'] = node.at_css('a')['id']
+        end
+
+        # Make proper table headers
+        css('td.header').each do |node|
+          node.name = 'th'
+        end
+
+        # Remove code highlighting
+        css('pre').each do |node|
+          node.content = node.content
+        end
+
+        doc
+      end
+    end
+  end
+end
+```
+
+**Notes:**
+
+* Empty elements will be automatically removed by the core `CleanTextFilter` later in the pipeline's execution.
+* Although the goal is to end up with a clean version of the page, try to keep the number of modifications to a minimum, so as to make the code easier to maintain. Custom CSS is the preferred way of normalizing the pages (except for hiding stuff which should always be done by removing the markup).
+* Try to document your filter's behavior as much as possible, particularly modifications that apply only to a subset of pages. It'll make updating the documentation easier.
+
+### `EntriesFilter`
+
+The `Entries` filter is responsible for extracting the page's metadata, represented by a set of _entries_, each with a name, type and path.
+
+The following two models are used under the hood to represent the metadata:
+
+* [`Entry(name, type, path)`](https://github.com/Thibaut/devdocs/blob/master/lib/docs/core/models/entry.rb)
+* [`Type(name, slug, count)`](https://github.com/Thibaut/devdocs/blob/master/lib/docs/core/models/type.rb)
+
+Each scraper must implement its own `EntriesFilter` by subclassing the [`Docs::EntriesFilter`](https://github.com/Thibaut/devdocs/blob/master/lib/docs/filters/core/entries.rb) class. The base class already implements the `call` method and includes four methods which the subclasses can override:
+
+* `get_name` [String]  
+  The name of the default entry (aka. the page's name).  
+  It is usually guessed from the `slug` (documented above) or by searching the HTML markup.  
+  **Default:** modified version of `slug` (underscores are replaced with spaces and forward slashes with dots)
+
+* `get_type` [String]  
+  The type of the default entry (aka. the page's type).  
+  Entries without a type can be searched for but won't be listed in the app's sidebar (unless no other entries have a type).  
+  **Default:** `nil`
+
+* `include_default_entry?` [Boolean]  
+  Whether to include the default entry.  
+  Used when a page consists of multiple entries (returned by `additional_entries`) but doesn't have a name/type of its own, or to remove a page from the index (if it has no additional entries), in which case it won't be copied on the local filesystem and any link to it in the other pages will be broken (as explained on the [Scraper Reference](https://github.com/Thibaut/devdocs/wiki/Scraper-Reference) page, this is used to keep the `:skip` / `:skip_patterns` options to a maintainable size, or if the page includes links that can't reached from anywhere else).  
+  **Default:** `true`
+
+* `additional_entries` [Array]  
+  The list of additional entries.  
+  Each entry is represented by an Array of three attributes: its name, fragment identifier, and type. The fragment identifier refers to the `id` attribute of the HTML element (usually a heading) that the entry relates to. It is combined with the page's path to become the entry's path. If absent or `nil`, the page's path is used. If the type is absent or `nil`, the default `type` is used.  
+  Example: `[ ['One'], ['Two', 'id'], ['Three', nil, 'type'] ]` adds three additional entries, the first one named "One" with the default path and type, the second one named "Two" with the URL fragment "#id" and the default type, and the third one named "Three" with the default path and the type "type".  
+  The list is usually constructed by running through the markup. Exceptions can also be hard-coded for specific pages.  
+  **Default:** `[]`
+
+The following accessors are also available, but must not be overridden:
+
+* `name` [String]  
+  Memoized version of `get_name` (`nil` for the root page).
+
+* `type` [String]  
+  Memoized version of `get_type` (`nil` for the root page).
+
+**Notes:**
+
+* Leading and trailing whitespace is automatically removed from names and types.
+* Names must be unique across the documentation and as short as possible (ideally less than 30 characters). Whenever possible, methods should be differentiated from properties by appending `()`, and instance methods should be differentiated from class methods using the `Class#method` or `object.method` conventions.
+* You can call `name` from `get_type` or `type` from `get_name` but doing both will cause a stack overflow (i.e. you can infer the name from the type or the type from the name, but you can't do both at the same time). Don't call `get_name` or `get_type` directly as their value isn't memoized.
+* The root page has no name and no type (both are `nil`). `get_name` and `get_type` won't get called with the page (but `additional_entries` will).
+* `Docs::EntriesFilter` is an _HTML filter_. It must be added to the scraper's `html_filters` stack.
+* Try to document the code as much as possible, particularly the special cases. It'll make updating the documentation easier.
+
+**Example:**
+
+```ruby
+module Docs
+  class MyScraper
+    class EntriesFilter < Docs::EntriesFilter
+      def get_name
+        node = at_css('h1')
+        result = node.content.strip
+        result << ' event' if type == 'Events'
+        result << '()' if node['class'].try(:include?, 'function')
+        result
+      end
+
+      def get_type
+        object, method = *slug.split('/')
+        method ? object : 'Miscellaneous'
+      end
+
+      def additional_entries
+        return [] if root_page?
+
+        css('h2').map do |node|
+          [node.content, node['id']]
+        end
+      end
+
+      def include_default_entry?
+        !at_css('.obsolete')
+      end
+    end
+  end
+end
+```
+
+
+return [[Home]]

docs/Home.md

@@ -0,0 +1,23 @@
+### Development
+
+* [Adding documentations to DevDocs](https://github.com/Thibaut/devdocs/wiki/Adding-documentations-to-DevDocs)
+* [Scraper Reference](https://github.com/Thibaut/devdocs/wiki/Scraper-Reference)
+* [Filter Reference](https://github.com/Thibaut/devdocs/wiki/Filter-Reference)
+
+### Plugins and Extensions
+
+* [Chrome web app](https://chrome.google.com/webstore/detail/devdocs/mnfehgbmkapmjnhcnbodoamcioleeooe)
+* [Ubuntu Touch app](https://uappexplorer.com/app/devdocsunofficial.berkes)
+* [Sublime Text plugin](https://sublime.wbond.net/packages/DevDocs)
+* [Atom plugin](https://atom.io/packages/devdocs)
+* [Brackets extension](https://github.com/gruehle/dev-docs-viewer) 
+* [Fluid](http://fluidapp.com) for turning DevDocs into a real OS X app
+* [GTK shell / Vim integration](https://github.com/naquad/devdocs-shell)
+* [Emacs lookup](https://github.com/skeeto/devdocs-lookup)
+* [Alfred Workflow](https://github.com/yannickglt/alfred-devdocs)
+* [Vim search plugin with Devdocs in its defaults](https://github.com/waiting-for-dev/vim-www) Just set `let g:www_shortcut_engines = { 'devdocs': ['Devdocs', '<leader>dd'] }` to have a `:Devdocs` command and a `<leader>dd` mapping.
+* [Visual Studio Code plugin](https://marketplace.visualstudio.com/items?itemName=akfish.vscode-devdocs ) (1)
+* [Visual Studio Code plugin](https://marketplace.visualstudio.com/items?itemName=deibit.devdocs) (2)
+* [Desktop application](https://github.com/egoist/devdocs-desktop)
+* [Doc Browser](https://github.com/qwfy/doc-browser) is a native Linux app that supports DevDocs docsets
+* [GNOME Application](https://github.com/hardpixel/devdocs-desktop) GTK3 application with search integrated in headerbar