exfuz 0.1.0

data/lib/exfuz/fuzzy_finder_command.rb

@@ -0,0 +1,37 @@
+# frozen_string_literal: true
+
+module Exfuz
+  class FuzzyFinderCommand
+    attr_reader :selected
+
+    CMDS = { fzf: %w[fzf -m], peco: 'peco', percol: 'percol', sk: %w[sk -m] }.freeze
+
+    def initialize(command_type: :fzf)
+      @selected = ''
+      @cmd = CMDS[command_type] || CMDS[:fzf]
+    end
+
+    def run
+      stdio = IO.popen(@cmd, 'r+')
+      fiber = Fiber.new do |init_line|
+        puts_line(stdio, init_line)
+        loop do
+          line = Fiber.yield
+          puts_line(stdio, line)
+        end
+      end
+
+      yield fiber
+    ensure
+      stdio.close_write
+      @selected = stdio.each_line(chomp: true).to_a
+      stdio.close_read
+    end
+
+    private
+
+    def puts_line(stdio, line)
+      stdio.puts line
+    end
+  end
+end

data/lib/exfuz/group.rb

@@ -0,0 +1,34 @@
+# frozen_string_literal: true
+
+module Exfuz
+  class Group
+    def initialize(positions, keys)
+      @data = {}
+      @raw_positions = positions
+      create(positions, keys)
+    end
+
+    def create(positions, keys)
+      indices = (0...positions.size).to_a
+      keys.each do |key|
+        @data[key] = indices.group_by { |idx| positions[idx].slice(key) }
+                            .values
+      end
+    end
+
+    def key_positions(key)
+      @data[key].map do |grouping_indices|
+        @raw_positions[grouping_indices.first].slice(key)
+      end
+    end
+
+    def positions(key)
+      @data[key].each_with_object({}) do |grouping_indices, result|
+        key_position = @raw_positions[grouping_indices.first].slice(key)
+        result[key_position] = grouping_indices.map do |grouping_idx|
+          @raw_positions[grouping_idx]
+        end
+      end
+    end
+  end
+end

data/lib/exfuz/jump.rb

@@ -0,0 +1,29 @@
+# frozen_string_literal: true
+
+require 'json'
+
+module Exfuz
+  class Jump
+    OPERATOR_PATH = Exfuz::Util.wsl_to_windows(File.join(__dir__, './operator.ps1'))
+    # powershellのホストから見て、wslがリモート扱いのためBypassを付与
+    OPERATOR_CMD = "PowerShell.exe -ExecutionPolicy Bypass '$Input | #{OPERATOR_PATH}'"
+
+    def initialize(positions)
+      @positions = positions
+    end
+
+    def run
+      data = @positions.map do |p|
+        { to: p.bottom_name, info: p.jump_info }
+      end
+
+      result = nil
+      IO.popen(OPERATOR_CMD, 'r+') do |io|
+        io.puts JSON.unparse(data)
+        io.close_write
+        result = io.read
+      end
+      result
+    end
+  end
+end

data/lib/exfuz/key_map.rb

