ver 2009.12.14 → 2010.02

data/lib/ver/executor/fuzzy_file_finder.rb

@@ -0,0 +1,100 @@
+require 'ver/vendor/fuzzy_file_finder'
+
+module VER
+  class Executor
+    class ExFuzzyFileFinder < Entry
+      FFF = ::FuzzyFileFinder
+
+      def completed=(values)
+        path = Pathname(values.first)
+        self.value = path.relative_path_from(@pwd).to_s
+      end
+
+      def setup
+        tree.configure(
+          show: [:headings],
+          columns: %w[
+            path abbr directory name highlighted_directory highlighted_name
+            highlighted_path score
+          ],
+          displaycolumns: %w[
+            highlighted_path score
+          ],
+        )
+
+        tree.heading('path', text: 'Path')
+        tree.heading('abbr', text: 'Abbr')
+        tree.heading('directory', text: 'Directory')
+        tree.heading('name', text: 'Name')
+        tree.heading('highlighted_directory', text: 'Fuzzy Directory')
+        tree.heading('highlighted_name', text: 'Fuzzy Name')
+        tree.heading('highlighted_path', text: 'Fuzzy Path')
+        tree.heading('score', text: 'Score')
+
+        tree.column('path', stretch: true)
+        tree.column('score', width: 50, stretch: false)
+
+        setup_fff
+      end
+
+      def after_update
+        total = tree.winfo_width - 50
+
+        tree.column('highlighted_path', width: total, stretch: true)
+        tree.column('score', width: 50, stretch: false)
+      end
+
+      def setup_fff
+        @pwd = Pathname(Dir.pwd)
+        setup_fff_with(caller.project_root)
+      rescue FFF::TooManyEntries
+        setup_fff_with(@pwd)
+      rescue FFF::TooManyEntries
+        VER.message "The FuzzyFileFinder is overwhelmed by the amount of files"
+        callback.destroy
+        Tk.callback_break
+      end
+
+      def setup_fff_with(root)
+        @fffinder = FFF.new(root.to_s)
+      end
+
+      def update_items(values)
+        values.map do |value|
+          score = value.last
+          tag =
+            if score < 0.25; :icy
+            elsif score < 0.5; :cold
+            elsif score < 0.75; :warm
+            else; :hot
+            end
+
+          tree.insert(nil, :end, values: [*value], tags: [tag])
+        end
+      end
+
+      def choices(value)
+        choices = @fffinder.find(value).
+          sort_by{|match| [-match[:score], match[:path]] }
+        choices.map{|match|
+          [
+            match[:path],
+            match[:abbr],
+            match[:directory],
+            match[:name],
+            match[:highlighted_directory],
+            match[:highlighted_name],
+            match[:highlighted_path],
+            match[:score].round(2),
+          ]
+        }
+      end
+
+      def action(path)
+        throw(:invalid) unless File.file?(path)
+        VER.find_or_create_buffer(path)
+        callback.destroy(false)
+      end
+    end
+  end
+end

data/lib/ver/executor/grep.rb

