ver 2009.10.14

data/lib/ver/plist.rb

@@ -0,0 +1,106 @@
+require 'nokogiri'
+
+module VER
+  module Plist
+    class XML
+      def initialize(xml)
+        @doc = Nokogiri(xml)
+        @plist = {}
+        @parsed = nil
+      end
+
+      def parse
+        @parsed || parse!
+      end
+
+      def parse!
+        dict = @doc.at('/plist/dict')
+
+        if dict
+          @parsed = handle_dict(dict)
+        else
+          raise ArgumentError, 'This is no XML plist'
+        end
+      end
+
+      def handle_array(array)
+        out = []
+        key = nil
+
+        array.children.each do |child|
+          child_name = child.name
+          next if child_name == 'text'
+
+          out.push(
+            case child_name
+            when 'key'
+              raise 'No key allows in array'
+            when 'array';           handle_array(child)
+            when 'dict';            handle_dict(child)
+            when 'false';           false
+            when 'integer', 'real'; child.inner_text.to_i
+            when 'string';          child.inner_text
+            when 'true';            true
+            else
+              # $unhandled[child_name] << child
+              raise "%p: %p is not handled" % [child_name, child]
+            end
+          )
+        end
+
+        out
+      end
+
+      def handle_dict(dict)
+        out = {}
+        key = nil
+
+        dict.children.each do |child|
+          child_name = child.name
+
+          case child_name
+          when 'key'; key = child.inner_text
+          when 'text' # ignore
+          else
+            raise 'No key given' unless key
+
+            out[key] =
+              case child_name
+              when 'array';           handle_array(child)
+              when 'dict';            handle_dict(child)
+              when 'false';           false
+              when 'integer', 'real'; child.inner_text.to_i
+              when 'string';          child.inner_text
+              when 'true';            true
+              else
+                # $unhandled[child_name] << child
+                raise "%p: %p is not handled" % [child_name, child]
+              end
+
+            key = nil
+          end
+        end
+
+        out
+      end
+
+      def to_yaml
+        parse.to_yaml
+      end
+
+      def to_json
+        parse.to_json
+      end
+
+      def to_hash
+        parse
+      end
+    end
+
+    module_function
+
+    def parse_xml(filename)
+      XML.new(File.read(filename)).parse
+    end
+  end
+end

data/lib/ver/status.rb

@@ -0,0 +1,67 @@
+module VER
+  # The status bar
+  class Status < VER::Entry
+    attr_accessor :keymap, :view
+    attr_reader :mode
+
+    def initialize(view, options = {})
+      options[:style] ||= self.class.obtain_style_name
+      super
+      self.view = view
+
+      keymap_name = VER.options.fetch(:keymap)
+      self.keymap = Keymap.get(name: keymap_name, receiver: self)
+    end
+
+    def destroy
+      style_name = style
+      super
+    ensure
+      self.class.return_style_name(style_name)
+    end
+
+    def mode=(name)
+      @keymap.mode = @mode = name.to_sym
+    end
+
+    def text
+      view.text
+    end
+
+    def ask(question, &callback)
+      @question, @backup_value, @callback = question, value, callback
+
+      message @question
+      focus
+    end
+
+    def ask_submit
+      answer = value.sub(@question, '')
+      result = @callback.call(answer)
+      message result.inspect
+    end
+
+    def ask_abort
+      message @backup_value
+      text.focus
+    end
+
+    def delete_char_left
+      return if @question.size == cursor
+      super
+    end
+
+    def go_char_left
+      return if @question.size == cursor
+      super
+    end
+
+    def go_word_left
+      if index = value.rindex(/.\b\s/, cursor - 1)
+        self.cursor = index
+      else
+        self.cursor = @question.size
+      end
+    end
+  end
+end

data/lib/ver/syntax.rb

