ver 2009.12.14 → 2010.02

data/config/theme/newLISP.rb

@@ -0,0 +1,183 @@
+# Encoding: UTF-8
+
+{comment: "Ober (modified Sunburst)",
+ name: "newLISP",
+ settings: 
+  [{settings: 
+     {background: "#FFFFFF",
+      caret: "#A7A7A7",
+      foreground: "#000000",
+      invisibles: "#CAE2FB3D",
+      lineHighlight: "#FFFFFF0D",
+      selection: "#C7D8E2"}},
+   {name: "Comment",
+    scope: "comment",
+    settings: {fontStyle: "", foreground: "#555555"}},
+   {name: "Constant", scope: "constant", settings: {foreground: "#685500"}},
+   {name: "Entity",
+    scope: "entity",
+    settings: {fontStyle: "bold", foreground: "#090909"}},
+   {name: "Keyword",
+    scope: "keyword",
+    settings: {fontStyle: "bold", foreground: "#1F27B7"}},
+   {name: "Storage",
+    scope: "storage",
+    settings: {fontStyle: "bold", foreground: "#1F27B7"}},
+   {name: "String",
+    scope: "string",
+    settings: {fontStyle: "", foreground: "#006801"}},
+   {name: "Support",
+    scope: "support",
+    settings: {fontStyle: "", foreground: "#1F27B7"}},
+   {name: "Variable", scope: "variable", settings: {foreground: "#1F27B7"}},
+   {name: "Invalid – Deprecated",
+    scope: "invalid.deprecated",
+    settings: 
+     {background: "#FFFFB9",
+      fontStyle: "italic underline",
+      foreground: "#808000"}},
+   {name: "Invalid – Illegal",
+    scope: "invalid.illegal",
+    settings: {background: "#800000", foreground: "#FFFFFF"}},
+   {name: "-----------------------------------", settings: {}},
+   {name: "♦ Embedded Source (Bright)",
+    scope: "text source",
+    settings: {background: "#B1B3BA08"}},
+   {name: "♦ Entity inherited-class",
+    scope: "entity.other.inherited-class",
+    settings: {fontStyle: "", foreground: "#9B5C2E"}},
+   {name: "♦ String embedded-source",
+    scope: "string.quoted source",
+    settings: {fontStyle: "", foreground: "#A38345"}},
+   {name: "♦ String constant",
+    scope: "string constant",
+    settings: {fontStyle: "", foreground: "#A38345"}},
+   {name: "♦ String.regexp",
+    scope: "string.regexp",
+    settings: {foreground: "#A38345"}},
+   {name: "♦ String.regexp.«special»",
+    scope: 
+     "string.regexp constant.character.escape, string.regexp source.ruby.embedded, string.regexp string.regexp.arbitrary-repitition",
+    settings: {foreground: "#CF7D34"}},
+   {name: "♦ String variable",
+    scope: "string variable",
+    settings: {foreground: "#8A9A95"}},
+   {name: "♦ Support.function",
+    scope: "support.function",
+    settings: {fontStyle: "", foreground: "#1F27B7"}},
+   {name: "♦ Support.constant",
+    scope: "support.constant",
+    settings: {fontStyle: "", foreground: "#685500"}},
+   {name: "c C/C++ Preprocessor Line",
+    scope: "meta.preprocessor.c",
+    settings: {foreground: "#8996A8"}},
+   {name: "c C/C++ Preprocessor Directive",
+    scope: "meta.preprocessor.c keyword",
+    settings: {foreground: "#AFC4DB"}},
+   {name: "j Entity Name Type",
+    scope: "entity.name.type",
+    settings: {fontStyle: "bold"}},
+   {name: "j Cast",
+    scope: "meta.cast",
+    settings: {fontStyle: "italic", foreground: "#676767"}},
+   {name: "✘ Doctype/XML Processing",
+    scope: 
+     "meta.sgml.html meta.doctype, meta.sgml.html meta.doctype entity, meta.sgml.html meta.doctype string, meta.xml-processing, meta.xml-processing entity, meta.xml-processing string",
+    settings: {foreground: "#494949"}},
+   {name: "✘ Meta.tag.«all»",
+    scope: "meta.tag, meta.tag entity",
+    settings: {fontStyle: "", foreground: "#006801"}},
+   {name: "✘ Meta.tag.inline",
+    scope: 
+     "source entity.name.tag, source entity.other.attribute-name, meta.tag.inline, meta.tag.inline entity",
+    settings: {fontStyle: "", foreground: "#685500"}},
+   {name: "✘ Namespaces",
+    scope: "entity.name.tag.namespace, entity.other.attribute-name.namespace",
+    settings: {fontStyle: "", foreground: "#B71A18"}},
+   {name: "§ css tag-name",
+    scope: "meta.selector.css entity.name.tag",
+    settings: {fontStyle: "", foreground: "#B71A18"}},
+   {name: "§ css:pseudo-class",
+    scope: "meta.selector.css entity.other.attribute-name.tag.pseudo-class",
+    settings: {foreground: "#8F9D6A"}},
+   {name: "§ css#id",
+    scope: "meta.selector.css entity.other.attribute-name.id",
+    settings: {foreground: "#000000"}},
+   {name: "§ css.class",
+    scope: "meta.selector.css entity.other.attribute-name.class",
+    settings: {fontStyle: "", foreground: "#000000"}},
+   {name: "§ css property-name:",
+    scope: "support.type.property-name.css",
+    settings: {fontStyle: "bold", foreground: "#1F27B7"}},
+   {name: "§ css property-value;",
+    scope: 
+     "meta.property-group support.constant.property-value.css, meta.property-value support.constant.property-value.css",
+    settings: {foreground: "#000000"}},
+   {name: "§ css @at-rule",
+    scope: "meta.preprocessor.at-rule keyword.control.at-rule",
+    settings: {foreground: "#8693A5"}},
+   {name: "§ css additional-constants",
+    scope: 
+     "meta.property-value support.constant.named-color.css, meta.property-value constant",
+    settings: {foreground: "#685500"}},
+   {name: "§ css constructor.argument",
+    scope: "meta.constructor.argument.css",
+    settings: {foreground: "#8F9D6A"}},
+   {name: "⎇ diff.header",
+    scope: "meta.diff, meta.diff.header",
+    settings: 
+     {background: "#0E2231", fontStyle: "italic", foreground: "#F8F8F8"}},
+   {name: "⎇ diff.deleted",
+    scope: "markup.deleted",
+    settings: {background: "#420E09", foreground: "#F8F8F8"}},
+   {name: "⎇ diff.changed",
+    scope: "markup.changed",
+    settings: {background: "#4A410D", foreground: "#F8F8F8"}},
+   {name: "⎇ diff.inserted",
+    scope: "markup.inserted",
+    settings: {background: "#253B22", foreground: "#F8F8F8"}},
+   {name: "--------------------------------", settings: {}},
+   {name: "Markup: Italic",
+    scope: "markup.italic",
+    settings: {fontStyle: "italic", foreground: "#CB0202"}},
+   {name: "Markup: Bold",
+    scope: "markup.bold",
+    settings: {fontStyle: "bold", foreground: "#CB0202"}},
+   {name: "Markup: Underline",
+    scope: "markup.underline",
+    settings: {fontStyle: "underline", foreground: "#CB0202"}},
+   {name: "Markup: Quote",
+    scope: "markup.quote",
+    settings: 
+     {background: "#F8F7E4", fontStyle: "italic", foreground: "#408000"}},
+   {name: "Markup: Heading",
+    scope: "markup.heading, markup.heading entity",
+    settings: {background: "#632D04", fontStyle: "", foreground: "#FEDCC5"}},
+   {name: "Markup: List",
+    scope: "markup.list",
+    settings: {foreground: "#908978"}},
+   {name: "Markup: Raw",
+    scope: "markup.raw",
+    settings: {background: "#B1B3BA08", fontStyle: "", foreground: "#26368F"}},
+   {name: "Markup: Comment",
+    scope: "markup comment",
+    settings: {fontStyle: "italic", foreground: "#F67B37"}},
+   {name: "Markup: Separator",
+    scope: "meta.separator",
+    settings: {background: "#242424", foreground: "#60A633"}},
+   {name: "Log Entry",
+    scope: "meta.line.entry.logfile, meta.line.exit.logfile",
+    settings: {background: "#EEEEEE29"}},
+   {name: "Log Entry Error",
+    scope: "meta.line.error.logfile",
+    settings: {background: "#751012"}},
+   {name: "Namespace",
+    scope: "namespace.lsp",
+    settings: {background: "#94410A", fontStyle: "bold"}},
+   {name: "newLISP: paren",
+    scope: "operator.lsp",
+    settings: {fontStyle: "", foreground: "#B71A18"}},
+   {name: "String Delimiter",
+    scope: "punctuation.definition.string.lsp",
+    settings: {fontStyle: "", foreground: "#006801"}}],
+ uuid: "1EB2144B-4567-4860-B4B1-890DA804195C"}

