rwiki 0.1.3 → 0.2.1

data/lib/rwiki.rb

@@ -6,6 +6,7 @@ require 'json/pure'
 require 'redcloth'
 require 'sinatra'
 require 'sinatra/base'
+require 'fuzzy_file_finder'
 
 module Rwiki
 

data/lib/rwiki/app.rb

@@ -2,10 +2,12 @@ module Rwiki
   class App < Sinatra::Base
     include Models
 
-    set :raise_errors, false
-    set :show_exceptions, false
     set :root, File.join(File.dirname(__FILE__), '../..')
 
+    disable :raise_errors
+    disable :show_exceptions
+    disable :logging
+
     error NodeNotFoundError do
       message = request.env['sinatra.error'].message
       { :success => false, :message => message }.to_json
@@ -55,6 +57,7 @@ module Rwiki
 
       result = node.to_hash
       result[:parentPath] = parent_folder.path
+
       result.to_json
     end
 
@@ -67,6 +70,7 @@ module Rwiki
 
       result = node.to_hash
       result[:oldPath] = path
+
       result.to_json
     end
 
@@ -81,6 +85,7 @@ module Rwiki
       result = node.to_hash
       result[:oldPath] = path
       result[:success] = true
+
       result.to_json
     end
 
@@ -91,5 +96,12 @@ module Rwiki
 
       { :path => node.path }.to_json
     end
+
+    get '/fuzzy_finder' do
+      query = params[:query]
+      matches = Node.fuzzy_finder(query)
+
+      { :results => matches, :count => matches.size }.to_json
+    end
   end
 end

data/lib/rwiki/models/folder.rb

@@ -28,7 +28,7 @@ module Rwiki::Models
       new_page_full_path = self.class.full_path_for(new_page_path)
       raise Rwiki::NodeError.new("#{new_page_path} already exists") if File.exists?(new_page_full_path)
 
-      FileUtils.touch(new_page_full_path)
+      File.open(new_page_full_path, 'w') { |f| f.write("h1. #{name.gsub(/\.txt$/, '')}\n\n") }
       return Page.new(new_page_path)
     end
 

data/lib/rwiki/models/node.rb

@@ -15,6 +15,16 @@ module Rwiki::Models
       def working_path=(path)
         @@working_path = path
       end
+
+      def fuzzy_finder(query)
+        @finder ||= FuzzyFileFinder.new(full_path_for('.'))
+        matches = @finder.find(query).sort_by { |m| [-m[:score], m[:path]] }
+        matches.each do |m|
+          m[:path] = '.' + m[:path].gsub(full_path_for('.'), '') 
+        end
+
+        return matches
+      end
     end
 
     def self.new_from_path(path)
@@ -32,7 +42,7 @@ module Rwiki::Models
     end
 
     def parent_folder
-      return Folder.new(File.dirname(@path))
+      Folder.new(File.dirname(@path))
     end
 
     def delete

data/lib/rwiki/models/page.rb

@@ -65,7 +65,7 @@ module Rwiki::Models
       @raw_content = raw_content.gsub(CODE_REGEXP) do
         code = $3 || ''
         lang = $2
-        "<notextile>#{CodeRay.scan(code.strip, lang).html(:line_numbers => :table).div(:css => :class)}</notextile>"
+        "<notextile>#{CodeRay.scan(code.strip, lang).html.div(:css => :class)}</notextile>"
       end
     end
 

data/public/javascripts/Rwiki.js

