xiki 0.5.0a

data/lib/search_term.rb

@@ -0,0 +1,40 @@
+# Remember something you're searching for, and jump to the next occurrences.
+  CODE_SAMPLES = %q<
+    - Deprecated:
+  >
+
+class SearchTerm
+
+  @@last_dash_search = ""
+  def self.keys
+    $el.define_key :isearch_mode_map, $el.kbd("C--") do  # During isearch, remember current search term
+      $el.isearch_done
+      $el.isearch_clean_overlays
+      match = $el.buffer_substring $el.match_beginning(0), $el.match_end(0)
+      @@last_dash_search = match
+    end
+    Keys.set("C--") do
+      started = $el.point
+      chars = @@last_dash_search.size
+      # Go to it
+      $el.search_forward @@last_dash_search
+      # Go forward again if you were already at it
+      $el.search_forward @@last_dash_search if started == $el.point - chars
+      # Back up to beginning
+      $el.backward_char chars
+    end
+  end
+  # Does an isearch on the characters typed, until the user pauses more than .4 seconds
+  def self.timed_search
+
+#    isearch_forward
+    c = $el.read_char "search: "
+#    keys = self.to_letter(keys)
+    $el.call_interactively $el.key_binding(c)
+    while(c = $el.read_char("Input: ", nil, 0.40))
+      $el.call_interactively $el.key_binding(c)
+    end
+
+  end
+end
+# Test stuff to search for, and stuff

data/lib/snippet.rb

@@ -0,0 +1,68 @@
+class Snippet
+  def self.menu *args
+
+    if args[0] == "docs"
+      return Tree.children self.docs, args[1..-1]
+    end
+
+    extension = View.extension
+    file = "#{Xiki.dir}etc/snippets/#{extension}.notes"
+
+    prefix = Keys.prefix
+
+    return View.open file if prefix == 'open' || prefix == :u   # If up+, just go to file
+
+    # If leaf has quote, kill the rest or create new snippet
+
+    if args[-1] =~ /\|/
+      txt = ENV['txt'].dup
+
+      txt << "\n" if txt !~ /\n/
+
+      #Tree.to_parent :u
+      Tree.to_root
+      CodeTree.kill_rest
+      indent = Line.indent
+      Line.delete
+      View.<< txt.gsub(/^/, indent), :dont_move=>1
+
+      return
+    end
+
+    # Get snippets.foo file from snippets/ dirs, and drill into it
+
+    # TODO: also look in ~/xiki/snippets? - find different dir name, in case ~/xiki is the Xiki.dir
+
+    if ! File.exists? file
+      # TODO: if none found, show
+      return "
+        | No snippets were found for the file extension '#{extension}'.
+        | You can create some by making a tree in this file:
+        @ #{file}
+        "
+      # TODO: maybe let them type directly into the @snippet menu and do C-. to save
+    end
+
+    txt = File.read file
+    Tree.children txt, args
+
+    # TODO: if line has quote and path doesn't exist in file (.drill fails), create new snippet
+
+  end
+
+  def self.insert
+    View << "@" if Line =~ /^ /
+
+    Launcher.insert("snippet/")
+  end
+
+  def self.docs
+    "
+    > To edit
+
+    > To Use
+    ___
+    "
+  end
+
+end

data/lib/specs.rb