@@ -0,0 +1,116 @@
+# frozen_string_literal: true
+
+require 'curses'
+
+module Exfuz
+  class KeyMap
+    def initialize
+      @kmap = {}
+    end
+
+    def add_event_handler(key, obj, func: :update)
+      @kmap[key] ||= Exfuz::Event.new
+      @kmap[key].add_event_handler(obj, func)
+    end
+
+    def pressed(key, *args)
+      return unless @kmap.key?(key)
+
+      @kmap[key].fired(*args)
+    end
+  end
+
+  module Key
+    private_constant
+
+    # input_to_name_and_charで、文字と区別するためにシンボルで定義
+    CTRL_A = :ctrl_a
+    CTRL_E = :ctrl_e
+    CTRL_R = :ctrl_r
+    CTRL_H = :ctrl_h
+    CTRL_L = :ctrl_l
+    ESC = :esc
+    F1 = :f1
+    F2 = :f2
+    F3 = :f3
+    F4 = :f4
+    F5 = :f5
+    F6 = :f6
+    F7 = :f7
+    F8 = :f8
+    F9 = :f9
+    F10 = :f10
+    F11 = :f11
+    F12 = :f12
+    UP = :down
+    DOWN = :up
+    RIGHT = :right
+    LEFT = :left
+    BACKSPACE = :backspace
+    ENTER = :enter
+    CHAR = :char
+
+    # メモ化してもカーソル移動が若干遅い
+    INPUT_TO_SPECIAL_KEY_NAME = {
+      'OP' => F1,
+      'OQ' => F2,
+      'OR' => F3,
+      'OS' => F4,
+      '[15' => F5,
+      '[17' => F6,
+      '[18' => F7,
+      '[19' => F8,
+      '[20' => F9,
+      '[21' => F10,
+      '[23' => F11,
+      '[24' => F12,
+      '[A' => UP,
+      '[B' => DOWN,
+      '[C' => RIGHT,
+      '[D' => LEFT,
+      Curses::Key::ENTER => ENTER,
+      10 => ENTER,
+      27 => ESC,
+      Curses::KEY_CTRL_E => CTRL_E,
+      Curses::KEY_CTRL_R => CTRL_R,
+      Curses::KEY_CTRL_H => CTRL_H,
+      Curses::KEY_CTRL_L => CTRL_L,
+      127 => BACKSPACE # 現状は開発環境の値に合わせる (127 or 263)
+    }.freeze
+
+    module_function
+
+    def input_to_name_and_char(input)
+      case input
+      when Array
+        first = input.first
+        if special_key?(first)
+          input_to_special_key_name(input.slice(1, input.size - 1).join)
+        else
+          [CHAR, multibytes_to_char(input)]
+        end
+      when Integer
+        input_to_special_key_name(input)
+      when String
+        [CHAR, input]
+      end
+    end
+
+    def input_to_special_key_name(str_or_number)
+      INPUT_TO_SPECIAL_KEY_NAME[str_or_number]
+    end
+
+    def can_convert_to_name_and_char?(input)
+      name = input_to_name_and_char(input)
+      !name.nil? && name != ESC
+    end
+
+    def special_key?(number)
+      number == 27
+    end
+
+    def multibytes_to_char(multi_bytes)
+      multi_bytes.pack('C*').force_encoding(Encoding::UTF_8)
+    end
+  end
+end

data/lib/exfuz/main.rb

@@ -0,0 +1,59 @@
+# frozen_string_literal: true
+
+def read_data(xlsxs, candidates = [], status)
+  xlsxs.each_with_index do |xlsx, _idx|
+    p = Exfuz::Parser.new(xlsx)
+    p.parse
+    p.each_cell_with_all do |cell|
+      b = Exfuz::BookName.new(cell[:book_name])
+      s = Exfuz::SheetName.new(cell[:sheet_name])
+      c = Exfuz::Cell.new(address: cell[:cell], value: cell[:value])
+      candidates.push(Exfuz::Position.new([{ book_name: b }, { sheet_name: s }, { textable: c }]))
+    end
+
+    status.update(1)
+    sleep 1
+  end
+  candidates.close_push
+end
+
+def candidate_by(candidates, line, sep: ':')
+  lnum = line.split(sep)[0]
+  candidates[lnum.to_i - 1]
+end
+
+def main
+  xlsxs = Dir.glob('**/[^~$]*.xlsx')
+
+  status = Exfuz::Status.new(xlsxs.size)
+  candidates = Exfuz::Candidates.new
+  key_map = Exfuz::KeyMap.new
+  screen = Exfuz::Screen.new(status, key_map, candidates)
+
+  screen.init
+  Curses.close_screen
+  screen.init
+
+  Thread.new do
+    sleep 0.01
+    read_data(xlsxs, candidates, status)
+  end
+
+  loop do
+    unless Thread.list.find { |t| t.name == 'wating_for_input' }
+      in_t = Thread.new do
+        screen.rerender if screen.changed_state?
+      end
+      in_t.name = 'wating_for_input'
+    end
+
+    screen.wait_input
+    break if screen.closed?
+  end
+end
+
+if $PROGRAM_NAME == __FILE__
+  $LOAD_PATH.unshift(File.expand_path('..', __dir__))
+  require_relative '../exfuz'
+  main
+end