@@ -0,0 +1,68 @@
+module VER
+  class Syntax
+    autoload :Detector, 'ver/syntax/detector'
+    autoload :Processor, 'ver/syntax/processor'
+
+    def self.list
+      VER.loadpath.map{|path| Dir[(path/'syntax/*.json').to_s] }.flatten
+    end
+
+    def self.from_filename(filename)
+      if syntax_name = Detector.detect(filename)
+        return new(syntax_name)
+      else
+        new 'Plain text'
+      end
+    end
+
+    def self.find(syntax_name)
+      VER.find_in_loadpath("syntax/#{syntax_name}.json")
+    end
+
+    def self.load(file)
+      raise(ArgumentError, "No path to syntax file given") unless file
+      Textpow::SyntaxNode.load(file)
+    end
+
+    def self.find_and_load(syntax_name)
+      load(find(syntax_name))
+    end
+
+    attr_accessor :parser, :name
+    attr_reader :theme
+
+    def initialize(name, theme = nil)
+      @name = name
+      @first_highlight = true
+      @old_theme = nil
+
+      @parser = self.class.find_and_load(name)
+      @theme  = theme || Theme.find_and_load(VER.options[:theme])
+    end
+
+    def highlight(textarea, code, lineno = 0)
+      if @old_theme
+        @old_theme.delete_tags_on(textarea)
+        @old_theme = nil
+      end
+
+      if @first_highlight
+        @theme.create_tags_on(textarea)
+        @theme.apply_default_on(textarea)
+        @first_highlight = false
+      else
+        @theme.remove_tags_on(textarea)
+      end
+
+      pr = Processor.new(textarea, @theme, lineno)
+
+      parser.parse(code, pr)
+    end
+
+    def theme=(theme)
+      @old_theme = @theme
+      @theme = theme
+      @first_highlight = true
+    end
+  end
+end

data/lib/ver/syntax/detector.rb

@@ -0,0 +1,53 @@
+module VER
+  class Syntax
+    module Detector
+      module_function
+
+      EXTS_LIST = {}
+      HEAD_LIST = {}
+
+      def exts(name, exts)
+        EXTS_LIST[name] = exts
+      end
+
+      def head(name, head)
+        HEAD_LIST[name] = head
+      end
+
+      def names
+        [EXTS_LIST.keys, HEAD_LIST.keys].flatten.compact.sort
+      end
+
+      def detect(filename, override_name = nil)
+        path = Pathname(filename.to_s)
+        path = path.readlink if path.symlink?
+
+        return unless path.file?
+
+        VER.load('detect')
+
+        override_name || detect_ext(path) || detect_head(path)
+      end
+
+      def detect_ext(path)
+        basename = path.basename.to_s
+        return unless basename =~ /\./
+
+        EXTS_LIST.find do |name, exts|
+          exts.find do |ext|
+            return name if basename.end_with?(ext)
+          end
+        end
+      end
+
+      def detect_head(path)
+        line = path.open{|io| io.gets }
+        return unless line && line.valid_encoding?
+
+        HEAD_LIST.find do |name, head|
+          return name if line =~ head
+        end
+      end
+    end
+  end
+end

data/lib/ver/syntax/processor.rb

@@ -0,0 +1,48 @@
+module VER
+  class Syntax
+    class Processor < Struct.new(:textarea, :theme, :lineno, :stack, :tags)
+      def start_parsing(syntax_name)
+        self.stack = []
+        self.tags = Hash.new{|h,k| h[k] = [] }
+      end
+
+      def end_parsing(syntax_name)
+        tags.each do |name, indices|
+          tag_name = theme.get(name) || name
+          textarea.fast_tag_add(tag_name, *indices)
+        end
+
+        stack.clear
+      end
+
+      def new_line(line)
+        self.lineno += 1
+      end
+
+      def open_tag(name, pos)
+        stack << [name, pos]
+
+        if tag_name = theme.get(name)
+          if stack.size > 1
+            below = theme.get(stack[-2][0])
+            textarea.tag_raise(tag_name, below) rescue nil
+          end
+        end
+      end
+
+      def close_tag(name, mark)
+        sname, pos = stack.pop
+
+        tags[name] << "#{lineno}.#{pos}" << "#{lineno}.#{mark}"
+      rescue RuntimeError => exception
+        # if you modify near the end of the textarea, sometimes the last tag
+        # cannot be closed because the contents of the textarea changed since
+        # the last highlight was issued.
+        # this will cause Tk to raise an error that doesn't have a message and
+        #  is of no major consequences.
+        # We swallow that exception to avoid confusion.
+        raise exception unless exception.message.empty?
+      end
+    end
+  end
+end

data/lib/ver/text.rb