@@ -0,0 +1,229 @@
+gem "rspec"
+require "rspec"
+
+class Specs
+
+  def self.menu
+    '
+    - .load/
+      | Loads rspec (including the .should method) into the xiki environment:
+      - more/
+      - continue/
+    > See
+    << xiki/tests/
+    '
+  end
+
+  def self.load choice
+    if choice == "more"
+      return "
+        | > Point
+        | The point is so you can use rspec methods like .should when using
+        | do+run, as an easy transition to creating a spec:
+        |
+        | Launch continue/ above and then launch this line.  This servers as
+        | a sort of mini test you can create inline.
+        |
+        + try it out) @ puts 1.should == 2
+        |
+        "
+    end
+
+    # Must be "continue/"
+    gem "rspec"
+    require "rspec"
+    return "- loaded!"
+
+  end
+
+  class << self
+    def method_missing(func, *args, &block)
+
+      prefix = Keys.prefix
+
+      bm = nil
+      if args[0].is_a?(Symbol)   # If symbol, use that as bookmark
+        bm = args.shift
+      else   # Climb tree one level
+        parent = FileTree.parent
+        bm = parent.sub(/./, '') if parent =~ /^:\w+$/
+      end
+      bm = (bm || 'mt').to_sym
+      #       thing, opts = nil, thing if thing.is_a?(Hash)
+
+      test, quote = args
+
+      quote = test if args.size == 1 && test =~ /\n/   # If only 1 arg and it's multiline, it must be a quote
+      if quote   # If there's a quote, we're jumping, not running
+        quote = Line.value
+        quote =~ /([\.\/].+):(\d+)/
+
+        path, line = $1, $2
+        path.sub! /^\.\//, Bookmarks["$#{bm}"]   # Fix relative paths
+
+        View.open path
+        View.to_line line.to_i
+        return
+      end
+
+      clazz = func.to_s
+      dir = 'models'   # Assume model
+
+      dir = 'controllers' if clazz =~ /s$/   # If it ends with s, assume controller
+      dir = 'helpers' if clazz =~ /_helpers$/
+
+      # Special cases
+      dir = 'controllers' if clazz == "application"
+
+      # Try in unit/ dir first
+      path = "spec/unit/#{dir}/#{clazz}_spec.rb"
+      # Try just spec/ if not found
+      path = "spec/#{dir}/#{clazz}_spec.rb" if ! File.exists?("#{Bookmarks["$#{bm}"]}#{path}")
+
+      # If xiki, fix paths
+      #       if bm == :x
+      # Ol << "path: #{path.inspect}"
+      #         path.sub! /.+\//, 'spec/'
+      #       end
+
+      if prefix == :u   # If U prefix, jump to test
+
+        View.open "#{Bookmarks["$#{bm}"]}#{path}"
+        Keys.clear_prefix
+        View.to_highest
+        if test =~ /^#/
+          Search.forward "^ *describe .+['\"]#{$el.regexp_quote(test)}['\"]"
+        else
+          Search.forward "^ *it ['\"]#{$el.regexp_quote(test)}['\"]"
+        end
+        Line.to_beginning
+        return
+      end
+
+      txt = self.run_spec path, test, bm
+      txt.sub! /^F\n\n1\)\n/, ''   # Remove 1st few lines
+      txt.sub! /^\.+\n\nFinished in.+\n\n/, ''   # Remove 1st when passing
+      txt.sub! /^\(irb\):.+/m, ''   # Remove everything after (irb)
+
+      txt.gsub! /^#{Bookmarks["$#{bm}"]}/m, './'   # Shorten the paths
+
+      txt.sub! /nil\n$/, ''
+      # CodeTree.no_search_option +
+
+      txt.gsub!(/.+\/gems\/rr-.+\n/, '')
+      txt.gsub!(/.+\/gems\/rspec-.+\n/, '')
+
+      txt.gsub(/^/, '| ')
+
+    end
+  end
+
+  def self.line_of_test path, test, bm
+    found = nil; number = 1
+    IO.foreach(Bookmarks["$#{bm}/#{path}"]) do |line|
+      if line =~ /^ *describe.+#{test}\b/
+        break found = number
+      end
+      number += 1
+    end
+    found
+  end
+
+  def self.run_spec path, test, bm
+    params = [path]
+
+    if test =~ /^#/   # If starts with #, find line number
+      found = self.line_of_test path, test, bm
+      params << "-l" << (found ? "#{found}" : "0")
+    elsif test.is_a?(String)
+      params << "-e" << test
+    end
+
+    #     command = bm == :x ?
+    #       command = "Spec::Runner::CommandLine.run(Spec::Runner::OptionParser.parse(#{params.inspect}, $out_bufr, $out_bufr))" :
+
+    # Rails
+    command = "require 'spec'; reload!; Spec::Runner::CommandLine.run(Spec::Runner::OptionParser.parse(#{params.inspect}, $out_bufr, $out_bufr))"
+
+    # Assume merb if a merb file exists
+    # Merb
+    if File.exists?(Bookmarks["$#{bm}/bin/merb"])
+      command = "Merb::Mailer.delivery_method=:test_send; Spec::Runner::CommandLine.run(Spec::Runner::OptionParser.parse(#{params.inspect}, $out_bufr, $out_bufr)); Merb::Mailer.delivery_method=nil"
+    end
+    result = RubyConsole[bm].run(command)
+    result
+  end
+
+  # Pastes in for the line in the clipboard:
+  #   Spec.foo "bar"
+  def self.enter_as_rspec
+
+    line = Line.value
+    orig = Location.new
+
+    clazz = View.file_name[/(\w+)_spec\.rb/, 1]
+    path = "xiki/tests/#{clazz}/"
+
+    # If on describe, just append and done
+    if line =~ /^ *describe/
+      describe = line[/"(.+)"/, 1]
+      path << "#{describe}/"
+    else # If on it, grab, then go to describe
+      test = line[/"(.+)"/, 1]
+      Search.backward "^ *describe "
+      describe = Line[/"(.+)"/, 1]
+      path << "#{describe}/#{test}/"
+    end
+
+
+    View.layout_todo :no_blink=>1
+    View.to_highest
+
+    View.insert("\n", :dont_move=>1) unless line.empty?   # Make room if line not blank
+    View.insert("\n", :dont_move=>1) if Line.value(2) =~ /^>/   # Add extra space if heading is after!
+
+    View.insert path
+
+    Move.to_axis
+    orig.go
+
+  end
+
+
+  def self.enter_as_test_from_visit
+    line = Clipboard[0]
+
+    params_str = line[/\{(.+)\}/, 1]
+    params = eval "{#{params_str}}"
+    params_symbols = params.map{|k, v| ":#{k}=>#{v.inspect}"} * ",\n    "
+
+    View.insert %Q`
+      it "__" do
+        c = dispatch_to(#{TextUtil.camel_case params['controller']}, #{params['action']},
+          #{params_symbols}) do |c|
+        end
+        c.body.should =~ /result...__/
+      end
+      `.unindent
+
+  end
+
+
+  def self.run_spec_in_place
+    Keys.clear_prefix
+    cursor = View.cursor
+
+    path = View.file.sub /.+\/spec\//, 'spec/'
+    command = "rspec #{path}:#{View.line}"
+    result = Console.run command, :dir=>"$x", :sync=>true
+    result = result.gsub(/^/, '    # ').gsub(/ +$/, '')
+
+    Search.forward '^  +end$'
+    Move.forward
+    View.insert result
+
+    View.cursor = cursor
+  end
+end
+
+Menu.rspec :menu=>"specs"