data/lib/exfuz/operator.ps1

@@ -0,0 +1,62 @@
+param( 
+ [Parameter(ValueFromPipeline=$true)][string]$in
+)
+$excel = New-Object -ComObject Excel.Application
+
+$excel.Visible = $true
+Function Jump($to, [ref]$info) {
+  switch ($to) {
+    'book_name' { $book = JumpBook $info.Value.book_name }
+    'sheet_name' { 
+        $book = JumpBook $info.Value.book_name 
+        if ($book) {
+            $sheet = JumpSheet ([ref]$book) $info.Value.sheet_name
+        }
+    }
+    'textable' { 
+        $book = JumpBook $info.Value.book_name
+        if ($book) {
+            $sheet = JumpSheet ([ref]$book) $info.Value.sheet_name 
+            $cell = JumpCell ([ref]$sheet) ([ref]$info.Value.textable) 
+        }
+    }
+    Default {}
+  }
+}
+
+Function IsOpen($path) {
+    $openedPaths = @($excel.Workbooks | % {$_.Path})
+    if ($null -eq $openedPaths) {
+      return $false
+    }
+    return $openedPaths.Contains($path)
+}
+
+Function JumpBook($path) {
+  if(IsOpen $path) {
+    return $null
+  }
+  $book = $excel.Workbooks.Open($path)
+  return $book
+}
+
+Function JumpSheet([ref]$book, $sheetName) {
+  $sheet = $book.Value.Worksheets($sheetName)
+  $sheet.Activate()
+  return $sheet
+}
+
+Function JumpCell([ref]$sheet, [ref]$cellPosition) {
+  $cell = $sheet.Value.Cells($cellPosition.Value.row, $cellPosition.Value.col)
+  $cell.Activate()
+  return $cell
+}
+
+$targets = ConvertFrom-Json $in
+try {
+  foreach ($target in $targets) {
+    $result = Jump $target.to ([ref]$target.info)
+  } 
+} finally {
+  #$excel.Quit()
+}

data/lib/exfuz/parser.rb

@@ -0,0 +1,67 @@
+require 'xsv'
+
+module Exfuz
+  class Parser
+    EXTENSIONS = ['.xlsx', '.xls', '.xlsm'].freeze
+
+    attr_reader :sheet_names
+
+    def initialize(path)
+      raise 'not exsits file' unless File.exist?(path)
+
+      extname = File.extname(path)
+      raise 'no match extension name' unless EXTENSIONS.include?(extname)
+
+      @absolute_path = File.absolute_path(path)
+      @book = nil
+      @sheet_names = []
+    end
+
+    def parse
+      @book = Xsv.open(@absolute_path)
+      @sheet_names = @book.sheets.map { |s| s.name.force_encoding(Encoding::UTF_8) }
+    end
+
+    def book_name
+      @absolute_path
+    end
+
+    def each_cell_with_all
+      @book.sheets.each do |sheet|
+        sheet_name = sheet.name
+        sheet.each_with_index do |row, r_i|
+          row.each_with_index do |val, c_i|
+            next if val.nil?
+
+            cell = {
+              book_name: book_name,
+              sheet_name: sheet_name,
+              cell: to_address(r_i + 1, c_i + 1),
+              value: val
+            }
+            yield cell
+          end
+        end
+      end
+    end
+
+    private
+
+    def to_address(r_idx, c_idx)
+      "$#{to_alphabet(c_idx)}$#{r_idx}"
+    end
+
+    def to_alphabet(idx)
+      large_a_z = ('A'..'Z').to_a
+      alphabet = ''
+      q = idx
+
+      until q.zero?
+        q, r = (q - 1).divmod(26)
+        alphabet.concat(large_a_z[r])
+      end
+
+      alphabet
+    end
+  end
+end

data/lib/exfuz/position.rb