data/config/welcome

@@ -4,26 +4,22 @@
 
 This project can be found at: http://github.com/manveru/ver
 
-Notes:
-  * M usually stands for the alt key on your keyboard.
-
-Various help commands (all not implemented yet):
-  [M-h h] : Open help browser
-  [M-h k] : Query help for key
-  [M-h g] : Grep help
-  [M-h t] : Open tutorial
-
 Quick intro:
 
 VER is a modal editor, drawing from both Emacs and Vim for inspiration, as they are both excellent projects but have very different downsides.
 I tried to address these downsides:
 
-  * Use of a real programming language (Ruby) for implementation, configuration and scripting (no ancient elisp or crazy vimscript)
-  * Easy to use keymappings to emulate other editors while maintaining the strength of a live environment.
-  * I don't intend this editor to be everything for everybody, it's just useful for myself for now.
-  * Make editing powerful without years of learning and remembering arcane shortcuts, and don't require users of the editor to sacrifice their wrists.
+  * Use of a real programming language (Ruby) for implementation, configuration
+    and scripting (no ancient elisp or crazy vimscript)
+  * Easy to use keymappings to emulate other editors while maintaining the
+    strength of a live environment.
+  * I don't intend this editor to be everything for everybody, it's just useful
+    for myself for now.
+  * Make editing powerful without years of learning and remembering arcane
+    shortcuts, and don't require users of the editor to sacrifice their wrists.
   * Allow project-based browsing and grepping right from the start.
