wiki 0.0.1

checksums.yaml

@@ -0,0 +1,7 @@
+---
+SHA1:
+  metadata.gz: af6c3920f6679b9844dd249d0c5cc3fd61982799
+  data.tar.gz: 4d5247d3d0876a2ae044742b217e74b796e87f96
+SHA512:
+  metadata.gz: 8c818d43b7dfeb8e1d2cbcb720fd00a44b7df4784fb82aafd695fef6ffbafa4098d386d7ae872b6a1a76e83bd67afa22de721345455344cec6175848cbf61474
+  data.tar.gz: afffe40b5c4488773fa46abf1a602752b49e976e1f1b7d878a96e1935d5623c6cff612dc86ed8753721c24a3bc0cb68cd76ded290642c6fd9799f5bf89cedd14

data/.gitignore

@@ -0,0 +1,17 @@
+*.gem
+*.rbc
+.bundle
+.config
+.yardoc
+Gemfile.lock
+InstalledFiles
+_yardoc
+coverage
+doc/
+lib/bundler/man
+pkg
+rdoc
+spec/reports
+test/tmp
+test/version_tmp
+tmp

data/Gemfile

@@ -0,0 +1,4 @@
+source 'https://rubygems.org'
+
+# Specify your gem's dependencies in wiki.gemspec
+gemspec

data/LICENSE.txt

@@ -0,0 +1,22 @@
+Copyright (c) 2013 Daniel Stark
+
+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,29 @@
+# Wiki
+
+TODO: Write a gem description
+
+## Installation
+
+Add this line to your application's Gemfile:
+
+    gem 'wiki'
+
+And then execute:
+
+    $ bundle
+
+Or install it yourself as:
+
+    $ gem install wiki
+
+## Usage
+
+TODO: Write usage instructions here
+
+## Contributing
+
+1. Fork it
+2. Create your feature branch (`git checkout -b my-new-feature`)
+3. Commit your changes (`git commit -am 'Add some feature'`)
+4. Push to the branch (`git push origin my-new-feature`)
+5. Create new Pull Request

data/Rakefile

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

data/lib/wiki.rb

@@ -0,0 +1,2 @@
+require "wiki/version"
+require "wiki/server"

data/lib/wiki/ReadMe.md

@@ -0,0 +1,89 @@
+Server Goals
+============
+
+The server participates in a peer-to-peer exchange of page content and page metadata.
+It is expected to be mostly-on so that it can support the needs of peers and anticipate the needs of ux clients of this server.
+In summary, the server's peer-to-peer side exists to:
+
+* Encourage the deployment of independently owned content stores.
+* Support community among owners through systematic sharing of content.
+
+
+Customizing your Server
+=======================
+
+The distribution contains default files. They will be copied the first time
+they're requested, if you don't install your own. These are:
+
+    default-data/pages/welcome-visitors
+    default-data/status/favicon.png (unused, see below)
+
+The first is the usual welcome page offered as the server's home page.
+The second is a 32x32 png gradient that is used to identify your server
+in bookmarks, browser tabs, page headings and journal entries.
+
+You can revise the welcome page by editing your copy here:
+
+    data/pages/welcome-visitors
+
+A suitable random gradient will be generated for you.
+You can remove or replace it here:
+
+    data/status/favicon.png
+
+
+Launching the Server
+====================
+
+We're now using Ruby 1.9.2 which we manage with rvm. Launch the server with the following bundler commands:
+
+	rvm 1.9.2
+	bundle exec rackup -s thin -p 1111
+
+Hosting a Server Farm
+=====================
+
+The server can host separate pages and status directories for a number of virtual hosts. Enable this by creating the subdirectory:
+
+	data/farm
+
+or by setting the environment variable
+
+	FARM_MODE=true
+
+The server will create subdirectories with farm for each virtual host name and locate pages and status directories within that.
+
+Recursive Server Calls
+======================
+
+Federated sites hosted in the same farm can cause recursive web requests.
+This is an issue for certain rack servers, notably thin, which is widely used in production rack setups.
+If you have a standard server configuration, in which all traffic coming to *.my-sfw-farm.org will be handled by
+a single server, you can serve page json and favicons in the context of the current request
+(instead of generating an additional HTTP request)
+by setting the environment variable:
+
+	FARM_DOMAINS=my-sfw-farm.org
+
+Your server can handle multiple domains by comma-separating them:
+
+	FARM_DOMAINS=my-sfw-farm.org,fedwiki.jacksmith.com
+
+With this setup, pages and favicons will be served more efficiently, as well as being friendly to single-threaded servers like thin.
+
+Alternately, you can use webrick, which handles recursive calls out of the box. Launch it with this command:
+
+	bundle exec rackup -s webrick -p 1111
+
+CouchDB
+=======
+
+By default, all pages, favicons, and server claims are stored in the server's local filesystem.
+If you prefer to use CouchDB for storage, set two environment variables:
+
+	STORE_TYPE=CouchStore
+	COUCHDB_URL=https://username:password@some-couchdb-host.com
+
+If you want to run a farm with CouchDB, be sure to set the environment variable
+
+	FARM_MODE=true

