ver 2009.12.14 → 2010.02

data/lib/ver/methods/shortcuts.rb

@@ -1,21 +0,0 @@
-module VER
-  module Methods
-    module Shortcuts
-      include Move, Save, Open, Views, Insert
-
-      alias q view_close
-      alias q! quit
-      alias w file_save
-      alias r insert_file_contents
-      alias e open_path
-      alias o view_find_or_create
-      alias bn view_focus_next
-      alias bp view_focus_prev
-      alias bd view_close
-
-      def wq
-        w and q
-      end
-    end
-  end
-end

data/lib/ver/methods/views.rb

@@ -1,81 +0,0 @@
-module VER
-  module Methods
-    module Views
-      def view_focus(index = 0)
-        return unless found = layout.views[index - 1]
-        found.push_top
-      end
-
-      def view_find_or_create(file)
-        view.find_or_create(file)
-      end
-
-      def view_create
-        view.create
-      end
-
-      def view_close
-        view.close
-      end
-
-      def view_focus_next
-        view.focus_next
-      end
-
-      def view_focus_prev
-        view.focus_prev
-      end
-
-      def view_push_up
-        view.push_up
-      end
-
-      def view_push_down
-        view.push_down
-      end
-
-      def view_push_top
-        view.push_top
-      end
-
-      def view_push_bottom
-        view.push_bottom
-      end
-
-      def view_one
-        layout.options.merge! master: 1, stacking: 0
-        layout.apply
-      end
-
-      def view_two
-        layout.options.merge! master: 1, stacking: 1
-        layout.apply
-      end
-
-      def view_slave_inc
-        stacking = layout.options[:stacking]
-        unless stacking >= layout.views.size
-          layout.options[:stacking] += 1
-          layout.apply
-        end
-      end
-
-      def view_slave_dec
-        stacking = layout.options[:stacking]
-        layout.options[:stacking] -= 1 if stacking > 0
-        layout.apply
-      end
-
-      def view_master_inc
-        layout.options[:master] += 1
-        layout.apply
-      end
-
-      def view_master_dec
-        master = layout.options[:master]
-        layout.options[:master] -= 1 if master > 0
-        layout.apply
-      end
-    end
-  end
-end

data/lib/ver/mode.rb

@@ -1,207 +0,0 @@
-module VER
-  class Mode
-    MERGER = proc{|key, v1, v2|
-      if v1.respond_to?(:merge) && v2.respond_to?(:merge)
-        v1.merge(v2, &MERGER)
-      else
-        v2
-      end
-    }
-
-    attr_accessor :callback, :name, :arguments
-
-    def inspect
-      "#<Mode #@name>"
-    end
-
-    def initialize(name, callback)
-      @name, @callback = name, callback
-      @stack = []
-      @map = {}
-      @ancestors = []
-      @missing = nil
-      @arguments = callback.arguments
-    end
-
-    def inherits(*others)
-      others.flatten.each do |other|
-        ancestor = find_ancestor(other.to_sym)
-        @ancestors.delete ancestor
-        @ancestors.unshift ancestor
-      end
-    end
-
-    def find_ancestor(name)
-      if found = callback.modes[name.to_sym]
-        return found
-      else
-        raise "Mode #{name} is not specified yet"
-      end
-    end
-
-    def ancestors(*done, &block)
-      yield self
-
-      @ancestors.each do |ancestor|
-        next if done.include?(ancestor)
-        yield ancestor
-        ancestor.ancestors(done + [self], &block)
-      end
-    end
-
-    def missing(sym)
-      @missing = sym
-    end
-
-    def map(sym, *keychains)
-      keychains.each do |keychain|
-        bind(keychain.flatten, sym)
-      end
-    end
-    alias key map
-
-    def bind(keychain, action_name = nil, &block)
-      keychain = keychain.dup
-      total = hash = {}
-
-      while key = keychain.shift
-        if key.is_a?(Symbol)
-          canonical = callback.modes[key]
-        else
-          canonical = register(key)
-        end
-
-        if keychain.empty?
-          hash[canonical] = block || action_name
-        else
-          hash = hash[canonical] = {}
-        end
-      end
-
-      @map.replace @map.merge(total, &MERGER)
-    end
-
-    def register(key)
-      callback.register(key)
-    end
-
-    def enter_keys(*keys)
-      keys.flatten.each{|key| enter_key(key) }
-    end
-
-    def enter_key(key)
-      @stack << key
-
-      ancestors do |ancestor|
-        result = ancestor.attempt_execute(@stack.dup)
-
-        case result
-        when nil # nothing matched yet, but possible in future
-          return nil
-        when false # nothing possible
-          # try next one
-        when true # executed
-          @stack.clear
-          return true
-        else
-          raise "%p is not a valid result" % [result]
-        end
-      end
-
-      # no ancestors or all failed
-      @stack.clear
-      enter_missing(key)
-    rescue => ex
-      VER.error(ex)
-      @stack.clear
-    end
-
-    def enter_missing(key)
-      execute(@missing, key) if @missing
-    end
-
-    def attempt_execute(original_stack, lookup = false)
-      if arguments
-        stack, arg = Mode.split_stack(original_stack)
-      else
-        stack, arg = original_stack, nil
-      end
-
-      if stack.empty?
-        arg ? nil : false
-      else
-        executable = @map
-        while key = stack.shift
-          previous = executable
-          executable = executable[key]
-
-          case executable
-          when nil
-            return false unless previous.respond_to?(:find)
-
-            # FIXME: this allows only one mode
-            found = previous.find{|prev_key, prev_value| prev_key.is_a?(Mode) }
-            return false unless found
-
-            mode, action = found
-            looked = mode.attempt_execute([key, *stack], true)
-
-            case looked
-            when false
-              return false
-            when nil
-              return nil
-            else
-              cmd, cmd_arg = looked
-              return nil if cmd.is_a?(Hash)
-              return execute(action, cmd, arg)
-            end
-          end
-        end
-
-        if lookup
-          return executable, arg
-        else
-          execute(executable, *arg)
-        end
-      end
-    end
-
-    def execute(executable, *arg)
-      arg = [*arg].compact # doesn't allow nil
-      case executable
-      when Hash
-        return nil
-      when Symbol
-        callback.send(executable, *arg)
-      when Array
-        callback.send(*executable, *arg)
-      when Proc
-        executable.call(*arg)
-      else
-        return false
-      end
-
-      true
-    rescue ArgumentError => ex
-      callback.message("#{executable} : #{ex}")
-      true
-    end
-
-    def self.split_stack(stack)
-      first = stack[0]
-      return stack, nil if first == '0' || first == '<KeyPress-0>'
-
-      pivot = stack.index{|c| c !~ /^(<KeyPress-\d+>|\d+)$/ }
-
-      if pivot == 0
-        return stack, nil
-      elsif pivot
-        keys, args = stack[pivot..-1], stack[0..pivot]
-        return keys, args.join.scan(/\d+/).join.to_i
-      else
-        return [], stack.join.to_i
-      end
-    end
-  end
-end