-  * Easily identify the mode you are in by looking at the color of the status line and cursor.
+  * Easily identify the mode you are in by looking at the color of the status
+    line and cursor.
 
 Currently working:
 

data/lib/ver.rb

@@ -4,47 +4,58 @@
 # lazy stdlib
 autoload :Benchmark, 'benchmark'
 autoload :FileUtils, 'fileutils'
-
-# 3rd party
-require 'eventmachine'
+autoload :Tempfile,  'tempfile'
 
 # eager stdlib
 require 'digest/sha1'
-require 'json'
-# require 'pp'
 require 'securerandom'
 require 'set'
-require 'pathname'
-
-autoload :SizedArray, 'ver/vendor/sized_array'
+require 'ver/vendor/better_pp_hash'
+require 'ver/vendor/pathname'
+require 'ver/vendor/sized_array'
 
+# This is the doc for VER
 module VER
+  autoload :Action,              'ver/action'
+  autoload :Bookmarks,           'ver/methods/bookmark'
+  autoload :Buffer,              'ver/buffer'
   autoload :Entry,               'ver/entry'
-  autoload :Help,                'ver/help'
+  autoload :ExceptionView,       'ver/exception_view'
+  autoload :Executor,            'ver/executor'
   autoload :Font,                'ver/font'
+  autoload :Help,                'ver/help'
   autoload :HoverCompletion,     'ver/hover_completion'
+  autoload :KEYSYMS,             'ver/keysyms'
   autoload :Keymap,              'ver/keymap'
