xiki 0.5.0a

data/lib/numbers.rb

@@ -0,0 +1,45 @@
+class Numbers
+  def self.menu
+    ['.sum_numbers_in_clipboard',
+      '.sum_dollars_in_clipboard'
+    ]
+  end
+
+  def self.sum_numbers txt
+    numbers = txt.scan(/[\d.]+/)
+    numbers.map!{|o| o.to_f}
+    numbers.inject(0){|i, o| i + o}
+  end
+
+  def self.sum_numbers_in_clipboard
+    self.sum_numbers Clipboard[0]
+  end
+
+  def self.sum_dollars txt
+    numbers = txt.scan(/\$([\d.]+)/).map{|o| o.first}
+    numbers.map!{|o| o.to_f}
+    numbers.inject(0){|i, o| i + o}
+  end
+
+  def self.sum_dollars_in_clipboard
+    self.sum_dollars Clipboard[0]
+  end
+
+  def self.enter_as_added
+    txt = Clipboard[0]
+
+    # If it has amount after " = ", make nure only they are added
+    if txt =~ / = \$?\d/
+      txt.gsub! /.* = /, ''
+    end
+
+    # If it has dollars, just add dollars
+    if txt =~ /\$\d/
+      View.insert self.sum_dollars(txt).to_s
+      return
+    end
+
+    View.insert self.sum_numbers(txt).to_s
+
+  end
+end

data/lib/ol.rb

