rum 0.0.1-x86-mswin32-60

data/lib/rum.rb

@@ -0,0 +1,4 @@
+require 'rum/core'
+require 'rum/dsl'
+
+puts "Rum loaded."

data/lib/rum/apps.rb

@@ -0,0 +1,4 @@
+case Platform
+when :mac     then require 'rum/mac/apps'
+when :windows then require 'rum/windows/apps'
+end

data/lib/rum/barrel.rb

@@ -0,0 +1,157 @@
+# encoding: utf-8
+
+module Rum
+  class Path
+    def self.contents dir
+      paths = []
+      dir = File.join(dir, '')
+      dir_dots = /(?:^|\/)\.\.?$/ # /.. or /.
+      Dir.glob(dir + '**/*', File::FNM_DOTMATCH).each do |path|
+        sub_path = path[(dir.length)..-1].encode(Encoding::UTF_8, \
+                                                 Encoding::ISO_8859_1)
+        paths << sub_path unless sub_path =~ dir_dots
+      end
+      paths
+    end
+    
+    def self.select dir
+      path = Gui.choose(nil, contents(dir))
+      (File.join(dir, path)) if path
+    end
+    
+    def self.run path
+      start path
+    end
+
+    def self.select_and_run dir
+      path = select(dir)
+      run path if path
+    end
+
+    def self.sanitize path
+      path.gsub(/[\/\\|?*><":]/, '-')
+    end
+
+    def self.normalize path
+      path.gsub('\\', '/')
+    end
+  end
+  
+  module AppDir
+    class << self
+      attr_accessor :base_dir
+      
+      def get(exe)
+        File.join(@base_dir, exe, '')
+      end
+      
+      def get_or_create(exe)
+        dir = get(exe)
+        if File.exists? dir
+          dir
+        else
+          prompt = "App-Dir für #{exe.capitalize} anlegen?"
+          if "Erzeugen" == Gui.choose(prompt, ["Erzeugen", "Nicht erzeugen"])
+            Dir.mkdir dir
+            dir
+          end
+        end
+      end
+
+      def current
+        get_or_create(active_window.exe_name)
+      end
+
+      def visit
+        dir = current
+        Dopus.go dir if dir
+      end
+
+      def select
+        dir = current
+        Path.select_and_run dir if dir
+      end
+    end
+  end
+
+  module Commands
+    class Command
+      def initialize(name, proc)
+        @name = name
+        @proc = proc
+      end
+
+      def to_s
+        @name
+      end
+
+      def run
+        @proc.call
+      end
+    end
+    
+    class << self
+      attr_accessor :default_tag
+      attr_accessor :commands
+      Commands.commands = {}
+
+      def command(name, *args, &block)
+        args = args.first
+        tag = args[:tag] if args
+        tags = []
+        tags << tag if tag
+        tags << default_tag
+        tags.uniq!
+        
+        if args and (hotkey = args[:hotkey])
+          apps = tags.select { |tag| tag.is_a? App }
+          apps.each { |app| hotkey.do(app, &block) }
+        end
+        
+        cmd = Command.new(name, block)
+        tags.each do |tag|
+          commands_for_tag = (commands[tag] ||= {})
+          commands_for_tag[name] = cmd
+        end
+      end
+
+      def [] (tag=nil)
+        if (cmds = @commands[tag])
+          cmds.values
+        else
+          []
+        end
+      end
+
+      def select(tag=nil)
+        cmd = Gui.choose(nil, self[tag])
+        cmd.run if cmd
+      end
+
+      def for_active_window
+        cmds = []
+        exe = active_window.exe_name
+        app = App.for_exe(exe)
+        cmds.concat self[app] if app
+        if (dir = AppDir.get(exe))
+          cmds.concat Path.contents(dir)
+        end
+        if (chosen = Gui.choose(nil, cmds))
+          case chosen
+          when String
+            Path.run(dir + chosen)
+          else
+            chosen.run
+          end
+        end
+      end
+    end
+  end
+
+  def Commands(tag=nil, &block)
+    Commands.default_tag = tag
+    Commands.instance_eval(&block)
+  ensure
+    Commands.default_tag = nil
+  end
+end

data/lib/rum/barrel/emacs.rb

@@ -0,0 +1,44 @@
+require 'rum/barrel/emacs_client'
+
+class << Emacs
+  attr_accessor :client, :eval_in_user_buffer
+
+  Emacs.client = EmacsClient.new
+
+  def eval(elisp)
+    # MacRuby hack
+    # @client.eval fails
+    elisp = "(with-current-buffer (window-buffer) #{elisp})" if @eval_in_user_buffer
+    Emacs.client.eval(elisp)
+  end
+
+  def funcall(*args)
+    eval("(#{args.join(' ')})")
+  end
+
+  Quoting = [["\n", '\n'],
+             ['"', '\\"']]
+
+  def quote(str)
+    str.gsub!('\\', '\\\\\\\\')
+    Quoting.each { |from, to|  str.gsub!(from, to) }
+    '"' << str << '"'
+  end
+
+  def unquote(str)
+    Quoting.reverse.each { |from, to| str.gsub!(to, from) }
+    str.gsub('\\\\', '\\').chomp[1..-2]
+  end
+
+  def find_file(path, line)
+    line = if line.is_a? Fixnum
+             "(goto-line #{line})"
+           end
+    eval("(progn (find-file \"#{path}\")#{line})")
+  end
+
+  def open_file(path, line=nil)
+    Emacs.activate
+    Emacs.find_file(path, line)
+  end
+end

data/lib/rum/barrel/emacs_client.rb

@@ -0,0 +1,74 @@
+require 'socket'
+
+# Ruby implementation of
+# emacs_source/lib-src/emacsclient.c
+
+class EmacsClient
+  def eval(elisp)
+    socket = connect
+    socket.puts "-eval #{quote(elisp)}"
+    result = unquote(socket.read)
+    socket.close
+    format(result)
+  end
+
+  def format(str)
+    str[/.*? (.*)/, 1]
+  end
+
+  def quote str
+    r = str.gsub(/&|^-/, '&\&').gsub("\n", '&n').gsub(' ', '&_')
+  end
+
+  def unquote str
+    str.gsub(/&(.)/) do
+      case $1
+      when 'n'; "\n"
+      when '_'; ' '
+      else $1
+      end
+    end
+  end
+
+  if RUBY_PLATFORM =~ /mswin|mingw/
+    attr_accessor :ip, :port, :auth_string
+
+    def initialize
+      @server_file = File.join(ENV['HOME'], '.emacs.d', 'server', 'server')
+      read_config
+    end
+    
+    def read_config
+      @server_active = File.exists? @server_file
+      return unless @server_active
+      lines = File.readlines(@server_file)
+      @ip, @port = lines.first.match(/(.*?):(\d+)/).captures
+      @auth_string = lines.last
+    end
+
+    def create_socket
+      return unless @server_active
+      begin
+      	socket = TCPSocket.open(@ip, @port)
+        socket.write "-auth #@auth_string "
+        socket
+      rescue SystemCallError
+      end
+    end
+
+    def connect
+      create_socket or (read_config and create_socket) \
+      or raise "Can't connect to Emacs Server."
+    end
+  else # Unix
+    def initialize
+      @socket_path = File.join(ENV['TMPDIR'], "emacs#{Process::Sys.geteuid}", 'server')
+    end
+
+    def connect
+      UNIXSocket.open(@socket_path)
+    rescue SystemCallError => error
+      raise "Can't connect to Emacs Server\n" << error.message
+    end
+  end
+end

data/lib/rum/core.rb

@@ -0,0 +1,125 @@
+require 'rum/hotkey_core'
+require 'rum/help'
+require 'rum/gui'
+require 'rum/barrel'
+require 'thread'
+
+case RUBY_DESCRIPTION
+when /mswin|mingw/ then require 'rum/windows'
+when /MacRuby/     then require 'rum/mac'
+else raise "Platform not yet supported: #{RUBY_PLATFORM}"
+end
+
+Encoding.default_external = Encoding::UTF_8
+
+module Rum
+  autoload :Server, 'rum/server'
+  
+  class << self
+    attr_writer :layout
+    attr_reader :hotkey_set, :hotkey_processor, \
+                :work_queue, :worker_thread
+
+    def layout
+      @layout ||= Layouts.default_layout
+    end
+    
+    def setup
+      return if setup_completed?
+      @hotkey_set = HotkeySet.new(layout)
+      @hotkey_processor = HotkeyProcessor.new(@hotkey_set)
+    end
+
+    def setup_completed?
+      !!@hotkey_set
+    end
+
+    def start
+      setup
+      Thread.abort_on_exception = true
+      @work_queue = Action.work_queue = Queue.new
+      @worker_thread = start_worker_thread(@work_queue)
+
+      KeyboardHook.start &@hotkey_processor.method(:process_event)
+    end
+
+    def stop
+      KeyboardHook.stop
+    end
+
+    def start_worker_thread(queue)
+      Thread.new do
+        while action = queue.deq
+          begin
+            action.call
+          rescue => exception
+            display_exception exception
+          end
+        end
+      end
+    end
+
+    def display_exception(exception)
+      error_message = ["#{exception.class}:", exception,
+                       '', *exception.backtrace].join("\n")
+
+      file, line = parse_stack_frame(exception.backtrace.first)
+      if file
+        file = File.expand_path(file)
+        callback = lambda do
+          Gui.message("Click here to jump to the last error:\n\n#{file}:#{line}") do
+            Gui.message error_message, :sticky
+            Gui.open_file file, line
+          end
+        end
+      end
+      
+      Gui.message error_message, :sticky, &callback
+    end
+
+    def parse_stack_frame(frame)
+      if match = frame.match(/^(.+?):(\d+)/)
+        file, line = match.captures
+        # Different file names in IRB stackframes:
+        # Ruby 1.9.1: (eval)
+        # Ruby 1.9.2: <main>
+        # MacRuby 0.10: /working_directory/(eval)
+        if file !~ /\(eval\)$/ and file != '<main>'
+          [file, line.to_i]
+        end
+      end
+    end
+
+    def switch_worker_thread
+      return unless Thread.current == @worker_thread
+      old = @work_queue
+      new = @work_queue = Action.work_queue = Queue.new
+      new.enq(old.deq) until old.length == 0
+      @worker_thread = start_worker_thread(new)
+      old.enq nil # Signal the worker thread to stop
+    end
+  end
+
+  WorkingDir = Dir.pwd
+  
+  def restart
+    Dir.chdir WorkingDir
+    if Thread.current == Rum::Server.thread
+      Thread.new do
+        sleep 0.01 # Allow server to respond. Slightly hacky.
+        restart_platform_specific
+      end
+      true
+    else
+      restart_platform_specific
+    end
+  end
+  
+  def show
+    System.terminal_window.show
+  end
+
+  def hide
+    System.terminal_window.hide
+  end
+end

data/lib/rum/dsl.rb

@@ -0,0 +1,109 @@
+include Rum
+include System
+include Keyboard
+
+module Rum
+  class Action
+    def register
+      Rum.hotkey_set.register(self)
+    end
+    
+    def unregister
+      Rum.hotkey_set.unregister(self)
+    end
+  end
+
+  class FileLocation
+    def initialize(file, line)
+      @file = file
+      @line = line
+    end
+
+    def self.from_stack_frame(frame)
+      file, line = Rum.parse_stack_frame(frame)
+      if file
+        file = File.expand_path(file) if File.dirname(file) == '.'
+        new(file, line)
+      end
+    end
+
+    def show
+      Gui.open_file(@file, @line)
+      true
+    end
+  end
+end
+
+module GuiMixin
+  # Delegating to Gui instead of directly including Gui avoids dealing
+  # with module hierarchy corner cases that appear when other modules
+  # are later dynamically included into Gui via Gui.use.
+  [:message, :alert, :read, :choose, :open_file, :browse, :goto].each do |method_name|
+    define_method(method_name) do |*args, &block|
+      Gui.send(method_name, *args, &block)
+    end
+    private method_name
+  end
+end
+include GuiMixin
+
+def wait(timeout=5, interval=0.01)
+  start = Time.new
+  loop do
+    return true if yield
+    sleep interval
+    return false if Time.new - start > timeout
+  end
+end
+
+class String
+  def do(*options, &action)
+    repeated = true
+    options.reject! do |option|
+      case option
+      when :no_repeat
+        repeated = false
+      when String
+        action = lambda { Keyboard.type option }
+      end
+    end
+    if (condition = options.first) and condition.respond_to? :to_matcher
+      matcher = condition.to_matcher
+      condition = lambda { matcher.active? }
+    end
+    location = FileLocation.from_stack_frame(caller.first)
+    Rum.hotkey_set.add_hotkey(self, action, condition, repeated, location)
+  end
+
+  def unregister
+    Rum.hotkey_set.remove_hotkey(self)
+  end
+
+  def translate condition=nil, to
+    if condition and condition.respond_to? :to_matcher
+      matcher = condition.to_matcher
+      condition = lambda { matcher.active? }
+    end
+    Rum.hotkey_set.add_translation(self, to, condition,
+                                   FileLocation.from_stack_frame(caller.first))
+  end
+end
+
+class String
+  # Prepare a special version of #do that is only active when the user
+  # calls #do for the first time.
+  # After running Rum.setup it calls and restores the default version of #do.
+  alias :old_do :do
+  def do(*args, &block)
+    Rum.setup
+    String.class_eval do
+      alias :do :old_do
+      undef_method :old_do
+    end
+    action = self.do(*args, &block)
+    # The original location has been invalidated by the
+    # extra call to #do. Replace it.
+    action.location = FileLocation.from_stack_frame(caller.first)
+    action
+  end
+end