ver 2009.12.14 → 2010.02

data/lib/ver/theme.rb

@@ -3,36 +3,36 @@ module VER
     CACHE = {}
 
     def self.list
-      VER.loadpath.map{|path| Dir[(path/'theme/*.json').to_s] }.flatten
+      VER.loadpath.map{|path| Dir[(path/'theme/*.rb').to_s] }.flatten
     end
 
     def self.find(theme_name)
-      VER.find_in_loadpath("theme/#{theme_name}.json")
+      VER.find_in_loadpath("theme/#{theme_name}.rb")
     end
 
     def self.load(filename)
        raise(ArgumentError, "No path to theme file given") unless filename
 
-      json = JSON.load(File.read(filename.to_s))
-      uuid = json['uuid']
+      hash = eval(File.read(filename.to_s))
+      uuid = hash[:uuid]
 
-      CACHE[uuid] ||= create(uuid, json)
+      CACHE[uuid] ||= create(uuid, hash)
     end
 
     def self.create(uuid, hash)
       instance = new
-      instance.name = hash['name']
+      instance.name = hash[:name]
       instance.uuid = uuid
 
-      hash['settings'].each do |setting|
-        next unless settings = setting['settings']
+      hash[:settings].each do |setting|
+        next unless settings = setting[:settings]
 
-        if scope_names = setting['scope']
+        if scope_names = setting[:scope]
           # specific settings
           scope_names.split(/\s*,\s*/).each do |scope_name|
             instance.set(scope_name, settings)
           end
-        else
+        elsif !settings.empty?
           # general settings
           instance.default = settings
         end
@@ -45,6 +45,23 @@ module VER
       load(find(theme_name))
     end
 