@@ -0,0 +1,101 @@
+module VER
+  class Executor
+    # Grepping made easy
+    class ExGrep < Entry
+      def setup
+        @root = caller.project_root || Pathname(Dir.pwd)
+
+        tree.configure(
+          show: [:headings],
+          columns:        %w[file line source],
+          displaycolumns: %w[file line source],
+        )
+        tree.heading('file', text: 'File')
+        tree.heading('line', text: 'Line')
+        tree.heading('source', text: 'Source')
+      end
+
+      def after_update
+        total = tree.winfo_width - 50
+
+        tree.column('file',   width: (total * 0.3).to_i, stretch: false, anchor: :w)
+        tree.column('line',   width: 50,  stretch: false, anchor: :e)
+        tree.column('source', width: (total * 0.7).to_i, stretch: false, anchor: :w)
+      end
+
+      def choices(glob_needle)
+        choices = []
+
+        return [] if glob_needle =~ /^\s*$/
+
+        glob, needle = glob_needle.split(/\s+/, 2)
+        unless needle
+          glob, needle = '*', glob
+          self.value = "#{glob} #{needle}"
+        end
+
+        return [] if needle =~ /^\s*$/
+
+        begin
+          regexp = Regexp.new(needle)
+        rescue RegexpError, SyntaxError
+          regexp = Regexp.new(Regexp.escape(needle))
+        end
+
+        grep_with(glob, regexp)
+      end
+
+      def grep_with(glob, regexp, with_root = true)
+        results = []
+        root = with_root ? @root/glob : glob
+
+        root.glob do |path|
+          next unless path.file?
+
+          path.open do |io|
+            begin
+              io.each_line.with_index do |line, index|
+                next unless line =~ regexp
+                results << [path.to_s, index + 1, line]
+              end
+            rescue ArgumentError # why isn't that RegexpError or EncodingError
+            end
+          end
+        end
+
+        results
+      end
+
+      def action(selected)
+        item = tree.focus_item
+        file, line, _ = item.options(:values)
+        return unless file && line
+        VER.find_or_create_buffer(file.to_s, line.to_i)
+        callback.destroy(false)
+      end
+
+      # Ignore sync
+      def sync_value_with_tree_selection
+      end
+    end
+
+    # Grep the open buffers interactively
+    class ExGrepBuffers < ExGrep
+      def choices(needle)
+        choices = []
+        return choices if needle =~ /^\s*$/
+
+        files = VER.buffers.map{|name, buffer| buffer.filename }
+        glob = Pathname("{#{files.join(',')}}")
+
+        begin
+          regexp = Regexp.new(needle)
+        rescue RegexpError, SyntaxError
+          regexp = Regexp.new(Regexp.escape(needle))
+        end
+
+        grep_with(glob, regexp, false)
+      end
+    end
+  end
+end

data/lib/ver/executor/label.rb

@@ -0,0 +1,57 @@
+module VER
+  class Executor
+    autoload :ExFuzzyFileFinder, 'ver/executor/fuzzy_file_finder'
+    autoload :ExGrep,            'ver/executor/grep'
+    autoload :ExGrepBuffers,     'ver/executor/grep'
+    autoload :ExLocate,          'ver/executor/locate'
+    autoload :ExMethod,          'ver/executor/method'
+    autoload :ExPath,            'ver/executor/path'
+    autoload :ExSyntax,          'ver/executor/syntax'
+    autoload :ExTheme,           'ver/executor/theme'
+    autoload :ExWrite,           'ver/executor/path'
+    autoload :ExBuffer,          'ver/executor/buffer'
+
+    class ExLabel < Entry
+      COMPLETERS = {
+        'edit'         => :ExPath,
+        'fuzzy'        => :ExFuzzyFileFinder,
+        'grep'         => :ExGrep,
+        'grep_buffers' => :ExGrepBuffers,
+        'locate'       => :ExLocate,
+        'method'       => :ExMethod,
+        'open'         => :ExPath,
+        'syntax'       => :ExSyntax,
+        'theme'        => :ExTheme,
+        'write'        => :ExWrite,
+        'buffer'       => :ExBuffer,
+      }
+
+      def setup
+        tree.configure(
+          show: [],
+          columns: %w[ex],
+          displaycolumns: %w[ex],
+        )
+        tree.heading('ex', text: 'Execution Method')
+        update_only
+      end
+
+      def choices(name)
+        subset(name, COMPLETERS.keys)
+      end
+
+      def action(name)
+        completer_name = COMPLETERS.fetch(name)
+        completer = Executor.const_get(completer_name)
+        entry = callback.use_entry(completer)
+
+        self.value = completer_name
+        configure(state: :disabled, takefocus: false)
+
+        entry.focus
+        entry.update_only
+      rescue KeyError
+      end
+    end
+  end
+end

data/lib/ver/executor/locate.rb

@@ -0,0 +1,20 @@
+module VER
+  class Executor
+    class ExLocate < Entry
+      def setup
+        self.update_on_change = false
+      end
+
+      def choices(name)
+        return [] if name.strip.empty?
+        `locate -b0 '#{name}'`.split("\0")
+      end
+
+      def action(path)
+        throw(:invalid) if File.directory?(path)
+        VER.find_or_create_buffer(path)
+        callback.destroy(false)
+      end
+    end
+  end
+end

data/lib/ver/executor/method.rb

