xiki 0.5.0a

data/lib/control_lock.rb

@@ -0,0 +1,9 @@
+# Simple wrapper around control_lock.el to turne
+# it on and off (and handle the case where it's not)
+# installed.
+class ControlLock
+
+  def self.disable
+    $el.control_lock_enable if $el.boundp(:control_lock_mode_p) and $el.elvar.control_lock_mode_p
+  end
+end

data/lib/control_tab.rb

@@ -0,0 +1,176 @@
+# Helps you switch between files, in a way very similar to how Ctrl-tab
+# switches between windows in most operating systems.  Call #keys
+# to map it to Ctrl-tab in emacs.
+class ControlTab
+
+  @@edited = nil
+
+  @@switch_index = 0
+
+  # Primary method.  Is mapped to C-tab and does the switching.
+  def self.go
+
+    prefix = Keys.prefix :clear=>1
+
+    first_tab_in_sequence = Keys.before_last !~ /\btab$/   # If first tab, clear edited
+    @@edited = @@dash_prefix = @@nine_prefix = nil if first_tab_in_sequence
+
+    if prefix == :- || @@dash_prefix   # Go to next quote in $f
+      View.layout_files :no_blink=>1
+      Move.to_quote
+      Effects.blink
+      Launcher.launch
+      @@dash_prefix = true
+      return
+    end
+
+    if prefix == 9 || @@nine_prefix   # Navigate to next Ol line in *ol buffer
+
+      View.layout_output :dont_highlight=>1
+
+      Move.to_end
+      Search.forward "^-", :go_anyway=>1
+      if View.cursor == View.bottom
+        Move.to_previous_paragraph
+        Line.next
+      end
+      Effects.blink
+      Launcher.launch
+      @@nine_prefix = true
+      return
+    end
+
+      #     if prefix == 9   # If __ prefix, just burry buffer
+      #       $el.bury_buffer
+      #       # Store original order, and windows originally opened
+      #       @@original = buffer_list.to_a   # Hide evidence that we were on top (lest it restore us)
+      #       @@open_windows = window_list.collect {|b| window_buffer b}
+      #       @@consider_test = lambda{|b| ! buffer_name(b)[/Minibuf/] }
+      #       return
+      #     end
+
+    if prefix == :u   # If U prefix (must be first alt-tab in sequence)
+      # Go to last edited file, and store list
+      @@edited = $el.elvar.editedhistory_history.to_a
+      @@edited -= View.files :visible=>1   # Exclude currently visible files
+      $el.find_file @@edited.shift
+
+      return
+    elsif @@edited   # Subsequent alt-tab
+      $el.find_file @@edited.shift
+      return
+    end
+
+    # If this was the first tab in this sequence
+    if first_tab_in_sequence# || last_was_modeline_click
+
+      # Store original order, and windows originally opened
+      @@original = $el.buffer_list.to_a
+      @@open_windows = $el.window_list.collect {|b| $el.window_buffer b}
+
+      # Check for prefix, and store correct test for files to go through accordingly
+      case prefix
+      when 0   # Non-files
+        @@consider_test = lambda{|b| ! $el.buffer_file_name(b) && ! $el.buffer_name(b)[/Minibuf/]}
+      when 1   # Only files
+        @@consider_test = lambda{|b| $el.buffer_file_name(b)}
+        #       when 3   # ...css
+        #         @@consider_test = lambda{|b| buffer_name(b) =~ /\.(css|sass)/}
+      when 2   # .notes files
+        @@consider_test = lambda{|b| $el.buffer_file_name(b) =~ /\.deck$/}
+      when 3   # ...css
+        @@consider_test = lambda{|b| $el.buffer_name(b) =~ /^#/}
+      when 4   # haml.html files
+        @@consider_test = lambda{|b| $el.buffer_file_name(b) =~ /\.html/}
+      when 5   # Consoles
+        @@consider_test = lambda{|b|
+          next if $el.buffer_file_name b
+          $el.set_buffer b
+          next if $el.elvar.major_mode.to_s != 'shell-mode'
+          name = $el.buffer_name b
+          next if name == "*ol"
+          true
+        }
+        #         @@consider_test = lambda{|b| buffer_name(b) =~ /^(\*console|\*merb) /i}
+      when 6   # Ruby files only
+        @@consider_test = lambda{|b| $el.buffer_file_name(b) =~ /\.rb$/}
+      when 68   # controller
+        @@consider_test = lambda{|b| $el.buffer_file_name(b) =~ /\/app\/controllers\//}
+      when 66   # Models
+        @@consider_test = lambda{|b| $el.buffer_file_name(b) =~ /\/app\/models\//}
+      when 67   # Tests
+        @@consider_test = lambda{|b| $el.buffer_file_name(b) =~ /_(spec|test)\.rb$/}
+      when 7   # .notes files
+        @@consider_test = lambda{|b| $el.buffer_file_name(b) =~ /\.notes$/}
+      when 8   # Anything (just like no arg)
+        @@consider_test = lambda{|b| ! $el.buffer_name(b)[/Minibuf/] }
+        #       when 9   # js
+        #         @@consider_test = lambda{|b| buffer_file_name(b) =~ /\.js$/}
+      else   # Anything (except minibuffer)
+        @@consider_test = lambda{|b| ! $el.buffer_name(b)[/Minibuf/] }
+      end
+
+      # Remember we're starting at the top of the buffer list
+      @@switch_index = 0
+
+      # Go to next eligible buffer
+      self.move_to_next
+
+      $el.switch_to_buffer(@@original[@@switch_index])
+
+    # If we've been typing tabs
+    else
+      self.restore_original_order   # Restore order up to this buffer
+      self.move_to_next   # Point to next eligible buffer
+      $el.switch_to_buffer(@@original[@@switch_index])  # Switch to eligible
+
+    end
+  end
+
+  def self.restore_original_order
+    # Move backwards through original list, moving each to front
+    (0..(@@switch_index)).each do |i|
+      $el.switch_to_buffer(@@original[@@switch_index-i])
+    end
+  end
+
+  # Advances @@switch_index to next eligible buffer
+  def self.move_to_next
+    buffer_started_at = @@switch_index
+
+    @@switch_index += 1   # Move to next
+    self.to_next_unless_nil   # Go there so test can look at buffer mode, etc
+
+    # Keep moving until we find an eligible buffer (that isn't already viewed)
+    while(
+        @@open_windows.member?(@@original[@@switch_index]) ||   # Already viewed
+        ! @@consider_test[@@original[@@switch_index]]   # Not what we're looking for
+    )
+      @@switch_index += 1
+
+      # Stop moving forward if we're at end
+      if @@switch_index >= @@original.size
+        @@switch_index = buffer_started_at
+        #         View.to_buffer buffer_started_at
+        View.beep 'None left'
+        break
+      end
+
+      self.to_next_unless_nil
+    end
+  end
+
+  def self.to_next_unless_nil
+    to_buffer = @@original[@@switch_index]
+    if to_buffer.nil?
+      View.beep 'None left'
+    end
+    $el.set_buffer(to_buffer)   # Go there so test can look at buffer mode, etc
+  end
+
+  def self.keys
+    Keys.set("C-<tab>") do
+      ControlTab.go
+    end
+  end
+end

data/lib/core_ext.rb

@@ -0,0 +1,31 @@
+require 'text_util'
+
+class Array
+  def blank?
+    self.empty?
+  end
+end
+
+class NilClass
+  def empty?
+    self.nil?
+  end
+
+  def blank?
+    self.nil?
+  end
+end
+
+class String
+  def blank?
+    self.nil? || self.empty?
+  end
+
+  def present?
+    ! self.nil?
+  end
+
+  def unindent
+    TextUtil.unindent(to_s)
+  end
+end

data/lib/cursor.rb

@@ -0,0 +1,111 @@
+class Cursor
+
+  @@remember = {}
+
+  def self.menu
+    %`
+    > Summary
+    | Api for changing the cursor
+    |
+    - Colors/
+      @Cursor.white
+      @Cursor.red
+      @Cursor.green
+      @Cursor.blue
+      @Cursor.color "#80f"
+    - Shapes/
+      @Cursor.bar
+      @Cursor.underscore
+      @Cursor.hollow
+      @Cursor.box
+    - Colors and Shapes/
+      @Cursor.red_bar
+      @Cursor.green_underscore
+      @Cursor.blue_hollow
+      @Cursor.black_box
+    - Remembering and restoring cursor/
+      @Cursor.remember :a
+      @Cursor.restore :a
+    `
+
+  end
+
+  def self.bar
+    $el.el4r_lisp_eval "(customize-set-variable 'cursor-type '(bar . 2))"
+    nil
+  end
+  def self.box
+    $el.customize_set_variable :cursor_type, :box
+    nil
+  end
+  def self.underscore
+    $el.el4r_lisp_eval "(customize-set-variable 'cursor-type '(hbar . 3))"
+    nil
+  end
+  def self.hollow
+    $el.customize_set_variable :cursor_type, :hollow
+    nil
+  end
+
+  def self.color color
+    $el.set_face_background :cursor, color
+    nil
+  end
+
+  def self.blue
+    $el.set_face_background :cursor, "#0099ff"
+    nil
+  end
+  def self.red
+    $el.set_face_background :cursor, "#ff3300"
+    nil
+  end
+  def self.green
+    $el.set_face_background :cursor, "#33bb00"
+    nil
+  end
+  def self.white
+    $el.set_face_background :cursor, "#ffffff"
+    nil
+  end
+  def self.black
+    $el.set_face_background :cursor, "#000000"
+    nil
+  end
+
+  def self.red_bar
+    self.red
+    self.bar
+  end
+  def self.blue_hollow
+    self.blue
+    self.hollow
+  end
+  def self.green_underscore
+    self.green
+    self.underscore
+  end
+  def self.blue_underscore
+    self.blue
+    self.underscore
+  end
+  def self.black_box
+    self.black
+    self.box
+  end
+
+  def self.remember symbol=:default
+    # Save is hash for later restoring (only if not there yet)
+    @@remember[symbol] = [$el.elvar.cursor_type, $el.face_background(:cursor)]
+  end
+
+  def self.restore symbol=:default
+    before = @@remember[symbol]
+    return Cursor.black_box unless before  # Black if not found
+    type, color = before
+    $el.set_face_background :cursor, color
+    $el.customize_set_variable :cursor_type, type
+  end
+
+end
+

data/lib/deletes.rb

@@ -0,0 +1,65 @@
+class Deletes
+  def self.delete_whitespace
+
+    prefix = Keys.prefix(:clear=>true)   # Number prefix means add that many lines after deleting
+
+    if prefix == :u   # If U, remove whitespace within region
+      txt = View.selection :delete=>true
+      linebreak_on_end = txt[/\n\z/]
+      txt.gsub! /^ *[+-] /, ''
+      txt.gsub! /[\n\t ]/, ''
+      View.insert("#{txt}#{linebreak_on_end}", :dont_move=>true)
+      return
+    end
+
+    # If at end of line, go forward, and remember to delete backward
+    was_blank = Line.blank?
+    was_at_end = (Line.at_right? and (! was_blank))
+    was_at_beginning = (Line.at_left? and (! was_blank))
+    if was_blank  # If blank, stay on line
+      # Do nothing
+    elsif was_at_end
+      $el.forward_char
+    elsif was_at_beginning and not View.char =~ /\s/
+      $el.backward_char
+    else   # If not at end of a line, simply delete horizontal
+      $el.delete_horizontal_space
+      View.insert(" " * prefix) if prefix
+      return
+    end
+
+    # Delete any blank lines
+    $el.delete_blank_lines if Line.blank?
+    $el.delete_char(1) if Line.blank?   # Delete line if left
+
+    Deletes.backward if was_at_end
+    if was_at_beginning
+      Deletes.backward if Line.at_left?
+      $el.delete_char(1) if Line.at_right?
+    end
+    if was_blank
+      if prefix
+        View.insert("\n" * prefix)
+        Move.backward prefix
+      end
+    else
+      $el.delete_horizontal_space
+      View.insert(" " * prefix) if prefix
+    end
+  end
+
+
+  def self.backward
+    prefix = Keys.prefix
+    case prefix
+    when :u
+      $el.backward_kill_word 1
+    when :uu
+      $el.backward_kill_word 2
+    when :uuu
+      $el.backward_kill_word 3
+    else
+      $el.delete_backward_char(prefix || 1)
+    end
+  end
+end

data/lib/diff_log.rb

@@ -0,0 +1,297 @@
+require 'hide'
+
+# Will store a diff each time a file is saved.
+class DiffLog
+
+  @@log = File.expand_path("~/.emacs.d/difflog.notes")
+  @@temp_path = "/tmp/saved.txt"
+
+  def self.menu
+    "
+    .open/
+    .diffs/
+    .diffs/$p/
+    docs/
+      > Summary
+      | The difflog tracks diffs of all the changes you make to file
+      | (assuming you save using as+file).
+      |
+      > Keys
+      | open+diffs - open the difflog
+      | search+diffs - search the difflog from the bottom
+    "
+  end
+
+  # Open file having difflog
+  def self.open
+    View.to_after_bar if View.in_bar?
+
+    # If open, just switch to it and revert
+    if View.buffer_open?("difflog.notes")
+      View.to_buffer("difflog.notes")
+      $el.revert_buffer true, true, true
+    else  # Otherwise, open it
+      View.open(@@log)
+    end
+    View.to_bottom
+    Line.previous
+    Line.to_words
+    $el.recenter -4
+  end
+
+  def self.diffs path=nil
+
+    txt = File.read @@log
+    txt = txt.sub(/\A- /, '').split(/^- /).reverse.uniq
+
+    path ||= Tree.dir   # Pull from tree if there
+
+    path = Bookmarks[path] if path
+
+    if ! path
+      regex = /^\//
+    elsif File.file? path   # File
+      regex = /^#{Regexp.escape File.dirname path}\/\n  - #{Regexp.escape File.basename path}/
+    else   # Dir
+      regex = /^#{Regexp.escape path}/
+      path = "#{path}/" if path !~ /\/$/
+    end
+
+    txt = txt.select{|o| o =~ regex}
+
+    "- @#{txt.join("- @")}"
+  end
+
+  # Insert old text deleted during last save
+  def self.last_diff
+    $el.with(:save_window_excursion) do
+      DiffLog.open
+      Search.backward "^-"
+      txt = View.txt View.cursor, View.bottom
+    end
+  end
+
+  def self.is_one_line_change? txt
+    txt.scan(/^ +\|\-/).length == 1 &&
+      txt.scan(/^ +\|\+/).length == 1 &&
+      txt.scan(/^ +:/).length
+  end
+
+  # Insert new text added during last save
+  def self.enter_new
+    self.enter_old_or_new :new
+  end
+
+  def self.enter_old
+    self.enter_old_or_new :old
+  end
+
+  def self.enter_old_or_new old_or_new
+
+    diff = DiffLog.last_diff
+    one_line_change = DiffLog.is_one_line_change? diff
+
+    # Show intraline change if changed just one line and not up+
+
+    if ! Keys.up? && one_line_change
+      View.<< DiffLog.last_intraline_diff[old_or_new == :old ? 0 : 1] rescue View.beep $!
+      return
+    end
+
+    # Show lines
+
+    diff.gsub! /^ *[+:-].*\n/, ""   # Only leave red and green lines
+    if old_or_new == :old
+      diff.gsub! /^ +\|\+.*\n/, ""
+      diff.gsub! /^ +\|\-/, ""
+    else
+      diff.gsub! /^ +\|\-.*\n/, ""
+      diff.gsub! /^ +\|\+/, ""
+    end
+    View << diff
+
+  end
+
+  # Appends diff to difflog, then saves.  Mapped to as_file.
+  def self.save
+    return if View.file_name == "difflog.notes"
+
+    prefix = Keys.prefix :clear=>1
+
+    self.save_diffs
+
+    $el.save_buffer
+
+    if prefix == :u
+      sleep(0.3)
+      Firefox.reload
+    elsif prefix == 9
+      Launcher.do_last_launch
+    end
+  end
+
+  def self.format raw
+    path, file = raw.match(/--- (.+\/)(.+?)\t/)[1..2]
+
+    # Delete paths at top
+    raw.sub!(/.+\n.+\n/, '')
+
+    # Make @@... lines into lines having numbers
+    raw.gsub!(/^@@ -(\d+).* \+(\d+).+@@$/) {
+      a, b = $1.to_i, $2.to_i
+      highest = a > b ? a : b
+      "    :#{highest}"
+    }
+
+    # Make - and + lines into -| and +| lines
+    raw.gsub!(/^\+(.*)/, "      |+\\1")
+    raw.gsub!(/^-(.*)/, "      |-\\1")
+
+    # Return with path
+    "- #{path}\n" +
+    "  - #{file}\n" +
+    raw
+  end
+
+  def self.compare_with_saved
+
+    if Keys.prefix_u
+
+      buffer_unsaved = View.buffer
+
+      path = View.file
+
+      View.to_buffer "untitled"
+      $el.rename_uniquely
+      View << File.read(path)
+
+      return $el.ediff_buffers View.buffer, buffer_unsaved
+
+    end
+
+    diff = self.save_diffs :dont_log=>1
+    diff = "" if diff.nil?
+
+    View.to_buffer("*diff with saved*")
+    View.clear
+    Notes.mode
+
+    View.insert diff.count("\n") > 2 ?
+      diff :
+      "> Note\n- No Differences!\n"
+  end
+
+  def self.enter_from_difflog
+    Location.as_spot
+    View.to_after_bar if View.in_bar?
+    DiffLog.open
+    $el.isearch_backward
+  end
+
+  # Util function used by public functions
+  def self.save_diffs options={}
+    if options[:patha] && options[:textb]
+      patha = options[:patha]
+      File.open(@@temp_path, "w") { |f| f << options[:textb] }
+    else
+      patha = View.file
+      $el.write_region nil, nil, @@temp_path
+    end
+
+    diff = Console.sync "diff -U 0 \"#{patha}\" \"#{@@temp_path}\""
+    return if diff.empty? || diff =~ /: No such file or directory\n/   # Fail quietly if file didn't exist
+
+    diff = self.format diff
+    return diff if options[:dont_log]
+
+    File.open(@@log, "a") { |f| f << diff } unless diff.count("\n") <= 2
+  end
+
+  def self.parse_tree_diffs txt
+    result = [[], []]
+
+    txt = txt.split("\n")
+    i, length = 0, txt.length
+
+    while i < length
+      line = txt[i]
+      #       a_or_d = line[/^[ad]/]
+      match = line.match(/^(.)(\d+) (\d+)/)
+      raise "Line #{line} unexpected by DiffLog.parse_tree_diffs" if ! match
+      a_or_d, line_number, many = match[1..3]
+      line_number, many = line_number.to_i, many.to_i
+
+      if a_or_d == "d"
+        i += 1
+        many.times do |n|
+          result[1] << line_number + n
+        end
+        next
+      end
+
+      if a_or_d == "a"
+        i += 1
+        many.times do |n|
+          result[0] << line_number + n
+        end
+        next
+      end
+
+      raise "DiffLog.parse_tree_diffs doesn't know what to do with #{line}"
+    end
+
+    result
+  end
+
+  def self.do_compare_with
+    prefix = Keys.prefix :clear=>1
+
+    # up+ means compare buffers in first two views
+
+    return $el.ediff_buffers( $el.window_buffer($el.nth(0, $el.window_list)), $el.window_buffer($el.nth(1, $el.window_list))) if prefix == :u
+
+    # Save place and grab file at spot
+
+    source_path = Tree.dir_at_spot
+    dest_path = Tree.dir :file=>1
+    $el.ediff_files source_path, dest_path
+
+  end
+
+  #
+  # Grabs last diff from difflog, and calculates exactly what changed.  Whithin the line.
+  # So, it performs a single-line diff
+  #
+  # It presumes a single-line change, and a change at only one point on the line.
+  #
+  # DiffLog.last_intraline_diff
+  #
+  def self.last_intraline_diff txt=nil
+    txt ||= DiffLog.last_diff
+
+    linea = txt[/ +\|\-(.+)/, 1]
+    lineb = txt[/ +\|\+(.+)/, 1]
+
+    raise "The last diff in the difflog didn't have a red and a green." if linea.nil? || lineb.nil?
+
+    linea_length, lineb_length = linea.length, lineb.length
+
+    from_start = 0
+    while from_start < linea_length
+      break if linea[from_start] != lineb[from_start]
+      from_start += 1
+    end
+
+    from_end = 1
+    while from_end < linea_length
+      break if from_end > linea_length || from_end > lineb_length || linea[linea_length-from_end] != lineb[lineb_length-from_end]
+      from_end += 1
+    end
+
+    deltaa = from_end > linea_length ? "" : linea[from_start..(linea_length-from_end)]
+    delteab = from_end > lineb_length ? "" : lineb[from_start..(lineb_length-from_end)]
+
+    [deltaa, delteab]
+  end
+
+end