-  autoload :Layout,              'ver/layout'
+  autoload :Keymapped,           'ver/keymap/keymapped'
+  autoload :Levenshtein,         'ver/vendor/levenshtein'
   autoload :Methods,             'ver/methods'
-  autoload :Mode,                'ver/mode'
+  autoload :MiniBuffer,          'ver/minibuffer'
+  autoload :NotebookLayout,      'ver/layout/notebook'
+  autoload :PanedLayout,         'ver/layout/paned'
+  autoload :SYMKEYS,             'ver/keysyms'
   autoload :Status,              'ver/status'
   autoload :Syntax,              'ver/syntax'
   autoload :Text,                'ver/text'
   autoload :Textpow,             'ver/vendor/textpow'
-  autoload :Levenshtein,         'ver/vendor/levenshtein'
   autoload :Theme,               'ver/theme'
-  autoload :View,                'ver/view'
-  autoload :ExceptionView,       'ver/exception_view'
-  autoload :Bookmarks,           'ver/methods/bookmark'
-  autoload :Bookmark,            'ver/methods/bookmark'
+  autoload :TilingLayout,        'ver/layout/tiling'
+  autoload :Treeview,            'ver/treeview'
   autoload :Undo,                'ver/undo'
+  autoload :WidgetEvent,         'ver/widget_event'
+  autoload :WidgetMajorMode,     'ver/widget_major_mode'
 
+  require 'ver/major_mode'
+  require 'ver/minor_mode'
   require 'ver/options'
+
   @options = Options.new(:ver)
 
   class << self
-    attr_reader(:root, :layout, :status, :paths, :options, :bookmarks,
-                :ctag_stack)
+    attr_reader(:ctag_stack, :keymap, :style_name_pools, :style_name_register,
+                :bookmarks, :buffers, :layout, :options, :paths, :root, :status,
+                :minibuf)
+    attr_accessor :layout_class
   end
 
   # the rest of the options are in config/rc.rb
@@ -52,6 +63,9 @@ module VER
     o "Fork off on startup to avoid dying with the terminal",
       :fork, true
 
+    o "Use EventMachine inside VER, at the moment only for the console",
+      :eventmachine, false
+
     o "Internal:External encoding",
       :encoding, "UTF-8:UTF-8"
 
@@ -72,6 +86,9 @@ module VER
 
     o "Locations where we look for configuration",
       :loadpath, [home_conf_dir, core_conf_dir]
+
+    o "Name under which the session is stored (nil means to keep no session)",
+      :session, nil
   end
 
   module_function
@@ -83,56 +100,149 @@ module VER
   def run(given_options = {}, &block)
     setup_tk
     run_startup(given_options)
+    pp options if $DEBUG
 
-    forking do
-      if Tk::RUN_EVENTLOOP_ON_MAIN_THREAD
-        run_aqua(&block)
-      else
-        run_x11(&block)
-      end
+    run_maybe_forking do
+      options.eventmachine ? run_em(&block) : run_noem(&block)
     end
   rescue => exception
     VER.error(exception)
     exit
   end
 
-  def run_aqua(&block)
-    run_core
-    EM.defer(&block) if block
-    Tk.mainloop
-  end
+  def run_maybe_forking(&block)
+    return yield unless options.fork
 
-  def run_x11(&block)
-    EM.defer do
-      run_core
-      EM.defer(&block) if block
-      Tk.mainloop
+    fork do
+      trap(:HUP){ 'terminal disconnected' }
+      yield
     end
   end
 
-  def forking
-    if options.fork
-      fork do
-        trap(:HUP){ 'terminal disconnected' }
-        EM.run{ yield }
+  def run_em(&block)
+    require 'eventmachine'
+
+    EM.run do
+      if Tk::RUN_EVENTLOOP_ON_MAIN_THREAD
+        run_core
+        EM.defer(&block) if block
+        Tk.mainloop
+      else
+        EM.defer do
+          run_core
+          EM.defer(&block) if block
+          Tk.mainloop
+        end
       end
-    else
-      EM.run{ yield }
     end
   end
 