@@ -0,0 +1,80 @@
+module VER
+  class Executor
+    class ExMethod < Entry
+      def setup
+        @actions = caller.major_mode.actions.sort_by(&:method)
+
+        setup_tree
+      end
+
+      def setup_tree
+        tree.configure(
+          show: [:headings],
+          columns: %w[id method signature],
+          displaycolumns: %w[method signature],
+        )
+
+        tree.heading('method', text: 'Method')
+        tree.heading('signature', text: 'Signature')
+      end
+
+      def tree_selection_value
+        return unless item = tree.selection.first
+        item.options[:values][1]
+      end
+
+      def after_update
+        total = tree.winfo_width
+        third = total / 3
+
+        tree.column('method',    width: third, stretch: true)
+        tree.column('signature', width: third * 2, stretch: true)
+      end
+
+      def choices(name)
+        subset(name, @actions.map.with_index{|action, id|
+          receiver = action.receiver || caller
+          method = receiver.method(action.method)
+          [id, method.name.to_s, signature_of(method)]
+        }.compact, 1)
+      end
+
+      def accept_line(event)
+        self.tabcount = 0
+        return unless item = tree.selection.first
+        id = item.options[:values].first.to_i
+        return unless action = @actions[id]
+        callback.destroy
+        action.call(caller)
+      end
+
+      def action(id)
+        p id => @actions[id]
+        # eval("caller.#{method}")
+      rescue Exception => ex
+        VER.message ex.message
+      end
+
+      # TODO:
+      # Use YARD for this, my local clone is a bit dusty and broken.
+      # What I really want to do is extract @usage or similar, for now we use
+      # the signature because parsing all the docs is expensive.
+      def signature_of(method)
+        source_file, source_line = method.source_location
+        return '' unless source_file && source_line
+
+        File.open(source_file) do |io|
+          needle = source_line - 1
+
+          io.each_line.with_index do |line, index|
+            return line.strip if needle == index
+          end
+        end
+
+        return ''
+      rescue Errno::ENOENT # <gem_prelude>, eval, etc.
+        return ''
+      end
+    end
+  end
+end

data/lib/ver/executor/path.rb

@@ -0,0 +1,45 @@
+module VER
+  class Executor
+    # Open or focus a buffer with the given path.
+    class ExPath < Entry
+      def choices(origin)
+        origin = origin.sub(/^.*\/\//, '/')
+        origin = origin.sub(/^.*\/~\//, '~/')
+        origin = File.expand_path(origin) unless File.directory?(origin)
+
+        Dir.glob("#{origin}*").map do |path|
+          if File.directory?(path)
+            "#{path}/"
+          else
+            path
+          end
+        end
+      end
+
+      def action(selected)
+        path = selected || value
+        throw(:invalid) if File.directory?(path)
+        VER.find_or_create_buffer(path)
+        callback.destroy(false)
+      end
+    end
+
+    # Create new buffer with given filename and copy contents of current buffer
+    # into it.
+    # Then save it for good measure.
+    class ExWrite < ExPath
+      def action(selected)
+        path = selected || value
+        throw(:invalid) if File.directory?(path)
+
+        VER.find_or_create_buffer(path) do |buffer|
+          text = buffer.text
+          text.value = caller.value.chomp
+          Methods::Save.file_save(text)
+        end
+
+        callback.destroy(false)
+      end
+    end
+  end
+end

data/lib/ver/executor/syntax.rb

@@ -0,0 +1,22 @@
+module VER
+  class Executor
+    class ExSyntax < Entry
+      def setup
+        callback.update_on_change = true
+        @syntaxes = VER::Syntax.list.map{|fullpath|
+          File.basename(fullpath, File.extname(fullpath))
+        }
+      end
+
+      def choices(name)
+        subset(name, @syntaxes)
+      end
+
+      def action(name)
+        caller.load_syntax(name)
+        caller.touch!('1.0', 'end')
+        callback.destroy
+      end
+    end
+  end
+end

data/lib/ver/executor/theme.rb

@@ -0,0 +1,21 @@
+module VER
+  class Executor
+    class ExTheme < Entry
+      def setup
+        callback.update_on_change = true
+        @themes = VER::Theme.list.map{|fullpath|
+          File.basename(fullpath, File.extname(fullpath))
+        }
+      end
+
+      def choices(name)
+        subset(name, @themes)
+      end
+
+      def action(name)
+        caller.load_theme(name)
+        callback.destroy
+      end
+    end
+  end
+end