data/lib/styles.rb

@@ -0,0 +1,274 @@
+class Styles
+
+  def self.menu
+
+    '
+    - .font size/
+    - .background color/
+      - white/
+      - black/
+    - .list faces/
+    - api/
+      > Summary
+      | How to use the Styles class.  You can change the color and font of text.
+      | You define styles, then make them apply to the text that matches
+      | regular expression.
+      |
+      > Define
+      | Styles.define :red, :bg => "d77"
+      |
+      > Apply
+      | Styles.apply "apply", :red
+      |
+      > Define more complex font
+      | Styles.define :blueish,
+      |   :fg => "99e",
+      |   :face => "verdana",
+      |   :size => 90,
+      |   :bold => true
+      |
+      > See
+      | For styling specific text (not just a pattern):
+      <<< @overlay/
+    - see/
+      > List styles in current page in web browser
+      <<< @css/list/
+    '
+    #       > Apply multiple fonts and groups
+
+  end
+
+  def self.background_color color
+
+    $el.customize_set_variable(:background_mode_type, color == "black" ? :dark : :light)
+
+    Notes.define_styles
+    FileTree.define_styles
+    Styles.use_xiki_color_scheme
+    Styles.define_misc_face_colors
+    Color.define_styles
+
+    nil
+  end
+
+  def self.font_size size=nil
+
+    # If nothing passed, show default sizes
+
+
+    if ! size
+      return "
+        - original) #{Styles.height}
+        - 110
+        - 120
+        - 135
+        - 160
+        - 200
+        - 250
+        "
+    end
+
+    Styles.define :default, :size=>size.to_i
+
+    # To resize mode lines
+    Themes.use "Shiny Blue"
+    Notes.define_styles
+    FileTree.define_styles
+
+    nil
+  end
+
+  def self.zoom options={}
+
+    increment = options[:out] ? -10 : 10
+    increment *= 10 if Keys.prefix_u
+
+    height = self.height
+    height += increment
+    self.font_size height
+  end
+
+
+  def self.toggle
+    $el.elvar.font_lock_mode ?
+      $el.font_lock_mode(0) :   # plain text
+      $el.font_lock_mode(true)   # stylized text
+
+    nil
+  end
+
+  def self.list_faces
+    $el.with(:save_window_excursion) do
+      $el.list_faces_display
+    end
+    View.to_buffer "*Faces*"
+
+    nil
+  end
+
+  def self.inverse_bg enable=true
+    $el.customize_set_variable(:background_mode_type, enable ? :dark : :light)
+  end
+
+  def self.inverse
+    $el.boundp(:background_mode_type) &&
+      $el.elvar.background_mode_type.to_s == 'dark'
+  end
+
+  def self.exand_colors options, keys
+    keys.each do |key|
+      next if ! options[key]
+      options[key].sub! /^#/, ''
+      options[key].sub! /^(.)(.)(.)$/, "\\1\\1\\2\\2\\3\\3"
+    end
+  end
+
+  def self.method_missing *args
+    self.define *args
+  end
+
+  def self.define name, options
+
+    return if ! $el
+
+    self.exand_colors options, [:bg, :fg]
+
+    code = "(set-face-attribute (make-face '#{name.to_s.gsub("_", "-")}) nil\n"
+    code << "  :background \"##{options[:bg]}\"\n" if options[:bg]
+    code << "  :foreground \"##{options[:fg]}\"\n" if options[:fg]
+    code << "  :family \"#{options[:face]}\"\n" if options[:face]
+
+    if options[:size]
+      size = options[:size]
+      size = self.size(size.to_i) if size.is_a? String   # If a string, convert to relative size
+      code << "  :height #{size}\n"
+    end
+
+    code += options[:strike] ? "  :strike-through t\n" : "  :strike-through nil\n" if options.has_key?(:strike)
+
+    code += options[:underline] ? "  :underline t\n" : "  :underline nil\n" if options.has_key?(:underline)
+    code += options[:overline] ? "  :overline t\n" : "  :overline nil\n" if options.has_key?(:overline)
+
+    code += options[:bold] ? "  :weight 'bold\n" : "  :weight 'normal\n" if options.has_key?(:bold)
+    if options[:border]
+      border = options[:border]
+      code <<
+        if border.class == Symbol
+          ":box nil\n"
+        elsif border.class == String
+          ":box '(:line-width 1 :color \"##{border}\")\n"
+        elsif border.class == Array
+          ":box '(:line-width #{border[1]} :color \"##{border[0]}\" :style #{border[2] || 'nil'})\n"
+        end
+    end
+    code << "  )"
+
+    $el.el4r_lisp_eval code
+  end
+
+  def self.define_misc_face_colors
+
+    if Styles.inverse
+
+      Styles.define :font_lock_comment_face, :fg=>'777'   # gray
+      Styles.define :font_lock_function_name_face, :fg=>'f50'   # orange
+      Styles.define :font_lock_type_face, :fg=>'0a1'   # green
+      Styles.define :font_lock_variable_name_face, :fg=>'fd0'   # yellow
+      Styles.define :font_lock_string_face, :fg=>'e10'   # red
+      Styles.define :font_lock_keyword_face, :fg=>'999'
+
+    else
+
+      Styles.define :font_lock_comment_face, :fg=>'aaa'   # gray
+      Styles.define :font_lock_function_name_face, :fg=>'f50'   # orange
+      Styles.define :font_lock_type_face, :fg=>'090', :bold=>nil   # green
+      Styles.define :font_lock_variable_name_face, :fg=>'00c', :bold=>1   # yellow
+      Styles.define :font_lock_string_face, :fg=>'e10', :bold=>nil   # red
+      Styles.define :font_lock_keyword_face, :fg=>'888', :bold=>1   # blue
+
+    end
+
+  end
+
+  def self.apply(pattern, *styles)
+    # Make back-slashes double
+    pattern.gsub!("\\", '\\\\\\\\')
+    code = "(font-lock-add-keywords nil '(( \"#{pattern}\"\n"
+    styles.each_with_index do |f, i|
+      code << "  (#{i} '#{f.to_s.gsub("_", "-")})\n" if f
+    end
+    code << "  )))"
+    $el.el4r_lisp_eval code
+    $el.font_lock_mode 1
+    nil
+  end
+
+  def self.init
+    return if ! $el
+
+    # Make 'arial black' work in Linux
+    $el.el4r_lisp_eval %`
+      (custom-set-variables
+        '(face-font-family-alternatives '(
+          ("arial black" "arial" "DejaVu Sans")
+          ("arial" "DejaVu Sans")
+          ("verdana" "DejaVu Sans")
+          ;("verdana" "arial")
+          ))
+        '(global-font-lock-mode t nil (font-lock))
+        ;'(font-lock-defaults '(nil t))  ; messes up Open List Faces
+        '(show-trailing-whitespace t)
+        '(font-lock-keywords-case-fold-search t)
+        )
+      `
+  end
+
+  # Don't format quotes (it can override other styles)
+  def self.clear
+    $el.el4r_lisp_eval "(setq font-lock-defaults '(nil t))"
+  end
+
+  def self.height
+    $el.el4r_lisp_eval "(face-attribute 'default :height)"
+  end
+
+  def self.attribute style, attribute
+    $el.el4r_lisp_eval "(face-attribute '#{style} :#{attribute})"
+  end
+
+  def self.size relative=0
+    # Cache so subsequent calls don't have to look up from elisp
+    size = $el.el4r_lisp_eval "(face-attribute 'default :height)"
+    size ||= 90
+    size + relative * 5
+  end
+
+  def self.use_xiki_color_scheme
+    if Styles.inverse   # Use black
+      # Mode line (bar between windows)
+
+      $el.set_face_background :trailing_whitespace, "#333333"
+      Styles.define :default, :bg=>'111111', :fg=>'ffffff'
+      Styles.define :cursor, :bg=>'ffffff', :fg=>'000000'
+
+      Styles.define :fringe, :bg=>'111111', :fg=>'666666'
+
+      # Dark gray scheme
+      Styles.define :mode_line, :bg=>'333', :border=>['666', -1], :face=>'Lucida Grande', :size=>'3', :bold=>false, :fg=>'fff'
+      Styles.define :mode_line_inactive, :bg=>'666', :border=>['888', -1], :face=>'Lucida Grande', :size=>'3', :bold=>false, :fg=>'fff'
+
+    else
+      $el.set_face_background :trailing_whitespace, "#aaaaaa"
+      Styles.define :default, :bg=>'ffffff', :fg=>'000000'# , :height=>110
+      Styles.define :cursor, :bg=>'333333', :fg=>'ffffff'
+      Styles.define :fringe, :bg=>'ffffff', :fg=>'cccccc'   # eg border / status
+
+      Styles.define :mode_line, :fg=>'222222', :bg=>'555', :border=>['333', -1], :face=>'Lucida Grande', :size=>'3', :bold=>false
+      Styles.define :mode_line_inactive, :fg=>'999999', :bg=>'888', :border=>['666', -1], :face=>'Lucida Grande', :size=>'3', :bold=>false
+
+    end
+
+  end
+
+end
+Styles.init