+  def run_noem(&block)
+    run_core
+    yield if block
+    Tk.mainloop
+  end
+
   def run_startup(given_options)
     first_startup unless options.home_conf_dir.directory?
+
+    @startup_hooks = []
+    @paths = Set.new
+    @cancel_blocks = {}
+    @load_plugins = Set.new
+    @exception_view = nil
+    @bookmarks = Bookmarks.new
+    @ctag_stack = []
+    @style_name_register = []
+    @style_name_pools = {}
+    @buffers = {}
+
     load 'rc'
     @options.merge!(given_options)
   end
 
   def run_core
     sanitize_options
-    # dump_options
     setup_widgets
     open_argv || open_welcome
+    open_session
     emergency_bindings
+    load_plugins
+    run_startup_hooks
+  end
+
+  def when_inactive_for(ms)
+    block = lambda{
+      if @cancel_blocks[block]
+        @cancel_blocks.delete(block)
+      else
+
+        if Tk.root.tk_inactive > ms
+          yield
+          Tk.root.tk_inactive('reset')
+          Tk::After.ms(ms, &block)
+        else
+          Tk::After.ms(ms, &block)
+        end
+      end
+    }
+
+    @cancel_blocks[block] = false
+    Tk::After.idle(&block)
+    block
+  end
+
+  def defer
+    Tk::After.idle do
+      begin
+        yield
+      rescue Exception => ex
+        VER.error(ex)
+      end
+    end
+  end
+
+  def cancel_block(block)
+    @cancel_blocks[block] = true
+  end
+
+  def run_startup_hooks
+    @startup_hooks.each(&:call)
+  end
+
+  def startup_hook(&block)
+    @startup_hooks << block
+  end
+
+  def plugin(name)
+    @load_plugins << name.to_s
+  end
+
+  def load_plugins
+    @load_plugins.each do |plugin|
+      load_plugin(plugin)
+      Tk::Event.generate(root, '<<PluginLoaded>>', data: plugin.to_s)
+    end
+  end
+
+  def load_plugin(name)
+    loadpath.each do |dirname|
+      (dirname/"plugin/#{name}.rb").glob do |rb|
+        return require(rb.to_s)
+      end
+    end
+  rescue => ex
+    error(ex)
+  end
+
+  def load_all_plugins
+    loadpath.each do |dirname|
+      (dirname/'plugin/*.rb').glob do |rb|
+        require rb
+      end
+    end
+  rescue => ex
+    error(ex)
   end
 
   def setup_tk
@@ -143,21 +253,29 @@ module VER
   def setup_widgets
     Tk::Tile.set_theme options.tk_theme
 
-    @paths = Set.new
-
     @root = Tk.root
     @root.wm_geometry = '160x80'
 
-    @layout = Layout.new(@root)
-    @layout.strategy = Layout::VerticalTiling
+    Tk::Tile::Style.configure('Label', font: options.font, sticky: :sw)
+    # Tk::Tile::Style.configure('TLabelframe', background: '#f00')
 
-    @status = Entry.new(@root, font: options.font)
-    @status.insert :end, 'For information about VER, type F1'
-    @status.pack(fill: :x)
+    setup_layout
 
-    @exception_view = nil
-    @bookmarks = Bookmarks.new
-    @ctag_stack = []
+    load("keymap/#{options.keymap}.rb")
+
+    @minibuf = MiniBuffer.new(@layout)
+    @layout.configure(
+      labelwidget: minibuf,
+      labelanchor: :sw
+    )
+
+    [:Messages, :Scratch].each do |name|
+      defer{ Buffer[name].hide }
+    end
+  end
+
+  def setup_layout
+    @layout = (layout_class || PanedLayout).new(root)
   end
 
   def sanitize_options
@@ -206,6 +324,8 @@ module VER
   end
 
   def exit
+    store_session
+    @cancel_blocks.keys.each{|key| @cancel_blocks[key] = true }
     Tk.exit rescue nil
     EM.stop rescue nil
     Kernel.exit
@@ -235,31 +355,85 @@ module VER
 
   def open_argv
     argv = ARGV.dup