data/lib/wiki/config.ru

@@ -0,0 +1,2 @@
+require File.expand_path('../server', __FILE__)
+run Controller

data/lib/wiki/favicon.rb

@@ -0,0 +1,31 @@
+require 'rubygems'
+require 'png'
+
+class Favicon
+  class << self
+    def create_blob
+      canvas = PNG::Canvas.new 32, 32
+      light = PNG::Color.from_hsv(256*rand,200,255).rgb()
+      dark = PNG::Color.from_hsv(256*rand,200,125).rgb()
+      angle = 2 * (rand()-0.5)
+      sin = Math.sin angle
+      cos = Math.cos angle
+      scale = sin.abs + cos.abs
+      for x in (0..31)
+        for y in (0..31)
+          p = (sin >= 0 ? sin*x+cos*y : -sin*(31-x)+cos*y) / 31 / scale
+          canvas[x,y] = PNG::Color.new(
+            light[0]*p + dark[0]*(1-p),
+            light[1]*p + dark[1]*(1-p),
+            light[2]*p + dark[2]*(1-p))
+        end
+      end
+      PNG.new(canvas).to_blob
+    end
+
+    def get_or_create(path)
+      Store.get_blob(path) || Store.put_blob(path, Favicon.create_blob)
+    end
+
+  end
+end

data/lib/wiki/page.rb

@@ -0,0 +1,74 @@
+require 'json'
+require File.expand_path("../random_id", __FILE__)
+require File.expand_path("../stores/all", __FILE__)
+
+class PageError < StandardError; end;
+
+# Page Class
+# Handles writing and reading JSON data to and from files.
+class Page
+
+    # Directory where pages are to be stored.
+    attr_accessor :directory
+    # Directory where default (pre-existing) pages are stored.
+    attr_accessor :default_directory
+    # Directory where plugins that may have pages are stored.
+    attr_accessor :plugins_directory
+
+    def plugin_page_path name
+      Dir.glob(File.join(plugins_directory, '*/pages')) do |dir|
+        probe = "#{dir}/#{name}"
+        return probe if File.exists? probe
+      end
+      return nil
+    end
+
+
+    # Get a page
+    #
+    # @param [String] name - The name of the file to retrieve, relative to Page.directory.
+    # @return [Hash] The contents of the retrieved page (parsed JSON).
+    def get(name)
+      assert_attributes_set
+      path = File.join(directory, name)
+      default_path = File.join(default_directory, name)
+      page = Store.get_page(path)
+      if page
+        page
+      elsif File.exist?(default_path)
+        FileStore.get_page(default_path)
+      elsif (path = plugin_page_path name)
+        page = FileStore.get_page(path)
+        page['plugin'] = path.match(/plugins\/(.*?)\/pages/)[1]
+        page
+      else
+        halt 404
+      end
+    end
+
+    def exists?(name)
+      Store.exists?(File.join(directory, name)) or
+      File.exist?(File.join(default_directory, name)) or
+      !plugin_page_path(name).nil?
+    end
+
+    # Create or update a page
+    #
+    # @param [String] name - The name of the file to create/update, relative to Page.directory.
+    # @param [Hash] page - The page data to be written to the file (it will be converted to JSON).
+    # @return [Hash] The contents of the retrieved page (parsed JSON).
+    def put(name, page)
+      assert_attributes_set
+      path = File.join directory, name
+      page.delete 'plugin'
+      Store.put_page(path, page, :name => name, :directory => directory)
+    end
+
+    private
+
+    def assert_attributes_set
+      raise PageError.new('Page.directory must be set') unless directory
+      raise PageError.new('Page.default_directory must be set') unless default_directory
+      raise PageError.new('Page.plugins_directory must be set') unless plugins_directory
+    end
+end