@@ -0,0 +1,374 @@
+module VER
+  class Text < Tk::Text
+    include Methods
+
+    MODE_CURSOR = {
+      :insert       => {insertbackground: 'red',    blockcursor: false},
+      :control      => {insertbackground: 'green',  blockcursor: true},
+      :select_char  => {insertbackground: 'yellow', blockcursor: true},
+      :select_line  => {insertbackground: 'yellow', blockcursor: true},
+      :select_block => {insertbackground: 'yellow', blockcursor: true},
+    }
+
+    attr_accessor :keymap, :view, :status, :filename
+
+    def initialize(view, options = {})
+      super
+      self.view = view
+
+      keymap_name = VER.options.fetch(:keymap)
+      self.keymap = Keymap.get(name: keymap_name, receiver: self)
+
+      @selection_start = @highlight_thread = nil
+      @pristine = true
+    end
+
+    def short_filename
+      filename.sub(Dir.pwd + '/', '') if filename
+    end
+
+    def open_path(path)
+      @filename = Pathname(path.to_s).expand_path
+
+      begin
+        self.value = @filename.read
+        status.message "Opened #{short_filename}"
+      rescue Errno::ENOENT
+        clear
+        status.message "Create #{short_filename}"
+      end
+
+      after_open
+    end
+
+    def open_empty
+      clear
+      status.message "[No File]"
+      after_open
+    end
+
+    def after_open
+      VER.opened_file(self)
+
+      edit_reset
+
+      if @pristine
+        Thread.new do
+          wait_visibility
+          setup_highlight
+        end
+      else
+        setup_highlight
+      end
+
+      focus
+      mark_set :insert, '0.0'
+
+      @pristine = false
+    end
+
+    def layout
+      view.layout
+    end
+
+    def quit
+      Tk.exit
+    end
+
+    def insert_index
+      index(:insert).split('.').map(&:to_i)
+    end
+
+    def end_index
+      index(:end).split('.').map(&:to_i)
+    end
+
+    # lines start from 1
+    # end is maximum lines + 1
+    def status_projection(into)
+      format = "%s  %d,%d  %d%% [%s]"
+
+      insert_y, insert_x = insert_index
+      end_y, end_x       = end_index
+
+      percent = (100.0 / (end_y - 2)) * (insert_y - 1)
+      percent = 100.0 if percent.nan?
+
+      additional = [keymap.mode]
+      syntax_name = @syntax.name if @syntax
+      additional << syntax_name if syntax_name
+
+      values = [
+        short_filename,
+        insert_y, insert_x,
+        percent,
+        additional.join(' | '),
+      ]
+
+      into.value = format % values
+    end
+
+    TAG_ALL_MATCHING_OPTIONS = {
+      foreground: '#f00',
+      background: '#00f',
+    }
+
+    def tag_all_matching(name, regexp, options = {})
+      name = name.to_s
+
+      if tag_exists?(name)
+        tag_remove(name, '0.0', 'end')
+      else
+        options = TAG_ALL_MATCHING_OPTIONS.merge(options)
+        TktNamedTag.new(self, name, options)
+      end
+
+      start = '0.0'
+      while result = search_with_length(regexp, start, 'end - 1 chars')
+        pos, len, match = result
+        break if !result || len == 0
+
+        start = "#{pos} + #{len} chars"
+        tag_add name, pos, start
+      end
+    end
+
+    def tag_exists?(given_path)
+      list = tk_split_simplelist(tk_send_without_enc('tag', 'names', None), false, true)
+      list.include?(given_path)
+    end
+
+    # Wrap Tk methods to behave as we want and to generate events
+    def mark_set(mark_name, index)
+      super
+
+      return unless mark_name == :insert
+
+      Tk.event_generate(self, '<Movement>')
+    end
+
+    def refresh_selection
+      return unless start = @selection_start
+
+      now = index(:insert).split('.').map(&:to_i)
+      left, right = [start, now].sort.map{|pos| pos.join('.') }
+      tag_remove :sel, '0.0', 'end'
+
+      case keymap.mode
+      when :select_char
+        tag_add :sel, left, "#{right} + 1 chars"
+      when :select_line
+        tag_add :sel, "#{left} linestart", "#{right} lineend + 1 chars"
+      when :select_block
+        ly, lx = left.split('.').map(&:to_i)
+        ry, rx = right.split('.').map(&:to_i)
+
+        from_y, to_y = [ly, ry].sort
+        from_x, to_x = [lx, rx].sort
+
+        from_y.upto to_y do |y|
+          tag_add :sel, "#{y}.#{from_x}", "#{y}.#{to_x + 1}"
+        end
+      end
+    end
+
+    # fix the ruby definition of delete, Tk allows more than 2 indices
+    def delete(*args)
+      if args.size > 2
+        deleted = args.each_slice(2).map{|left, right| get(left, right) }
+      else
+        deleted = get(*args)
+      end
+
+      copy(deleted)
+
+      tk_send_without_enc('delete', *args)
+
+      touch!
+    end
+
+    def insert(*args)
+      super
+      touch!
+    end
+
+    def setup_highlight
+      return unless filename
+      return unless @syntax = Syntax.from_filename(filename)
+
+      @highlight_thread = create_highlight_thread
+    end
+
+    def create_highlight_thread
+      @highlight_thread = Thread.new{
+        this = Thread.current
+        this[:pending] = 1
+
+        loop do
+          if this[:pending] > 0
+            while this[:pending] > 0
+              this[:pending] -= 1
+              sleep 0.2
+            end
+
+            refresh_highlight!
+          else
+            sleep 0.5
+          end
+        end
+      }
+    end
+
+    def refresh_highlight(lineno = 0)
+      return unless @highlight_thread
+      @highlight_thread[:pending] += 1
+    end
+
+    def caret(keys=nil)
+      if keys
+        tk_call_without_enc('tk', 'caret', self, *hash_kv(keys))
+        self
+      else
+        lst = tk_split_list(tk_call_without_enc('tk', 'caret', self))
+        info = {}
+        while key = lst.shift
+          info[key[1..-1]] = lst.shift
+        end
+        info
+      end
+    end
+
+    def focus
+      super
+      Tk.event_generate(self, '<Focus>')
+    end
+
+    def fast_tag_add(tag, *indices)
+      tk_send_without_enc('tag', 'add', _get_eval_enc_str(tag), *indices)
+      self
+    end
+
+    def set_window_title
+      if filename
+        home = Pathname(ENV['HOME'])
+        dir, file = filename.split
+        dir_relative_to_home = dir.relative_path_from(home)
+
+        if dir_relative_to_home.to_s.start_with?('../')
+          title = "#{file} (#{dir}) - VER"
+        else
+          title = "#{file} (#{dir_relative_to_home}) - VER"
+        end
+      else
+        title = "[No Name] - VER"
+      end
+
+      VER.root['title'] = title
+    end
+
+    private
+
+    def refresh_highlight!
+      tag_all_matching('trailing_whitespace', /[ \t]+$/, foreground: '#000', background: '#f00')
+      @syntax.highlight(self, value, lineno = 0)
+    end
+
+    def touch!
+      Tk.event_generate(self, '<Modified>')
+    end
+
+    def copy(text)
+      if text.respond_to?(:to_str)
+        copy_string(text)
+      elsif text.respond_to?(:to_ary)
+        copy_array(text)
+      else
+        copy_fallback(text)
+      end
+    end
+
+    def copy_string(text)
+      TkClipboard.set(text = text.to_str)
+
+      copy_message text.count("\n"), text.size
+    end
+
+    def copy_array(text)
+      TkClipboard.set(text, type: Array)
+
+      copy_message text.size,  text.reduce(0){|s,v| s + v.size }
+    end
+
+    def copy_fallback(text)
+      TkClipboard.set(text)
+
+      status.message "Copied unkown entity of class %p" % [text.class]
+    end
+
+    def copy_message(lines, chars)
+      lines_desc = lines == 1 ? 'line' : 'lines'
+      chars_desc = chars == 1 ? 'character' : 'characters'
+
+      msg = "copied %d %s of %d %s" % [lines, lines_desc, chars, chars_desc]
+      status.message msg
+    end
+
+    def paste_continous(text)
+      if text =~ /\n/
+        mark_set :insert, 'insert lineend'
+        insert :insert, "\n"
+        insert :insert, text.chomp
+      else
+        insert :insert, text
+      end
+    end
+
+    def paste_tk_array(tk_array)
+      chunks = Tk.send(:simplelist, tk_array)
+
+      insert_y, insert_x = index(:insert).split('.').map(&:to_i)
+
+      chunks.each_with_index do |chunk, idx|
+        y = insert_y + idx
+        insert "#{y}.#{insert_x}", chunk
+      end
+    end
+
+    def mode=(name)
+      keymap.mode = mode = name.to_sym
+
+      cursor = MODE_CURSOR[mode]
+      configure cursor
+
+      return unless status && color = cursor[:insertbackground]
+      style = status.style
+      Tk::Tile::Style.configure style, fieldbackground: color
+    end
+
+    def load_theme(name)
+      return unless @syntax
+      return unless found = Theme.find(name)
+
+      @syntax.theme = Theme.load(found)
+      refresh_highlight
+
+      status.message "Theme #{found} loaded"
+    end
+
+    def load_syntax(name)
+      return unless @syntax
+      return unless found = Syntax.find(name)
+
+      theme = @syntax.theme
+      @syntax = Syntax.new(name, theme)
+      refresh_highlight
+
+      status.message "Syntax #{found} loaded"
+    end
+
+    def clear_selection
+      @selection_start = nil
+      tag_remove :sel, '0.0', 'end'
+    end
+  end
+end