-    any = false
+    openend_any = false
 
     while arg = argv.shift
-      layout.create_view do |view|
-        if argv.first =~ /\+\d+/
-          line = argv.shift.to_i
-          view.open_path(arg, line)
-        else
-          view.open_path(arg)
-        end
-
-        any = true
+      if argv.first =~ /\+\d+/
+        line = argv.shift.to_i
+        find_or_create_buffer(arg, line)
+      else
+        find_or_create_buffer(arg)
       end
+
+      opened_any = true
     end
 
-    any
+    opened_any
   end
 
   def open_welcome
-    layout.create_view do |view|
-      welcome = find_in_loadpath('welcome')
-      view.open_path(welcome)
+    if welcome = find_in_loadpath('welcome')
+      find_or_create_buffer(welcome)
+      true
     end
   end
 
+  def open_session
+    return unless session_base = options.session
+    basename = "#{session_base}.session.rb"
+    return unless file = find_in_loadpath(basename)
+
+    begin
+      session = eval(File.read(file))
+    rescue SyntaxError => ex
+      puts "#{ex.class}: #{ex}", *ex.backtrace
+      return
+    end
+
+    session[:bookmarks].each do |raw_bm|
+      bm = Bookmarks::Bookmark.new
+      bm.name = raw_bm[:name]
+      bm.file = Pathname(raw_bm[:file])
+      bm.index = raw_bm[:index]
+      bookmarks << bm
+    end
+
+    session[:buffers].each do |buffer|
+      find_or_create_buffer(buffer[:filename], *buffer[:insert])
+    end
+  end
+
+  def store_session
+    return unless session_base = VER.options.session
+    basename = "#{session_base}.session.rb"
+    session_path = loadpath.first/basename
+
+    session = {buffers: [], bookmarks: []}
+    buffers.each do |name, buffer|
+      session[:buffers] << {
+        name: name.to_s,
+        filename: buffer.filename.to_s,
+        insert: buffer.text.index(:insert).split,
+      }
+    end
+
+    bookmarks.each do |bm|
+      session[:bookmarks] << {
+        name:  bm.name,
+        file:  bm.file.to_s,
+        index: bm.index,
+      }
+    end
+
+    session_path.open('w+:UTF-8') do |io|
+      io.write(session.pretty_inspect)
+    end
+  end
+
+  def find_or_create_buffer(file, line = nil, column = nil, &block)
+    Buffer.find_or_create(file, line, column, &block)
+  end
+
   def emergency_bindings
     Tk::Bind.bind(:all, options.emergency_exit){ exit }
   end
@@ -268,6 +442,37 @@ module VER
     @paths << text.filename
   end
 
+  def message(*args)
+    minibuf.message(*args)
+  end
+
+  def warn(*args)
+    minibuf.warn(*args)
+  end
+
+  def obtain_style_name(widget_name, widget_class)
+    suffix = "#{widget_name}.#{widget_class}"
+    pool = style_name_pools[suffix] ||= []
+    register = style_name_register
+
+    unless name = pool.shift
+      begin
+        id = SecureRandom.hex
+        name = "#{id}.#{suffix}"
+      end while register.include?(name)
+
+      register << name
+    end
+
+    return name
+  end
+
+  def return_style_name(style_name)
+    id, widget_name, widget_class = style_name.split('.')
+    suffix = "#{widget_name}.#{widget_class}"
+    style_name_pools[suffix] << style_name
+  end
+
   def dump_options
     out = []
 
@@ -303,19 +508,7 @@ module VER
   end
 
   def exception_view(exception)
-    unless @exception_view
-      @exception_view ||= ExceptionView.new(@root)
-
-      @exception_view.bind '<<TreeviewOpen>>' do
-        @exception_view.on_treeview_open
-      end
-
-      @exception_view.bind '<Escape>' do
-        @exception_view.pack_forget
-        @layout.views.first.focus
-      end
-    end
-
+    @exception_view ||= ExceptionView.new(root)
     @exception_view.show(exception)
   end
 end