data/lib/wiki/random_id.rb

@@ -0,0 +1,5 @@
+module RandomId
+  def self.generate
+    (0..15).collect{(rand*16).to_i.to_s(16)}.join
+  end
+end

data/lib/wiki/server.rb

@@ -0,0 +1,336 @@
+require 'rubygems'
+require 'bundler'
+require 'pathname'
+Bundler.require
+
+$LOAD_PATH.unshift(File.dirname(__FILE__))
+SINATRA_ROOT = File.expand_path(File.dirname(__FILE__))
+APP_ROOT = File.expand_path(File.join(SINATRA_ROOT, "..", ".."))
+
+Encoding.default_external = Encoding::UTF_8
+
+require 'server_helpers'
+require 'stores/all'
+require 'random_id'
+require 'page'
+require 'favicon'
+
+require 'openid'
+require 'openid/store/filesystem'
+
+class Controller < Sinatra::Base
+  set :port, 1111
+  set :public, File.join(APP_ROOT, "client")
+  set :views , File.join(SINATRA_ROOT, "views")
+  set :haml, :format => :html5
+  set :versions, `git log -10 --oneline` || "no git log"
+  if ENV.include?('SESSION_STORE')
+    use ENV['SESSION_STORE'].split('::').inject(Object) { |mod, const| mod.const_get(const) }
+  else
+    enable :sessions
+  end
+  helpers ServerHelpers
+
+  Store.set ENV['STORE_TYPE'], APP_ROOT
+
+  class << self # overridden in test
+    def data_root
+      File.join APP_ROOT, "data"
+    end
+  end
+
+  def farm_page(site=request.host)
+    page = Page.new
+    page.directory = File.join data_dir(site), "pages"
+    page.default_directory = File.join APP_ROOT, "default-data", "pages"
+    page.plugins_directory = File.join APP_ROOT, "client", "plugins"
+    Store.mkdir page.directory
+    page
+  end
+
+  def farm_status(site=request.host)
+    status = File.join data_dir(site), "status"
+    Store.mkdir status
+    status
+  end
+
+  def data_dir(site)
+    Store.farm?(self.class.data_root) ? File.join(self.class.data_root, "farm", site) : self.class.data_root
+  end
+
+  def identity
+    default_path = File.join APP_ROOT, "default-data", "status", "local-identity"
+    real_path = File.join farm_status, "local-identity"
+    id_data = Store.get_hash real_path
+    id_data ||= Store.put_hash(real_path, FileStore.get_hash(default_path))
+  end
+
+  post "/logout" do
+    session.delete :authenticated
+    redirect "/"
+  end
+
+  post '/login' do
+    begin
+      root_url = request.url.match(/(^.*\/{2}[^\/]*)/)[1]
+      identifier_file = File.join farm_status, "open_id.identifier"
+      identifier = Store.get_text(identifier_file)
+      unless identifier
+        identifier = params[:identifier]
+      end
+      open_id_request = openid_consumer.begin(identifier)
+
+      redirect open_id_request.redirect_url(root_url, root_url + "/login/openid/complete")
+    rescue
+      oops 400, "Trouble starting OpenID<br>Did you enter a proper endpoint?"
+    end
+  end
+
+  get '/login/openid/complete' do
+    begin
+      response = openid_consumer.complete(params, request.url)
+      case response.status
+        when OpenID::Consumer::FAILURE
+          oops 401, "Login failure"
+        when OpenID::Consumer::SETUP_NEEDED
+          oops 400, "Setup needed"
+        when OpenID::Consumer::CANCEL
+          oops 400, "Login cancelled"
+        when OpenID::Consumer::SUCCESS
+          id = params['openid.identity']
+          id_file = File.join farm_status, "open_id.identity"
+          stored_id = Store.get_text(id_file)
+          if stored_id
+            if stored_id == id
+              # login successful
+              authenticate!
+            else
+              oops 403, "This is not your wiki"
+            end
+          else
+            Store.put_text id_file, id
+            # claim successful
+            authenticate!
+          end
+        else
+          oops 400, "Trouble with OpenID"
+      end
+    rescue
+      oops 400, "Trouble running OpenID<br>Did you enter a proper endpoint?"
+    end
+  end
+
+  get '/system/slugs.json' do
+    content_type 'application/json'
+    cross_origin
+    JSON.pretty_generate(Dir.entries(farm_page.directory).reject{|e|e[0] == '.'})
+  end
+
+  get '/favicon.png' do
+    content_type 'image/png'
+    headers 'Cache-Control' => "max-age=3600"
+    cross_origin
+    Favicon.get_or_create(File.join farm_status, 'favicon.png')
+  end
+
+  get '/random.png' do
+    unless authenticated? or (!identified? and !claimed?)
+      halt 403
+      return
+    end
+
+    content_type 'image/png'
+    path = File.join farm_status, 'favicon.png'
+    Store.put_blob path, Favicon.create_blob
+  end
+
+  get '/' do
+    redirect "/#{identity['root']}.html"
+  end
+
+  get %r{^/data/([\w -]+)$} do |search|
+    content_type 'application/json'
+    cross_origin
+    pages = Store.annotated_pages farm_page.directory
+    candidates = pages.select do |page|
+      datasets = page['story'].select do |item|
+        item['type']=='data' && item['text'] && item['text'].index(search)
+      end
+      datasets.length > 0
+    end
+    halt 404 unless candidates.length > 0
+    JSON.pretty_generate(candidates.first)
+  end
+
+  get %r{^/([a-z0-9-]+)\.html$} do |name|
+    halt 404 unless farm_page.exists?(name)
+    haml :page, :locals => { :page => farm_page.get(name), :page_name => name }
+  end
+
+  get %r{^((/[a-zA-Z0-9:.-]+/[a-z0-9-]+(_rev\d+)?)+)$} do
+    elements = params[:captures].first.split('/')
+    pages = []
+    elements.shift
+    while (site = elements.shift) && (id = elements.shift)
+      if site == 'view'
+        pages << {:id => id}
+      else
+        pages << {:id => id, :site => site}
+      end
+    end
+    haml :view, :locals => {:pages => pages}
+  end
+
+  get '/system/plugins.json' do
+    content_type 'application/json'
+    cross_origin
+    plugins = []
+    path = File.join(APP_ROOT, "client/plugins")
+    pathname = Pathname.new path
+    Dir.glob("#{path}/*/") {|filename| plugins << Pathname.new(filename).relative_path_from(pathname)}
+    JSON.pretty_generate plugins
+  end
+
+  get '/system/sitemap.json' do
+    content_type 'application/json'
+    cross_origin
+    pages = Store.annotated_pages farm_page.directory
+    sitemap = pages.collect {|p| {"slug" => p['name'], "title" => p['title'], "date" => p['updated_at'].to_i*1000, "synopsis" => synopsis(p)}}
+    JSON.pretty_generate sitemap
+  end
+
+  get '/system/factories.json' do
+    content_type 'application/json'
+    cross_origin
+    # return "[]"
+    factories = Dir.glob(File.join(APP_ROOT, "client/plugins/*/factory.json")).collect do |info|
+      begin
+        JSON.parse(File.read(info))
+      rescue
+      end
+    end.reject {|info| info.nil?}
+    JSON.pretty_generate factories
+  end
+
+  get %r{^/([a-z0-9-]+)\.json$} do |name|
+    content_type 'application/json'
+    serve_page name
+  end
+
+  error 403 do
+    'Access forbidden'
+  end
+
+  put %r{^/page/([a-z0-9-]+)/action$} do |name|
+    unless authenticated? or (!identified? and !claimed?)
+      halt 403
+      return
+    end
+
+    action = JSON.parse params['action']
+    if site = action['fork']
+      # this fork is bundled with some other action
+      page = JSON.parse RestClient.get("#{site}/#{name}.json")
+      ( page['journal'] ||= [] ) << { 'type' => 'fork', 'site' => site }
+      farm_page.put name, page
+      action.delete 'fork'
+    elsif action['type'] == 'create'
+      return halt 409 if farm_page.exists?(name)
+      page = action['item'].clone
+    elsif action['type'] == 'fork'
+      if action['item']
+        page = action['item'].clone
+        action.delete 'item'
+      else
+        page = JSON.parse RestClient.get("#{action['site']}/#{name}.json")
+      end
+    else
+      page = farm_page.get(name)
+    end
+
+    case action['type']
+    when 'move'
+      page['story'] = action['order'].collect{ |id| page['story'].detect{ |item| item['id'] == id } || raise('Ignoring move. Try reload.') }
+    when 'add'
+      before = action['after'] ? 1+page['story'].index{|item| item['id'] == action['after']} : 0
+      page['story'].insert before, action['item']
+    when 'remove'
+      page['story'].delete_at page['story'].index{ |item| item['id'] == action['id'] }
+    when 'edit'
+      page['story'][page['story'].index{ |item| item['id'] == action['id'] }] = action['item']
+    when 'create', 'fork'
+      page['story'] ||= []
+    else
+      puts "unfamiliar action: #{action.inspect}"
+      status 501
+      return "unfamiliar action"
+    end
+    ( page['journal'] ||= [] ) << action
+    farm_page.put name, page
+    "ok"
+  end
+
+  get %r{^/remote/([a-zA-Z0-9:\.-]+)/([a-z0-9-]+)\.json$} do |site, name|
+    content_type 'application/json'
+    host = site.split(':').first
+    if serve_resources_locally?(host)
+      serve_page(name, host)
+    else
+      RestClient.get "#{site}/#{name}.json" do |response, request, result, &block|
+        case response.code
+        when 200
+          response
+        when 404
+          halt 404
+        else
+          response.return!(request, result, &block)
+        end
+      end
+    end
+  end
+
+  get %r{^/remote/([a-zA-Z0-9:\.-]+)/favicon.png$} do |site|
+    content_type 'image/png'
+    host = site.split(':').first
+    if serve_resources_locally?(host)
+      Favicon.get_or_create(File.join farm_status(host), 'favicon.png')
+    else
+      RestClient.get "#{site}/favicon.png"
+    end
+  end
+
+  not_found do
+    oops 404, "Page not found"
+  end
+
+  put '/submit' do
+    content_type 'application/json'
+    bundle = JSON.parse params['bundle']
+    spawn = "#{(rand*1000000).to_i}.#{request.host}"
+    site = request.port == 80 ? spawn : "#{spawn}:#{request.port}"
+    bundle.each do |slug, page|
+      farm_page(spawn).put slug, page
+    end
+    citation = {
+      "type"=> "reference",
+      "id"=> RandomId.generate,
+      "site"=> site,
+      "slug"=> "recent-changes",
+      "title"=> "Recent Changes",
+      "text"=> bundle.collect{|slug, page| "<li> [[#{page['title']||slug}]]"}.join("\n")
+    }
+    action = {
+      "type"=> "add",
+      "id"=> citation['id'],
+      "date"=> Time.new.to_i*1000,
+      "item"=> citation
+    }
+    slug = 'recent-submissions'
+    page = farm_page.get slug
+    (page['story']||=[]) << citation
+    (page['journal']||=[]) << action
+    farm_page.put slug, page
+    JSON.pretty_generate citation
+  end
+
+end