+    R4G4B4 = '#%04x%04x%04x'
+
+    def self.tm_color_to_tk_color(color)
+      case color
+      when /^(#\h{6})\h{2}$/, /^(#\h{6})$/,/^(#\h{3})\h$/
+        color = $1
+      end
+
+      xcolor = FFI::Tk::get_color(Tk.interp, color)
+      R4G4B4 % [xcolor.red, xcolor.green, xcolor.blue]
+    end
+
+    def self.invert_rgb(color)
+      xcolor = FFI::Tk::get_color(Tk.interp, color)
+      R4G4B4 % [0xffff - xcolor.red, 0xffff - xcolor.green, 0xffff - xcolor.blue]
+    end
+
     def initialize(colors = {}, &block)
       self.colors = colors
       instance_eval(&block) if block_given?
@@ -75,10 +92,10 @@ module VER
         next unless value = settings.delete(key)
         next if value.empty?
 
-        if value =~ /^(#\h{6})/
-          settings[key] = $1
-        elsif key.downcase == 'fontstyle'
-          settings['font'] = fontstyle_as_font(value)
+        if value =~ /^#\h+$/
+          settings[key] = Theme.tm_color_to_tk_color(value)
+        elsif key.downcase == :fontstyle
+          settings[:font] = fontstyle_as_font(value)
         else
           settings[key] = value
         end
@@ -129,27 +146,29 @@ module VER
     # -spacing3, spacing3, Spacing3
 
     def apply_default_on(widget)
+      config = {}
+
       default.each do |key, value|
         case key.downcase
-        when 'background'
-          widget.configure background: value
-        when 'caret'
-          widget.configure insertbackground: value
-        when 'foreground', 'fg'
-          widget.configure foreground: value
-        when 'invisibles'
-          # TODO
-          # widget.configure key => value
-        when 'linehighlight'
+        when :background, :bg
+          config[:background] = value
+        when :caret
+          config[:insertbackground] = value
+        when :foreground, :fg
+          config[:foreground] = value
+        when :invisibles, :linehighlight
           # TODO
           # widget.configure key => value
-        when 'selection'
-          widget.configure selectbackground: value
+        when :selection
+          config[:selectbackground] = value
+          config[:selectforeground] = Theme.invert_rgb(value)
         else
           warn key => value
-          widget.configure(key => value)
+          config[key] = value
         end
       end
+
+      widget.default_theme_config = config
     end
 
     def create_tags_on(widget)
@@ -159,8 +178,12 @@ module VER
     end
 
     def remove_tags_on(widget, from, to)
+      outer_tags = widget.tag_names(from) & widget.tag_names(to)
+
       colors.each do |name, options|
-        widget.tag_remove(name.to_s, from, to) rescue nil
+        name = name.to_s
+        next if outer_tags.include?(name)
+        widget.tag_remove(name, from, to) rescue nil
       end
     end
 

data/lib/ver/treeview.rb

@@ -0,0 +1,54 @@
+module VER
+  # Some convenience methods for the default {Tk::Tile::Treeview}
+  class Treeview < Tk::Tile::Treeview
+    LINE_UP = <<-'TCL'.strip
+set children [%path% children {}]
+set children_length [llength $children]
+
+if { $children_length > 1 } {
+set item [%path% prev [%path% focus]]
+
+if { $item == {} } { set item [lindex $children [expr $children_length - 1]] }
+
+%path% focus $item
+%path% see $item
+%path% selection set $item
+}
+    TCL
+
+    # Go one item in the tree up, wraps around to the bottom if the first item
+    # has focus.
+    #
+    # Some lists may be huge, so we handle this in tcl to avoid lots of
+    # useless traffic between tcl and ruby.
+    # My apologies.
+    def line_up(event = nil)
+      Tk.eval(LINE_UP.gsub(/%path%/, tk_pathname))
+    end
+
+    LINE_DOWN = <<-'TCL'.strip
+set children [%path% children {}]
+set children_length [llength $children]
+
+if { $children_length > 1 } {
+set item [%path% next [%path% focus]]
+
+if { $item == {} } { set item [lindex $children 0] }
+
+%path% focus $item
+%path% see $item
+%path% selection set $item
+}
+    TCL
+
+    # Go one line in the tree down, wraps around to the top if the last item
+    # has focus.
+    #
+    # Some lists may be huge, so we handle this in tcl to avoid lots of
+    # useless traffic between tcl and ruby.
+    # My apologies.
+    def line_down(event = nil)
+      Tk.eval(LINE_DOWN.gsub(/%path%/, tk_pathname))
+    end
+  end
+end

data/lib/ver/undo.rb

@@ -43,6 +43,8 @@ module VER
         self.applied = current
         self.applied = current
         self.pending = nil
+
+        compact!
       end
 
       # Undo last applied change so it becomes the next pending change.
@@ -83,7 +85,7 @@ module VER
       def separate!
         applied.separator = true if applied
       end
-    end
+    end # Tree
 
     class AutoSeparator < Struct.new(:tree, :records)
       def initialize(tree)
@@ -115,7 +117,7 @@ module VER
           records << record
         end
       end
-    end
+    end # AutoSeparator
 
     # Every Record is responsible for one change that it can apply or undo.
     # There is only a very limited set of methods for modifications, as some of
@@ -151,41 +153,42 @@ module VER
         self.separator = false
       end
 
-      def insert(pos, string)
-        pos = widget.index(pos) unless pos.respond_to?(:to_index)
+      def insert(pos, string, tag = Tk::None)
+        pos = index(pos)
 
-        widget.execute_only(:insert, pos, string)
-        widget.touch!(pos)
+        widget.execute_only(:insert, pos, string, tag)
+        widget.touch!(pos.linestart, (pos + string.size).lineend)
 
-        self.redo_info = [:insert, pos, string]
+        self.redo_info = [:insert, pos, string, tag]
         self.undo_info = [pos, pos + string.size, '']
         self.applied = true
+        pos
       end
 
       def replace(from, to, string)
-        from = widget.index(from) unless from.respond_to?(:to_index)
-        to = widget.index(to) unless to.respond_to?(:to_index)
+        from, to = indices(from, to)
 
         data = widget.get(from, to)
         widget.execute_only(:replace, from, to, string)
-        widget.touch!(*from.upto(to))
+        widget.touch!(from.linestart, to.lineend)
 
         self.redo_info = [:replace, from, to, string]
         self.undo_info = [from, from + string.size, data]
         self.applied = true
+        from
       end
 
       def delete(from, to)
-        from = widget.index(from) unless from.respond_to?(:to_index)
-        to = widget.index(to) unless to.respond_to?(:to_index)
+        from, to = indices(from, to)
 
         data = widget.get(from, to)
         widget.execute_only(:delete, from, to)
-        widget.touch!(*from.upto(to))
+        widget.touch!(from.linestart, to.lineend)
 
         self.redo_info = [:delete, from, to]
         self.undo_info = [from, from, data]
         self.applied = true
+        from
       end
 
       def undo
@@ -193,13 +196,16 @@ module VER
 
         from, to, string = undo_info
         widget.execute_only(:replace, from, to, string)
+        widget.touch!(from.linestart, to.lineend)
+        widget.mark_set(:insert, from)
 
         self.applied = false
       end
 
       def redo
         return unless redo_info && !applied
-        send(*redo_info)
+        pos = send(*redo_info)
+        widget.mark_set(:insert, pos)
       end
 
       def compact!
@@ -281,9 +287,23 @@ module VER
         applied
       end
 
+      def indices(*given_indices)
+        given_indices.map do |index|
+          index.respond_to?(:to_index) ? index.to_index : widget.index(index)
+        end
+      end
+
+      def index(given_index)
+        if given_index.respond_to?(:to_index)
+          given_index.to_index
+        else
+          widget.index(given_index)
+        end
+      end
+
       def inspect
         "#<Undo::Record sep=%p undo=%p redo=%p>" % [separator, undo_info, redo_info]
       end
-    end
-  end
-end
+    end # Record
+  end # Undo
+end # VER

data/lib/ver/vendor/better_pp_hash.rb

@@ -0,0 +1,27 @@
+require 'pp'
+
+class PP
+  module PPMethods
+    # make hashes prettier
+    def pp_hash(obj)
+      group(1, '{', '}') do
+        seplist(obj, nil, :each_pair) do |k, v|
+          group do
+            if k.is_a?(Symbol) && k =~ /^\w+$/
+              text k.to_s
+              text ': '
+            else
+              pp k
+              text ' => '
+            end
+
+            group(1) do
+              breakable ''
+              pp v
+            end
+          end
+        end
+      end
+    end
+  end
+end

data/lib/ver/vendor/binary_search.rb

@@ -3,7 +3,7 @@ module VER
   # This allows you to find the last number that is valid for some condition
   # passed in a block in a fast manner rather than doing simple brute-force.
   #
-  # @usage for finding the highest value for pack('n')
+  # @example for finding the highest value for pack('n')
   #
   #   works = 0
   #   fails = 100_000
@@ -16,7 +16,7 @@ module VER
   # The reason this exists was to find the highest value for the time-to-live
   # arugment to MemCache#store.
   #
-  # @usage for finding the highest ttl of memcache
+  # @example for finding the highest ttl of memcache
   #
   #   require 'memcache'
   #   m = MemCache.new(['localhost:11211:1'], :namespace => 'manveru-session')

data/lib/ver/vendor/fuzzy_file_finder.rb

@@ -37,7 +37,7 @@ class FuzzyFileFinder
   module Version
     MAJOR = 1
     MINOR = 0
-    TINY  = 2
+    TINY  = 4
     STRING = [MAJOR, MINOR, TINY].join(".")
   end
 
@@ -58,7 +58,6 @@ class FuzzyFileFinder
         string
       end
     end
-    alias to_str to_s
   end
 
   # Used internally to represent a file within the directory tree.
@@ -103,11 +102,14 @@ class FuzzyFileFinder
   # The prefix shared by all +roots+.
   attr_reader :shared_prefix
 
+  # The list of glob patterns to ignore.
+  attr_reader :ignores
+
   # Initializes a new FuzzyFileFinder. This will scan the
   # given +directories+, using +ceiling+ as the maximum number
   # of entries to scan. If there are more than +ceiling+ entries
   # a TooManyEntries exception will be raised.
-  def initialize(directories=['.'], ceiling=10_000)
+  def initialize(directories=['.'], ceiling=10_000, ignores=nil)
     directories = Array(directories)
     directories << "." if directories.empty?
 
@@ -121,6 +123,8 @@ class FuzzyFileFinder
     @files = []
     @ceiling = ceiling
 
+    @ignores = Array(ignores)
+
     rescan!
   end
 
@@ -166,7 +170,7 @@ class FuzzyFileFinder
   #   the file matches the given pattern. A score of 1 means the
   #   pattern matches the file exactly.
   def search(pattern, &block)
-    pattern.strip!
+    pattern.gsub!(" ", "")
     path_parts = pattern.split("/")
     path_parts.push "" if pattern[-1,1] == "/"
 
@@ -213,18 +217,25 @@ class FuzzyFileFinder
     def follow_tree(directory)
       Dir.entries(directory.name).each do |entry|
         next if entry[0,1] == "."
+        next if ignore?(directory.name) # Ignore whole directory hierarchies
         raise TooManyEntries if files.length > ceiling
 
         full = File.join(directory.name, entry)
 
         if File.directory?(full)
           follow_tree(Directory.new(full))
-        else
+        elsif !ignore?(full.sub(@shared_prefix_re, ""))
           files.push(FileSystemEntry.new(directory, entry))
         end
       end
     end
 
+    # Returns +true+ if the given name matches any of the ignore
+    # patterns.
+    def ignore?(name)
+      ignores.any? { |pattern| File.fnmatch(pattern, name) }
+    end
+
     # Takes the given pattern string "foo" and converts it to a new
     # string "(f)([^/]*?)(o)([^/]*?)(o)" that can be used to create
     # a regular expression.
@@ -285,7 +296,9 @@ class FuzzyFileFinder
     def match_path(path, path_matches, path_regex, path_segments)
       return path_matches[path] if path_matches.key?(path)
 
-      matchable_name = path.name.sub(@shared_prefix_re, "")
+      name_with_slash = path.name + "/" # add a trailing slash for matching the prefix
+      matchable_name = name_with_slash.sub(@shared_prefix_re, "")
+      matchable_name.chop! # kill the trailing slash
 
       if path_regex
         match = matchable_name.match(path_regex)
@@ -303,8 +316,9 @@ class FuzzyFileFinder
     def match_file(file, file_regex, path_match, &block)
       if file_match = file.name.match(file_regex)
         match_result = build_match_result(file_match, 1)
-        full_match_result = File.join(path_match[:result], match_result[:result])
-        abbr = File.join(path_match[:result].gsub(/[^\/]+/) { |m| m.index("(") ? m : m[0,1] }, match_result[:result])
+        full_match_result = path_match[:result].empty? ? match_result[:result] : File.join(path_match[:result], match_result[:result])
+        shortened_path = path_match[:result].gsub(/[^\/]+/) { |m| m.index("(") ? m : m[0,1] }
+        abbr = shortened_path.empty? ? match_result[:result] : File.join(shortened_path, match_result[:result])
 
         result = { :path => file.path,
                    :abbr => abbr,