@@ -14,58 +14,100 @@ Rwiki.captureEvents = function(observable) {
 
 Rwiki.init = function() {
 
+  // TabPanel history
+  Ext.History.init();
+
+  var firstLoad = true;
+
   // TODO find better solution
-  Rwiki.ajaxCallInProgress = false;
-  $(document).ajaxStart(function() {
-    Rwiki.ajaxCallInProgress = true;
-  }).ajaxStop(function() {
-    Rwiki.ajaxCallInProgress = false;
-  });
+  Rwiki.ajaxCallCompleted = true;
+  Rwiki.treeLoaded = false;
 
-  var toolbar = new Rwiki.Toolbar();
   var treePanel = new Rwiki.TreePanel();
   Rwiki.treePanel = treePanel;
-  var treePanelContextMenu = new Rwiki.TreePanel.Menu();
-  treePanel.setContextMenu(treePanelContextMenu);
   var nodeManager = Rwiki.NodeManager.getInstance();
 
+  nodeManager.on('rwiki:beforePageLoad', function() {
+    Rwiki.ajaxCallCompleted = false;
+  });
+
+  nodeManager.on('rwiki:pageLoaded', function() {
+    Rwiki.ajaxCallCompleted = true;
+  });
+
+  treePanel.getLoader().on('load', function() {
+    Rwiki.treeLoaded = true;
+    Rwiki.treePanel.openNodeFromLocationHash();
+  });
+
   treePanel.relayEvents(nodeManager,
-    ['rwiki:folderCreated', 'rwiki:pageCreated', 'rwiki:nodeRenamed', 'rwiki:nodeDeleted']);
+    ['rwiki:pageLoaded', 'rwiki:folderCreated', 'rwiki:pageCreated', 'rwiki:nodeRenamed', 'rwiki:nodeDeleted']);
 
   var tabPanel = new Rwiki.TabPanel();
+  Rwiki.tabPanel = tabPanel;
   tabPanel.relayEvents(nodeManager,
     ['rwiki:pageLoaded', 'rwiki:folderCreated', 'rwiki:pageCreated', 'rwiki:pageSaved', 'rwiki:nodeRenamed', 'rwiki:nodeDeleted']);
   tabPanel.relayEvents(treePanel, ['pageSelected']);
 
   var editorPanel = new Rwiki.EditorPanel();
-  editorPanel.relayEvents(nodeManager,
-    ['rwiki:pageLoaded', 'rwiki:nodeRenamed', 'rwiki:nodeDeleted', 'rwiki:lastPageClosed']);
-  editorPanel.relayEvents(toolbar, ['editorToggled']);
+  editorPanel.relayEvents(Rwiki.NodeManager.getInstance(), ['rwiki:pageLoaded']);
 
-  // Create layout
+  var window = new Rwiki.EditorWindow(editorPanel);
 
-  var sidePanel = new Rwiki.SidePanel({
-    items: [treePanel]
-  });
+  function showEditor(path) {
+    if (!window.isVisible()) {
+      window.setPagePath(path);
+      window.show();
+    }
+  }
 
-  sidePanel.relayEvents(toolbar, ['treeToggled']);
+  tabPanel.on('rwiki:editPage', function(path) {
+    showEditor(path);
+  });
 
-  var pageAndEditorPanel = new Ext.Panel({
-    layout: 'border',
-    region: 'center',
-    items: [tabPanel, editorPanel]
+  // Handle this change event in order to restore the UI to the appropriate history state
+  Ext.History.on('change', function() {
+    Rwiki.treePanel.openNodeFromLocationHash();
   });
 
-  var mainPanel = new Ext.Panel({
-    layout: 'border',
-    region: 'center',
-    tbar: toolbar,
-    items: [sidePanel, pageAndEditorPanel]
+  // Create layout
+
+  var navigationPanel = new Rwiki.NavigationPanel({
+    items: [treePanel]
   });
 
-  var app = new Rwiki.Viewport({
-    items: [mainPanel]
+  var app = new Ext.Viewport({
+    layout: 'border',
+    plain: true,
+    renderTo: Ext.getBody(),
+    items: [navigationPanel, tabPanel]
   });
 
   app.show();
+
+  // map one key by key code
+  var map = new Ext.KeyMap(document, [{
+    key: "e",
+    alt: true,
+    stopEvent: true,
+    fn: function() {
+      tabPanel.onEditPage();
+    }
+  }, {
+    key: "t",
+    ctrl: true,
+    stopEvent: true,
+    fn: function() {
+      tabPanel.onFuzzyFinder();
+    }
+  }, {
+    key: "w",
+    ctrl: true,
+    stopEvent: true,
+    fn: function() {
+      var tab = tabPanel.getActiveTab();
+      tabPanel.remove(tab);
+    }
+  }]);
+  
 };

data/public/javascripts/Rwiki/EditorPanel.js

@@ -3,13 +3,8 @@ Ext.ns('Rwiki');
 Rwiki.EditorPanel = Ext.extend(Ext.Panel, {
   constructor: function() {
     Ext.apply(this, {
-      region: 'east',
       contentEl: 'editor-container',
       header: false,
-      collapseMode: 'mini',
-      split: true,
-      collapsible: true,
-      collapsed: true,
       height: 400,
 
       listeners: {
@@ -23,17 +18,13 @@ Rwiki.EditorPanel = Ext.extend(Ext.Panel, {
     });
 
     Rwiki.EditorPanel.superclass.constructor.apply(this, arguments);
-    this.editor = new Rwiki.EditorPanel.Editor($('textarea#editor'));
+    this.editor = new Rwiki.EditorPanel.Editor();
   },
 
   initEvents: function() {
     Rwiki.EditorPanel.superclass.initEvents.apply(this, arguments);
 
     this.on('rwiki:pageLoaded', this.onPageLoaded);
-    this.on('rwiki:nodeRenamed', this.onNodeRenamed);
-    this.on('rwiki:nodeDeleted', this.onNodeDeleted);
-    this.on('rwiki:lastPageClosed', this.onLastPageClosed);
-    this.on('editorToggled', this.onEditorToggled);
   },
 
   onPageLoaded: function(data) {
@@ -41,34 +32,11 @@ Rwiki.EditorPanel = Ext.extend(Ext.Panel, {
     this.editor.setContent(data.rawContent);
   },
 
-  onNodeRenamed: function(data) {
-    var oldPath = data.oldPath;
-    var currentPagePath = this.editor.getPagePath();
-    if (currentPagePath == null) return;
-
-    var isPage = oldPath.match(new RegExp('\.txt$'));
-    var currentPageWasChanged = isPage && oldPath == currentPagePath;
-    var parentPathWasChanged = Rwiki.NodeManager.getInstance().isParent(oldPath, currentPagePath);
-
-    if (currentPageWasChanged) {
-      this.editor.setPagePath(data.path);
-    } else if (parentPathWasChanged) {
-      var newPath = currentPagePath.replace(oldPath, data.path);
-      this.editor.setPagePath(newPath);
-    }
-  },
-
-  onNodeDeleted: function(data) {
-    if (data.path == this.editor.getPagePath()) {
-      this.editor.clearContent();
-    }
-  },
-
-  onLastPageClosed: function() {
-    this.editor.clearContent();
+  getPagePath: function() {
+    return this.editor.getPagePath();
   },
 
-  onEditorToggled: function() {
-    this.toggleCollapse();
+  getRawContent: function() {
+    return this.editor.getContent();
   }
 });

data/public/javascripts/Rwiki/EditorPanel/Editor.js

@@ -1,36 +1,10 @@
 Ext.ns('Rwiki.EditorPanel');
 
 Rwiki.EditorPanel.Editor = Ext.extend(Ext.util.Observable, {
-  constructor: function(container) {
+  constructor: function() {
     Rwiki.EditorPanel.Editor.superclass.constructor.apply(this, arguments);
-
-    this.container = container;
-    this.enabled = false;
-
-    // hack for FF, clear text area on load
-    this.container.val('');
-
+    this.container = $('textarea#editor');
     this.initMarkItUp();
-    this.initEvents();
-  },
-
-  initEvents: function() {
-    var self = this;
-
-    this.container.bind('keydown', function() {
-      return self.enabled;
-    });
-
-    var timeout = null;
-    this.container.bind('keyup', function() {
-      if (!self.enabled) return;
-
-      clearTimeout(timeout);
-      var callback = function() {
-        self.savePage();
-      };
-      timeout = setTimeout(callback, 500);
-    });
   },
 
   initMarkItUp: function() {
@@ -60,28 +34,18 @@ Rwiki.EditorPanel.Editor = Ext.extend(Ext.util.Observable, {
         {separator:'---------------' },
         {name:'Quotes', openWith:'bq(!(([![Class]!]))!). '},
         {separator:'---------------' },
-        {name:'Code', openWith:'<code>\n', closeWith:'\n</code>'},
-        {name:'Ruby Code', openWith:'<code lang="ruby">\n', closeWith:'\n</code>'},
-        {name:'JavaScript Code', openWith:'<code lang="javascript">\n', closeWith:'\n</code>'},
-        {name:'HTML Code', openWith:'<code lang="html">\n', closeWith:'\n</code>'},
-        {name:'Css Code', openWith:'<code lang="css">\n', closeWith:'\n</code>'}
+        {name:'Code', openWith:'<code>\n', closeWith:'\n</code>', className: 'insert-code'},
+        {name:'Ruby Code', openWith:'<code lang="ruby">\n', closeWith:'\n</code>', className: 'insert-code ruby'},
+        {name:'JavaScript Code', openWith:'<code lang="javascript">\n', closeWith:'\n</code>', className: 'insert-code javascript'},
+        {name:'HTML Code', openWith:'<code lang="html">\n', closeWith:'\n</code>', className: 'insert-code html'},
+        {name:'Css Code', openWith:'<code lang="css">\n', closeWith:'\n</code>', className: 'insert-code css'}
       ],
-      resizeHandle: false,
-      afterInsert: function() {
-        self.savePage();
-      }
+      resizeHandle: false
     };
 
     this.container.markItUp(textileSettings);
   },
 
-  savePage: function() {
-    var path = this.getPagePath();
-    var rawContent = this.getContent();
-
-    Rwiki.NodeManager.getInstance().savePage(path, rawContent);
-  },
-
   clearContent: function() {
     this.container.val('');
     this.disable();

data/public/javascripts/Rwiki/EditorWindow.js

@@ -0,0 +1,66 @@
+Ext.ns('Rwiki');
+
+Rwiki.EditorWindow = Ext.extend(Ext.Window, {
+  constructor: function(editorPanel) {
+    Ext.apply(this, {
+      maximizable: true,
+      modal: true,
+      width: 750,
+      height: 500,
+      minWidth: 300,
+      minHeight: 200,
+      layout: 'fit',
+      plain: true,
+      bodyStyle: 'padding: 5px;',
+      buttonAlign: 'center',
+      items: editorPanel,
+      buttons: [
+        {
+          text: 'Save',
+          scope: this,
+          handler: this.onSaveButton
+        },
+        {
+          text: 'Save and continue',
+          scope: this,
+          handler: this.onSaveAndContinueButton
+        },
+        {
+          text: 'Cancel',
+          scope: this,
+          handler: this.onCancelButton
+        }
+      ]
+    });
+
+    Rwiki.EditorWindow.superclass.constructor.apply(this, arguments);
+    this.editorPanel = editorPanel;
+  },
+
+  setPagePath: function(path) {
+    this.pagePath = path;
+    this.setTitle('Editing page ' + path);
+  },
+
+  show: function() {
+    Rwiki.NodeManager.getInstance().loadPage(this.pagePath);
+    Rwiki.EditorWindow.superclass.show.apply(this, arguments);
+  },
+
+  onSaveButton: function() {
+    Rwiki.NodeManager.getInstance().savePage(this.pagePath, this.editorPanel.getRawContent());
+    this.hide();
+  },
+
+  onSaveAndContinueButton: function() {
+    Rwiki.NodeManager.getInstance().savePage(this.pagePath, this.editorPanel.getRawContent());
+  },
+
+  onCancelButton: function() {
+    this.hide();
+  },
+
+  close: function() {
+    this.hide();
+  }
+});