@@ -0,0 +1,63 @@
+# frozen_string_literal: true
+
+module Exfuz
+  class Position
+    def initialize(hierarchy)
+      @key_to_obj = {}
+      @hierarchy = hierarchy
+      hierarchy.each do |h|
+        k = h.keys[0]
+        @key_to_obj[k] = h[k]
+
+        instance_eval "@#{k} = h[k]", __FILE__, __LINE__
+        self.class.send(:attr_reader, k)
+      end
+    end
+
+    def bottom_name
+      @key_to_obj.keys.last
+    end
+
+    def slice(key)
+      keys = @key_to_obj.keys
+      remaining = keys[0, (keys.find_index { |k| k == key }) + 1]
+      args = @hierarchy.filter do |h|
+        remaining.include?(h.keys[0])
+      end
+      Exfuz::Position.new(args)
+    end
+
+    def slice_keys(key)
+      keys = @key_to_obj.keys
+      keys[0, (keys.find_index { |k| k == key }) + 1]
+    end
+
+    def match?(conditions)
+      conditions.each do |key, value|
+        unless obj = @key_to_obj[key]
+          raise 'not exist key'
+        end
+
+        return false unless obj.match?(value)
+      end
+      true
+    end
+
+    def jump_info
+      keys = @key_to_obj.keys
+      keys.each_with_object({}) do |key, result|
+        obj = send(key)
+        result.merge!(obj.jump_info)
+      end
+    end
+
+    def ==(other)
+      other.class === self && other.hash == hash
+    end
+    alias eql? ==
+
+    def hash
+      @key_to_obj.values.hash
+    end
+  end
+end

data/lib/exfuz/query.rb

@@ -0,0 +1,103 @@
+# frozen_string_literal: true
+
+require 'unicode/display_width'
+require 'unicode/display_width/string_ext'
+
+module Exfuz
+  class Query
+    attr_reader :line, :caret
+
+    MAX_UTF_8_BYTES = 3
+
+    def initialize(caret)
+      @chars = []
+      @line = ''
+      @caret = caret
+      @offset = caret[1]
+    end
+
+    def text
+      @chars.join
+    end
+
+    def add(ch_or_chs)
+      if ch_or_chs.instance_of?(Array)
+        ch_or_chs.each do |ch|
+          insert_at_caret(ch)
+          right
+        end
+      elsif ch_or_chs.instance_of?(String)
+        insert_at_caret(ch_or_chs)
+        right
+      end
+    end
+
+    def delete
+      return if left_end?(@caret[1])
+
+      left
+      remove_at_caret
+    end
+
+    def right(direction = 1)
+      col = 0
+
+      col += 1 while direction > col && next_caret
+    end
+
+    def left(direction = 1)
+      col = 0
+
+      col += 1 while direction > col && prev_caret
+    end
+
+    private
+
+    # ['あ', nil]
+    # caret 0 -> 2 (right end)
+    def next_caret
+      return if right_end?(@caret[1])
+
+      idx = current - @offset
+      idx += 1 while idx < @chars.size - 1 && @chars[idx + 1].nil?
+      @caret[1] = @offset + idx + 1
+    end
+
+    # ['あ', nil]
+    # caret 2 -> 0 (left end)
+    def prev_caret
+      return if left_end?(@caret[1])
+
+      idx = current - @offset
+      idx -= 1 while !idx.zero? && @chars[idx - 1].nil?
+      @caret[1] = @offset + idx - 1
+    end
+
+    def insert_at_caret(ch)
+      r_arr = @chars.slice!((current - @offset)..-1)
+      @chars.concat([ch] + [nil] * (ch.display_width - 1) + r_arr)
+      @line = @chars * ''
+    end
+
+    # [a, あ, nil, い, nil] -> [a, い, nil]
+    # caret 1 -> 0
+    def remove_at_caret
+      r_arr = @chars.slice!((current - @offset)..-1)
+      deleted = r_arr.delete_at(0)
+      @chars.concat(r_arr.drop_while(&:nil?))
+      @line = @chars.clone.push(' ' * deleted.display_width) * ''
+    end
+
+    def current
+      @caret[1]
+    end
+
+    def left_end?(col)
+      @offset == col
+    end
+
+    def right_end?(col)
+      @chars.size + @offset == col
+    end
+  end
+end