rum 0.0.1-x86-mingw32

data/lib/rum/mac/system.rb

@@ -0,0 +1,45 @@
+module Rum
+  module System
+    extend self
+
+    def applescript src
+      pointer = Pointer.new_with_type("@")
+      as = NSAppleScript.alloc.initWithSource(src)
+      as.executeAndReturnError(pointer)  
+    end
+    
+    def start *args
+      system 'open', *args
+    end
+
+    def escape_shell_word str
+      if str.empty? or %r{\A[0-9A-Za-z+,./:=@_-]+\z} =~ str
+        str
+      else
+        result = ''
+        str.scan(/('+)|[^']+/) {
+          if $1
+            result << %q{\'} * $1.length
+          else
+            result << "'#{$&}'"
+          end
+        }
+        result
+      end
+    end
+
+    def applescript_quote_string str
+      str.gsub!('\\', '\\\\\\\\')
+      str.gsub!('"', '\\"')
+      '"' << str << '"'
+    end
+
+    def spawn_in_terminal(*args)
+      close = args.delete :close_if_successful
+      command = args.map { |arg| escape_shell_word(arg) }.join(' ')
+      command << ';[ $? -eq 0 ] && exit' if close
+      command = applescript_quote_string(command)
+      applescript 'tell application "Terminal" to do script ' + command
+    end
+  end
+end

data/lib/rum/remote.rb

@@ -0,0 +1,48 @@
+require 'socket'
+
+module Rum
+  class Remote
+    def initialize(port=Remote.default_port)
+      @connection = Connection.new(TCPSocket.open('127.0.0.1', port))
+    end
+
+    def eval code
+      @connection.dispatch code
+      @connection.receive
+    end
+
+    def disconnect
+      @connection.close
+    end
+
+    def self.default_port
+      if (port = ENV['RUM_PORT'].to_i) and port.nonzero?
+        port
+      else
+        1994
+      end
+    end
+
+    module Connection
+      module Messaging
+        # Assumes message is not larger than 4,3 GB ((2**(4*8) - 1) bytes)
+        def dispatch(msg)
+          msg.encode! Encoding::UTF_8
+          msg.force_encoding Encoding::BINARY
+          write([msg.length].pack('N') + msg)
+        end
+        
+        def receive
+          if message_size = read(4) # sizeof (N)
+            message_size = message_size.unpack('N')[0]	
+            read(message_size).force_encoding(Encoding::UTF_8)
+          end
+        end
+      end
+      
+      def Connection.new(stream)
+        stream.extend Messaging
+      end
+    end
+  end
+end

data/lib/rum/server.rb

@@ -0,0 +1,92 @@
+require 'rum/remote'
+
+module Rum
+  module Server
+    module_function
+    
+    # This makes it easier for code to check if it runs inside the server thread.
+    def thread
+      @thread
+    end
+
+    def start
+      return if @thread
+      @thread = Thread.new do
+        @server = TCPServer.new('127.0.0.1', Remote.default_port)
+        puts "Server started."
+        begin
+          @connection = nil
+          loop do
+            @connection = Remote::Connection.new(@server.accept)
+            handle(@connection)
+            @connection.close
+          end
+        ensure # clean up when thread gets killed
+          close_connections
+        end
+      end
+    end
+
+    # Temporary hack.
+    # MacRuby crashes on the ensure clause above when
+    # the server thread is killed.
+    # This function allows for manually closing the connections.
+    def close_connections
+      [@server, @connection].compact.each { |e| e.close unless e.closed? }
+    end
+
+    def stop
+      if @thread
+        @thread.kill
+        # Kill can return before the thread has finished execution. A Ruby bug?
+        @thread.join
+        @thread = nil
+      end
+    end
+
+    EvalBinding = TOPLEVEL_BINDING
+
+    def handle(connection)
+      return nil unless message = connection.receive
+      result = begin
+                 eval(message, EvalBinding).inspect
+               rescue Exception => exception
+                 error_message(exception)
+               end
+      connection.dispatch(result)
+    rescue SystemCallError # connection errors
+    end
+
+    def error_message(exception)
+      # Hide the internals from the backtrace
+      backtrace = exception.backtrace.reject { |frame| frame =~ /^#{__FILE__}/ }
+      msg = ["Rum-Server: Evaluation Error."]
+      msg << "#{exception.class}: #{exception}"
+      msg += backtrace
+      msg.join "\n"
+    end
+
+    module IRBCompletion
+      Glue = 'binding = Rum::Server::EvalBinding
+              workspace = Struct.new(:binding).new(binding)
+              context = Struct.new(:workspace).new(workspace)
+              @CONF = { MAIN_CONTEXT: context }
+              
+              def IRB.conf
+                @CONF
+              end'
+
+      def self.setup
+        unless defined? IRB
+          # Since version 0.7, MacRuby ships with an incompatible IRB
+          # distribution called dietirb. Mac Rum includes a partial
+          # copy of the original IRB.
+          require Rum::Platform == :mac ? 'rum/mac/irb/completion' : 'irb/completion'
+          IRB.module_eval(Glue)
+        end
+      end
+    end
+
+    IRBCompletion.setup
+  end
+end

data/lib/rum/windows.rb

@@ -0,0 +1,23 @@
+require 'rum/windows/system'
+require 'rum/windows/keyboard_hook'
+require 'rum/windows/keyboard'
+require 'rum/windows/gui'
+require 'rum/windows/app'
+require 'rum/windows/layouts'
+
+module Rum
+  Platform = :windows
+  
+  def self.restart_platform_specific
+    Rum::Server.stop
+    System.spawn_in_terminal('ruby', $PROGRAM_NAME)
+    sleep 0.01 # This prevents a strange lag. Wow.
+    System.terminal_window.close
+  end
+
+  class HotkeyProcessor
+    def inhibit_modifier_action
+      System.send_keypress @layout['control']
+    end
+  end
+end

data/lib/rum/windows/app.rb

@@ -0,0 +1,72 @@
+module Rum
+  class App
+    include System
+
+    @@apps = {}
+    
+    def self.add(app)
+      @@apps[app.binary] = app
+    end
+    
+    def self.remove(app)
+      @@apps.delete(app.binary)
+    end
+
+    def self.apps
+      @@apps
+    end
+
+    def self.for_exe(exe)
+      @@apps[exe.downcase]
+    end
+
+    attr_accessor :path, :binary, :matcher
+
+    def initialize(path, *matcher)
+      @path = append_path_to_programfiles_if_relative(path)
+      @binary = File.basename(@path).sub(/\.exe$/, '').downcase
+      @matcher = WindowMatcher.new(*matcher)
+      App.add(self)
+    end
+
+    def append_path_to_programfiles_if_relative(path)
+      if path !~ /^\w:|^%/
+        path = File.join(ENV['PROGRAMFILES'].gsub("\\", '/'), path)
+      end
+      path
+    end
+
+    def binary=(bin)
+      App.remove(self)
+      @binary = bin.downcase
+      App.add(self)
+    end
+
+    # Returns 'true' if the application window could be activated instantly.
+    def activate
+      window = @matcher.find
+      if window
+        window.show
+      else
+        run
+        false
+      end
+    end
+
+    def run
+      start @path
+    end
+
+    def to_matcher
+      @matcher
+    end
+
+    def active?
+      @matcher.active?
+    end
+
+    def window
+      @matcher.find
+    end
+  end
+end

data/lib/rum/windows/apps.rb

@@ -0,0 +1,25 @@
+# encoding: utf-8
+Emacs = App.new('', nil, 'Emacs')
+Emacs.binary = 'emacs'
+require 'rum/barrel/emacs'
+
+Firefox = App.new('mozilla firefox/firefox', /firefox/, 'MozillaWindowClass')
+def Firefox.activate_and_focus_address_bar
+  Keyboard.type '(ctrl l)' if activate
+end
+
+Photoshop = App.new('Adobe/Adobe Photoshop CS5/Photoshop', nil, 'Photoshop')
+class << Photoshop
+  def next_blend_mode
+    if Rum.layout['ö'] # german layout
+      type '(shift 0)'
+    else
+      type '(shift +)'
+    end
+  end
+
+  def previous_blend_mode
+    type '(shift -)'
+  end
+end
+

data/lib/rum/windows/gui.rb

@@ -0,0 +1,116 @@
+module Rum
+  module Gui
+    def goto path
+      if File.directory? path
+        System.start path
+      else
+        Gui.message "Can't visit a file in Windows Explorer."
+      end
+    end
+    
+    def open_file file, line=nil
+      System.start file
+    end
+
+    private
+
+    def browse_backend url
+      System.start url
+    end
+
+    module WindowsDialogs
+      private
+      def alert_backend text, title
+        System.message_box text, title
+      end
+      
+      def message_backend text, title, sticky, callback
+        alert text, title
+      end
+
+      def read_backend text, title, initial_value
+        System.input_box text, title, initial_value
+      end
+    end
+
+    use WindowsDialogs
+
+    module Growl
+      Message = 'message'
+
+      private
+      
+      def message_backend(text, title, sticky, callback)
+        unless title
+          title = text
+          text = nil
+        end
+        # ruby_gntp raises an error when 'title' is nil or pure whitespace.
+        title = 'empty text' if title.to_s.strip.empty?
+        if callback
+          on_click = lambda { |event| callback.call if event[:callback_result] == "CLICK" }
+        end
+        
+        Growl.client.notify(name: Message, title: title,
+                            text: text, sticky: sticky, &on_click)
+      end
+      
+      module_function
+      
+      def auto_setup
+        require 'ruby_gntp'
+        @growl = GNTP.new("Rum")
+        @growl.register(notifications: [{name: Message, enabled: true}])
+        true
+      rescue Errno::ECONNREFUSED # Growl not running
+        @growl = nil
+      end
+
+      def client
+        @growl or auto_setup and @growl
+      end
+    end
+
+    module EmacsInteraction
+      private
+      
+      def interaction(*args)
+        emacs = Emacs.window
+        return '' unless emacs
+        unless (emacs_already_active = emacs.active?)
+          old = System.active_window
+          emacs.move(400, 400, 800, 300)
+          emacs.show
+        end
+        result = unpack(Emacs.funcall(*args))
+        unless emacs_already_active
+          wait { old.active? } unless old.show
+          emacs.maximize
+        end
+        result
+      end
+
+      def unpack(output)
+        # If we don't get a string back something has gone wrong.
+        raise 'emacs returned no string: ' << output unless output[0] == ?"
+        # The first line contains the status (1 or 0),
+        # the second line contains additional output.
+        # See telemacs-format-output.
+        output = Emacs.unquote(output)
+        if output =~ /\n$/
+          ''
+        else
+          output = output.split(/\n/)
+          output[1] or (output[0] == '1' ?  true : nil)
+        end
+      end
+
+      def choose_backend prompt, choices
+        prompt = prompt ? Emacs.quote(prompt) : 'nil'
+        fn = 'selekt-external-fast'
+        result = interaction(fn, prompt, *choices.map { |item| Emacs.quote(item.to_s) })
+        choices[result.to_i] if result
+      end
+    end
+  end
+end

data/lib/rum/windows/keyboard.rb

@@ -0,0 +1,80 @@
+require 'strscan'
+
+module Rum
+  module Keyboard
+    extend self
+    
+    def type(key_sequence, *args)
+      release_core_modifiers unless args.include? :blind
+      type_sequence(key_sequence, args.include?(:slow))
+    end
+    
+    def type!(key_sequence, *args)
+      release_core_modifiers unless args.include? :blind
+      type_sequence_literally(key_sequence, args.include?(:slow))
+    end
+
+    def release_core_modifiers
+      pressed = Rum.hotkey_processor.pressed_modifiers
+      to_release = Rum.layout.core_modifiers.keys.select { |mod| pressed[mod] }
+      to_release.each { |key| System.send_key_event key, false }
+    end
+
+    private
+
+    def type_sequence_literally(key_sequence, slow)
+      key_sequence.chars.each do |char|
+        if (key = Rum.layout[char])
+          System.send_keypress key
+          sleep 0.01 if slow
+        elsif (translation = Rum.layout.translations[char])
+          type_sequence(translation, slow)
+        end
+      end
+    end
+
+    def type_sequence(key_sequence, slow)
+      s = StringScanner.new(key_sequence)
+      pressed_keys = []
+      while (char = s.getch)
+        case char
+        when '\\'
+          down_and_up(s.getch, slow)
+        when '('
+          key = s.scan(/[^() ]+/)
+          s.skip /\ /
+          down key
+          pressed_keys << key
+        when ')'
+          up pressed_keys.pop
+        else
+          down_and_up(char, slow)
+        end
+        sleep 0.01 if slow
+      end
+      pressed_keys.reverse_each { |key| up key }
+    end
+
+    def send_key(key, down)
+      if id = Rum.layout[key]
+        System.send_key_event id, down
+      end
+    end
+
+    def down(key)
+      send_key key, true
+    end
+
+    def up(key)
+      send_key key, false
+    end
+
+    def down_and_up(char, slow)
+      if (key = Rum.layout[char])
+        System.send_keypress key
+      elsif (key_sequence = Rum.layout.translations[char])
+        type_sequence(key_sequence, slow)
+      end
+    end
+  end
+end