@@ -0,0 +1,203 @@
+# Meant to log short succinct messages to help with troubleshooting
+# while coding.  Log statements hyperlink back to the line that logged it.
+class Ol
+  @@last = [Time.now - 1000]
+  @@timed_last = Time.now
+
+  # For when the caller constructs what to log on its own
+  def self.log_directly txt, line, name=nil
+    path = name ? "/tmp/#{name}_ol.notes" : self.file_path
+    self.write_to_file path, txt
+    self.write_to_file_lines path, line
+  end
+
+  def self.log txt, l=nil, name=nil, time=nil
+
+    path = name ? "/tmp/#{name}_ol.notes" : self.file_path
+
+    if l.nil?   # If just txt, delegate to line
+      self
+      return self.line(txt, caller(0)[1])
+    end
+
+    # If n seconds passed since last call
+    heading = self.pause_since_last?(time) ? "\n>\n" : nil
+
+    if l.is_a?(Array)   # If an array of lines was passed
+      result = ""
+      result_lines = ""
+      if heading
+        result << heading
+        result_lines << "\n\n"
+      end
+      l.each_with_index do |o, i|
+        next unless o
+        h = Ol.parse_line(o)
+        result << "#{'  '*i}#{self.extract_label(h)}#{i+1 == l.size ? " #{txt}" : ''}\n"
+        result_lines << "#{h[:path]}:#{h[:line]}\n"
+      end
+      self.write_to_file path, result
+      self.write_to_file_lines path, result_lines
+      return txt
+    end
+
+    # Indent lines if multi-line (except for first)
+    txt.gsub!("\n", "\n  ")
+    txt.sub!(/ +\z/, '')   # Remove trailing
+
+    h = Ol.parse_line(l)
+
+    self.write_to_file path, "#{heading}#{txt}\n"
+
+    # Multiline txt: Write path to .line file once for each number of lines
+    l = "#{h[:path]}:#{h[:line]}\n"
+    result = ""
+    result << "\n\n" if heading
+    txt.split("\n", -1).size.times { result << l }
+    self.write_to_file_lines "#{path}", result
+
+    txt
+  end
+
+  def self.write_to_file path, txt
+    existed = File.exists? path   # If file doesn't exist, chmod it to world writable later
+
+    File.open(path, "a") do |f|
+      f << txt
+      f.chmod 0666 if ! existed
+    end
+  end
+
+  def self.write_to_file_lines path, txt
+    path = "#{path}.lines"
+    existed = File.exists? path   # If file doesn't exist, chmod it to world writable later
+
+    File.open(path, "a", 0666) do |f|
+      f << txt
+      f.chmod 0666 if ! existed
+    end
+  end
+
+  def self.pause_since_last? time=nil, no_reset=nil
+    time ||= @@last
+    difference = Time.now - time[0]
+    time[0] = Time.now unless no_reset
+    difference > 3
+  end
+
+  def self.<< txt
+    self.line txt, caller(0)[1]
+  end
+
+  def self.time nth=1
+    now = Time.now
+    elapsed = self.pause_since_last? ? nil : (now - @@timed_last)
+
+    self.line "#{elapsed ? "(#{elapsed}) " : ''}#{now.strftime('%I:%M:%S').sub(/^0/, '')}:#{now.usec.to_s.rjust(6, '0')}", caller(0)[nth]
+    @@timed_last = now
+  end
+
+
+
+  def self.line txt=nil, l=nil, indent="", name=nil, time=nil
+    l ||= caller(0)[1]
+
+    l.sub! /^\(eval\)/, 'eval'   # So "(" doesn't mess up the label
+
+    h = self.parse_line(l)
+
+    txt = txt ? " #{txt}" : ''
+
+    if h[:clazz]
+      self.log "#{indent}#{self.extract_label(h)}#{txt}", l, name, time
+    else
+      display = l.sub(/_html_haml'$/, '')
+      display.sub!(/.+(.{18})/, "\\1...")
+      self.log "#{indent}- #{display})#{txt}", l, name, time
+    end
+  end
+
+  def self.extract_label h
+    "- #{h[:clazz]}.#{h[:method]} #{h[:line]})"
+  end
+
+
+  def self.parse_line path
+    method = path[/`(.+)'/, 1]   # `
+    path, l = path.match(/(.+):(\d+)/)[1..2]
+    path = File.expand_path path
+    clazz = path[/.+\/(.+)\.rb/, 1]
+    clazz = self.camel_case(clazz) if clazz
+    {:path=>path, :line=>l, :method=>method, :clazz=>clazz}
+  end
+
+  def self.file_path
+    "/tmp/output_ol.notes"
+  end
+
+  def self.camel_case s
+    s.gsub(/_([a-z]+)/) {"#{$1.capitalize}"}.sub(/(.)/) {$1.upcase}.gsub("_", "")
+  end
+
+  # Logs short succinct stack trace
+  def self.stack n=6, nth=1
+    ls ||= caller(0)[nth..(n+nth)]
+
+    self.line "stack...", ls.shift, ""
+
+    ls.each do |l|
+      self.line nil, l, "  "
+    end
+  end
+
+  def self.limit_stack stack, pattern=/^\/projects\//
+    # Cut off until it doesn't match
+    first = stack.first
+    stack.delete_if{|o| o !~ pattern}
+    stack.reverse!
+    # Be sure to leave one, if they're all deleted
+    stack << first if stack == []
+    stack
+  end
+
+  # Remove parents from stack that are common to last_stack
+  def self.remove_redundance stack, last_stack
+    result = []
+    # For each stack, copy it over if different, or nil if the same
+    stack.each_with_index do |o, i|
+      # If it's the last one, don't nil it out
+      if i+1 == stack.size
+        result << o
+        next
+      end
+
+      result << (o == last_stack[i] ? nil : o)
+    end
+    result
+  end
+
+  def self.browser html
+    path = "/tmp/browser.#{Time.now.usec}.html"
+    url = "file://#{path}"
+    File.open(path, "w") { |f| f << html }
+
+    `open '#{url}'`
+  end
+
+  def self.open_last_output
+
+    prefix = Keys.prefix :clear=>1
+    View.layout_output
+    if prefix == :u
+      View.to_highest
+      Search.forward "^-"
+    else
+      View.to_bottom
+      Line.previous
+    end
+
+    Launcher.launch
+
+  end
+
+end

data/lib/ol_helper.rb

@@ -0,0 +1,44 @@
+class OlHelper
+  def self.source_to_output file, line
+
+    target = "#{file}:#{line}\n"
+
+    lines = IO.readlines("/tmp/output_ol.notes.lines").reverse
+
+    lines_total = lines.length
+
+    # Get how far from bottom
+    distance, found = 0, nil
+    while distance < lines_total do
+      break found = distance if lines[distance] == target
+      distance += 1
+    end
+
+    found
+  end
+
+  def self.launch
+    prefix = Keys.prefix :clear=>1
+
+    # Get path from end
+    path = Ol.file_path #[/\/.+/]
+
+    # TODO: get total_lines - current_line
+    distance_to_end = Line.number(View.bottom) - Line.number
+
+    # Go to log.lines and get n from end
+    arr = IO.readlines("#{path}.lines")
+    line = arr[- distance_to_end]
+
+    path, line = line.split(':')
+
+    View.open path
+    View.to_line line.to_i
+
+    if prefix == 0
+      View.layout_output
+      Line.next
+    end
+  end
+
+end

data/lib/overlay.rb

@@ -0,0 +1,167 @@
+# Wrapper around the elisp 'overlay'.
+#
+# Represents an overlay and has finder methods for getting overlays
+# for more, see http://www.gnu.org/software/emacs/elisp/html_node/Overlays.html
+# represents an elisp overlay.  the Overlay class finder methods for getting overlays
+#-- IMPORTANT NOTES:
+#   start/end have been renamed to left/right respectively
+class Overlay
+
+  def initialize(elisp_overlay)
+    # raise TypeError.new("argument must be elisp overlay") if overlayp(elisp_overlay)
+    @overlay = elisp_overlay
+  end
+
+  def self.menu
+    "
+    - api/
+      | Make some text have a style
+      @ Overlay.face :underline, :left=>1, :right=>300
+      |
+      | Remove all overlays
+      @ Overlay.delete_all
+    "
+  end
+
+  # create elisp overlay and wrap it in a ruby object
+  def self.make(left, right)
+    Overlay.new($el.make_overlay(left, right))
+  end
+
+  # returns all overlays that contain at least one character between left and right
+  # empty overlays are included
+  def self.between(left, right)
+    overlays = $el.overlays_in(left, right).to_a
+    overlays.map { |o| Overlay.new(o) }
+  end
+
+  # returns all overlays for current buffer
+  def self.all
+    between(View.top, View.bottom)
+  end
+
+  # returns all overlays that have left and right exactly
+  def self.on(left, right)
+    between(left, right).select { |o| o.left == left && o.right == right }
+  end
+
+  # returns all overlays that cover pos
+  def self.at(pos)
+    overlays = $el.overlays_at(pos).to_a
+    overlays.map { |o| Overlay.new(o) }
+  end
+
+  def self.overlays_with(left, right, properties = {})
+    # implementation needed
+  end
+
+  def self.find_or_make(left, right)
+    overlays = on(left, right)
+    if overlays.any?
+      puts "warning: more than 1 overlay" if overlays.size > 1
+      overlays.first
+    else
+      make(left, right)
+    end
+  end
+
+  # maybe subclass NamedOverlay
+  # what about uniqueness of name?
+  def self.find_overlay_by_name(name)
+    # search overlays for all overlays with property name
+  end
+
+  def self.remove_overlays
+    # implementation needed
+  end
+
+  # Code Sample:  Overlay.face :trailing_whitespace, :what=>:line
+  # Apply face to region
+  def self.face(face, options={})
+    left ||= options[:left]
+    right ||= options[:right]
+    if options[:what] == :line or left.nil?
+      left, right = Line.left, Line.right+1
+    end
+
+    o = Overlay.find_or_make(left, right)
+    o[:face] = face
+    o
+    nil
+  end
+
+  def self.delete_all
+    $el.overlays_in(View.top, View.bottom).to_a.each{|o| $el.delete_overlay o}
+    nil
+  end
+
+  # returns the buffer that overlay belongs to. It returns nil if overlay has been deleted.
+  def buffer
+    $el.overlay_buffer @overlay
+  end
+
+  # returns a copy of the property list.
+  def properties
+    $el.overlay_properties @overlay
+  end
+
+  # returns the position at which overlay starts, as an integer.
+  def left
+    $el.overlay_start @overlay
+  end
+
+  # returns the position at which overlay ends, as an integer.
+  def right
+    $el.overlay_end @overlay
+  end
+
+  # deletes overlay. The overlay continues to exist as a Lisp object,
+  # and its property list is unchanged, but it ceases to be attached
+  # to the buffer it belonged to, and ceases to have any effect on
+  # display.
+  # A deleted overlay is not permanently disconnected. You
+  # can give it a position in a buffer again by calling move-overlay.
+  def delete
+    $el.delete_overlay @overlay
+  end
+
+  # def move
+  # end
+
+  def to_elisp
+    @overlay
+  end
+
+  # method missing candidate.  name space with 'set' or 'propset'
+  def invisible
+    $el.overlay_get(@overlay, :invisible)
+  end
+
+  def invisible=(arg)
+    if arg
+      $el.overlay_put(@overlay, :invisible, true)
+    else
+      $el.overlay_put(@overlay, :invisible, nil)
+    end
+  end
+
+  def isearch_open_invisible_temporary
+    $el.overlay_get(@overlay, :isearch_open_invisible_temporary)
+  end
+
+  def isearch_open_invisible_temporary=(arg)
+    if arg
+      $el.overlay_put(@overlay, :isearch_open_invisible_temporary, true)
+    else
+      $el.overlay_put(@overlay, :isearch_open_invisible_temporary, nil)
+    end
+  end
+
+  def []= key, val
+    $el.overlay_put(@overlay, key, val)
+  end
+
+  def [] key
+    $el.overlay_get(@overlay, key)
+  end
+end