data/lib/ver/status/context.rb

@@ -1,166 +0,0 @@
-module VER
-  class Status
-    class Context < Struct.new(:text)
-      def filename(width = 0)
-        "%#{width}s" % text.filename
-      end
-      alias F filename
-
-      def basename(width = 0)
-        "%#{width}s" % text.filename.basename
-      end
-      alias f basename
-
-      def relative(width = 0)
-        "%#{width}s" % text.short_filename
-      end
-      alias r relative
-
-      def dir(width = 0)
-        "%#{width}s" % text.filename.directory
-      end
-      alias d dir
-
-      def line(width = 0)
-        "%#{width}s" % (text.count(1.0, :insert, :lines) + 1)
-      end
-      alias l line
-
-      def lines(width = 0)
-        "%#{width}s" % text.count(1.0, :end, :lines)
-      end
-      alias L lines
-
-      def column(width = 0)
-        "%#{width}s" % text.count('insert linestart', :insert, :displaychars)
-      end
-      alias c column
-
-      def percent
-        here = text.count(1.0, :insert, :lines)
-        total = text.count(1.0, :end, :lines)
-        percent = ((100.0 / total) * here).round
-
-        case percent
-        when 100; 'Bot'
-        when 0  ; 'Top'
-        else    ; '%2d%%' % percent
-        end
-      end
-      alias P percent
-
-      def buffer(width = 0)
-        "%#{width}s" % text.layout.views.index(text.view)
-      end
-      alias b buffer
-
-      def buffers(width = 0)
-        "%#{width}s" % text.layout.views.size
-      end
-      alias B buffers
-
-      def encoding(width = 0)
-        "%#{width}s" % text.encoding
-      end
-      alias e encoding
-
-      def syntax(width = 0)
-        "%#{width}s" % text.syntax.name if text.syntax
-      end
-      alias s syntax
-
-      def mode(width = 0)
-        "%#{width}s" % text.keymap.mode
-      end
-      alias m mode
-
-      # format sequences:
-      #
-      # %c Current capacity (mAh)
-      # %r Current rate
-      # %b short battery status, '+', '-', '!'
-      # %p battery load percentage
-      # %m remaining time in minutes
-      # %h remaining time in hours
-      # %t remaining time in as 'H:M'
-      def battery(format = '[%b] %p% %t')
-        now = Time.now
-
-        if @battery_last
-          if @battery_last < (now - 60)
-            @battery_last = now
-            @battery_value = battery_build(format)
-          else
-            @battery_value
-          end
-        else
-          @battery_last = now
-          @battery_value = battery_build(format)
-        end
-      rescue => ex
-        puts ex, *ex.backtrace
-        ex.message
-      end
-
-      def battery_build(format)
-        total = {}
-
-        Dir.glob('/proc/acpi/battery/*/{state,info}') do |file|
-          parsed = battery_parse(file)
-          next unless parsed[:present] == 'yes'
-          # FIXME: doesn't take care of multiple batteries
-          total.merge!(parsed)
-        end
-
-        # rate might be 0
-        rate = total[:present_rate].to_i
-        capacity = total[:remaining_capacity].to_i
-
-        if rate == 0
-          hours, percent = 2, 100
-          time = hours_left = minutes_left = 'N/A'
-        else
-          hours, minutes = ((capacity * 60.0) / rate).divmod(60)
-          minutes = minutes.round
-          percent = ((100 / total[:last_full_capacity].to_f) * capacity).round
-          hours_left = (hours + (minutes / 60.0)).round
-          minutes_left = (hours / 60.0) + minutes
-          time = "#{hours}:#{minutes}"
-        end
-
-        case total[:charging_state]
-        when 'discharging'
-          b = hours < 1 ? '!' : '-'
-        when 'charging'
-          b = '+'
-        end
-
-        final = {
-          '%c' => capacity,
-          '%r' => rate,
-          '%b' => b,
-          '%p' => percent,
-          '%m' => minutes_left,
-          '%h' => hours_left,
-          '%t' => time,
-        }
-
-        @last = Time.now
-        format.gsub(/%\w/, final)
-      end
-
-      def battery_parse(file)
-        data = {}
-
-        File.open(file) do |io|
-          io.each_line do |line|
-            next unless line =~ /^([^:]+):\s*(.+)$/
-            data[$1.downcase.tr(' ', '_').to_sym] = $2
-          end
-        end
-
-        data
-      end
-    end
-  end
-end