kv 0.2.0

checksums.yaml

@@ -0,0 +1,7 @@
+---
+SHA256:
+  metadata.gz: 07f9b8b9be509c1a29acef17374146c9381713514e19c91a8a2942f9c2ba09e9
+  data.tar.gz: fb877ac8dbf8b5fac3f9b2c4e6690aa01fc25bca3b11fcf7abf88c52ef41fa23
+SHA512:
+  metadata.gz: c8c646ba69a9a977ea232dedaaff65db9f781d054e76d846913763821678c93c5362e7f4e153574d252505181da0a73a01b7865c38ac2c380c4bc9abaadcd6bc
+  data.tar.gz: eb9f37454be0ce707fbc02f6caae238541fe1865460e67de6c730a2eb81e2ba90d2fbaefa97f418426f19a8343e651b843f9943c61cd5e49cb2d22d15e5cde32

data/.gitignore

@@ -0,0 +1,8 @@
+/.bundle/
+/.yardoc
+/_yardoc/
+/coverage/
+/doc/
+/pkg/
+/spec/reports/
+/tmp/

data/LICENSE

@@ -0,0 +1,25 @@
+BSD 2-Clause License
+
+Copyright (c) 2020, Koichi Sasada
+All rights reserved.
+
+Redistribution and use in source and binary forms, with or without
+modification, are permitted provided that the following conditions are met:
+
+1. Redistributions of source code must retain the above copyright notice, this
+   list of conditions and the following disclaimer.
+
+2. Redistributions in binary form must reproduce the above copyright notice,
+   this list of conditions and the following disclaimer in the documentation
+   and/or other materials provided with the distribution.
+
+THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS "AS IS"
+AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE
+IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE ARE
+DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT HOLDER OR CONTRIBUTORS BE LIABLE
+FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL
+DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR
+SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER
+CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY,
+OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE
+OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.

data/README.md

@@ -0,0 +1,100 @@
+# kv: A page viewer written by Ruby
+
+kv is a page viewer designed for streaming data written by Ruby.
+
+## Installation
+
+Install it yourself as:
+
+    $ gem install kv
+
+# Usage
+
+kv requires Ruby and curses gem.
+
+## Use kv
+
+```
+# View [FILE]
+$ kv [OPTIONS] [FILE]
+
+# View results of [CMD]
+$ [CMD] | kv [OPTIONS]
+
+# View command help
+$ kv
+
+Options:
+    -f                               following mode like "tail -f"
+    -n, --line-number LINE           goto LINE
+```
+
+## Command on a pager
+
+```
+kv: A pager by Ruby Command list
+
+  ?: show the help message
+  q: quit
+
+  # Moving
+  k, j, [UP], [DOWN]:           move cursor (y)
+  h, l, [LEFT], [RIGTH]:        move cursor (x)
+  Ctrl-U, [PAGE UP]:            page up
+  Ctrl-D, [PAGE DOWN], [SPACE]: page down
+
+  g: Goto first line
+  G: Goto last line (current last line)
+  \d+: Goto specified line
+
+  # Loading
+  You can load a huge file or infinite input from a pipe.
+  10,000 lines ahead current line will be loaded.
+  If you want to load further lines the follwoing commands will help you.
+
+  F: Load remaining data or monitor a specified file and scroll forward.
+     Pushing any keys stops loading.
+     If a search string (specified by commadn "/") is specified,
+     stop scroll if the further input lines contains the string.
+
+  L: Toggle unlimited input mode
+
+  # Searching
+  /: search
+    When you enter a search string, you can choose
+    the following mode by Control key combination:
+      Ctrl-R: toggle Regexp mode (Ruby's regexp)
+      Ctrl-I: toggle ignore case mode
+    To clear search string, research with an empty string.
+  n: search next
+  p: search preview
+  f: filter mode (show only matched lines)
+
+  # Output
+  s: Save screen buffer to file
+
+  # Modes
+  N: toggle line mode
+  m: toggle mouse mode
+  t: terminal (REPL) mode
+  v: vi ("vi filename +[LINE]")
+```
+
+`G` is notable feature, `less` doesn't have. This feature jumps to "current" last line even if the pipe source command does not close output (== input for kv). You can refresh the last line by putting any command.
+
+## Mouse mode
+
+Not yet.
+
+## Terminal (REPL) mode
+
+Not yet.
+
+# Contributing
+
+Bug reports and pull requests are welcome on GitHub at https://github.com/ko1/kv.
+
+# Credit
+
+Created by Koichi Sasada at 2020.
+

data/Rakefile

@@ -0,0 +1,10 @@
+require "bundler/gem_tasks"
+require "rake/testtask"
+
+Rake::TestTask.new(:test) do |t|
+  t.libs << "test"
+  t.libs << "lib"
+  t.test_files = FileList["test/**/*_test.rb"]
+end
+
+task :default => :test

data/exe/kv

@@ -0,0 +1,11 @@
+#! /usr/bin/env ruby
+
+begin
+  require 'kv'
+rescue LoadError
+  $:.unshift File.join(__dir__, '../lib')
+  require 'kv'
+end
+
+kv = KV::KV.new ARGV
+kv.control

data/kv.gemspec

@@ -0,0 +1,31 @@
+require_relative 'lib/kv/version'
+
+Gem::Specification.new do |spec|
+  spec.name          = "kv"
+  spec.version       = KV::VERSION
+  spec.authors       = ["Koichi Sasada"]
+  spec.email         = ["ko1@atdot.net"]
+
+  spec.summary       = %q{kv: A page viewer written by Ruby}
+  spec.description   = %q{kv is a page viewer designed for streaming data written by Ruby.}
+  spec.homepage      = "https://github.com/ko1/kv"
+  spec.license       = "MIT"
+  spec.required_ruby_version = Gem::Requirement.new(">= 2.3.0")
+
+#  spec.metadata["allowed_push_host"] = "TODO: Set to 'http://mygemserver.com'"
+
+  spec.metadata["homepage_uri"] = spec.homepage
+  spec.metadata["source_code_uri"] = "https://github.com/ko1/kv"
+#  spec.metadata["changelog_uri"] = "TODO: Put your gem's CHANGELOG.md URL here."
+
+  # Specify which files should be added to the gem when it is released.
+  # The `git ls-files -z` loads the files in the RubyGem that have been added into git.
+  spec.files         = Dir.chdir(File.expand_path('..', __FILE__)) do
+    `git ls-files -z`.split("\x0").reject { |f| f.match(%r{^(test|spec|features)/}) }
+  end
+  spec.bindir        = "exe"
+  spec.executables   = spec.files.grep(%r{^exe/}) { |f| File.basename(f) }
+  spec.require_paths = ["lib"]
+
+  spec.add_runtime_dependency 'curses', '~> 1.3'
+end

data/lib/kv/version.rb

@@ -0,0 +1,3 @@
+module KV
+  VERSION = "0.2.0"
+end

data/lib/kv.rb

@@ -0,0 +1,666 @@
+# frozen_string_literal: true
+
+require "kv/version"
+require "curses"
+require 'stringio'
+require 'optparse'
+
+module KV
+class KV_PushScreen < Exception
+  attr_reader :screen
+  def initialize screen
+    @screen = screen
+  end
+end
+
+class KV_PopScreen < Exception
+end
+
+class KV_Screen
+  RenderStatus = Struct.new(
+    :c_cols, :c_lines, :x, :y,
+    :search, :goto, :line_mode, :render_full, :last_lineno
+  )
+  class RenderStatus
+    def to_s
+      'kv'
+    end
+  end
+
+  def initialize input, lines: [], search: nil, name: nil, following_mode: false, first_line: 0, line_mode: false
+    @rs = RenderStatus.new
+    @last_rs = nil
+    @rs.y = first_line
+    @rs.goto = first_line if first_line > 0
+    @rs.x = 0
+    @rs.last_lineno = 0
+    @rs.line_mode = line_mode
+    @rs.search = search
+
+    @name = name
+    @filename = @name if @name && File.exist?(@name)
+
+    @lines = lines
+    @mode = :screen
+
+    @following_mode = following_mode
+
+    @mouse = false
+    @search_ignore_case = false
+    @search_regexp = true
+    @loading = false
+    @buffer_lines = 10_000
+    @yq = Queue.new
+    @load_unlimited = false
+    @prev_render = {}
+
+    read_async input if input
+  end
+
+  def setup_line line
+    line = line.chomp
+    line.instance_variable_set(:@lineno, @rs.last_lineno += 1)
+    line
+  end
+
+  def read_async input
+    @loading = true
+    data = input.read_nonblock(4096)
+
+    lines = data.each_line.to_a
+    last_line = nil
+    lines.each{|line|
+      if line[-1] != "\n"
+        last_line = line
+        break
+      end
+      @lines << setup_line(line)
+    }
+
+    Thread.abort_on_exception = true
+    @reader_thread = Thread.new do
+      while line = input.gets
+        if last_line
+          line = last_line + line
+          last_line = nil
+        end
+
+        @lines << setup_line(line)
+        while !@load_unlimited && @lines.size > self.y + @buffer_lines
+          @yq.pop; @yq.clear
+        end
+        @yq.clear
+      end
+    ensure
+      if @filename
+        @file_mtime = File.mtime(@filename)
+        @file_lastpos = input.tell
+      end
+      input.close
+      @loading = false
+    end
+  end
+
+  def y_max
+    @lines.size - Curses.lines + 2
+  end
+
+  def y
+    @rs.y
+  end
+
+  def y=(y)
+    if y > (ym = self.y_max)
+      @rs.y = ym
+    else
+      @rs.y = y
+    end
+
+    @rs.y = 0 if @rs.y < 0
+    @yq << nil if @loading
+  end
+
+  attr_reader :x
+
+  def x=(x)
+    @rs.x = x
+    @rs.x = 0 if @rs.x < 0
+  end
+
+  def x
+    @rs.x
+  end
+
+  def init_screen
+    Curses.init_screen
+    Curses.stdscr.keypad(true)
+
+    if @mouse
+      Curses.mousemask(Curses::BUTTON1_CLICKED | Curses::BUTTON2_CLICKED |
+                       Curses::BUTTON3_CLICKED | Curses::BUTTON4_CLICKED)
+    else
+      Curses.mousemask(0)
+    end
+    self.y = @rs.y
+  end
+
+  
+  def standout
+    Curses.standout
+    yield
+    Curses.standend
+  end
+
+  def cattr attr
+    Curses.attron attr
+    begin
+      yield
+    ensure
+      Curses.attroff attr
+    end
+  end
+
+  def ctimeout ms
+    Curses.timeout = ms
+    begin
+      yield
+    ensure
+      Curses.timeout = -1
+    end
+  end
+
+  def screen_status status, post = nil
+    Curses.setpos Curses.lines-1, 0
+    Curses.addstr ' '.ljust(Curses.cols)
+
+    standout{
+      Curses.setpos Curses.lines-1, 0
+      Curses.addstr status
+    }
+    Curses.addstr post if post
+    Curses.standend
+  end
+
+  LINE_ATTR = Curses::A_DIM
+
+  def render_data
+    # check update
+    c_lines = Curses.lines
+    c_cols  = Curses.cols
+
+    if @rs != @last_rs
+      @last_rs = @rs.dup
+    else
+      return
+    end
+
+    Curses.clear
+
+    (c_lines-1).times{|i|
+      lno = i + self.y
+      line = @lines[lno]
+      cols = c_cols
+
+      unless line
+        if lno == @lines.size
+          Curses.setpos i, 0
+          cattr LINE_ATTR do
+            Curses.addstr '(END)'
+          end
+        end
+
+        break
+      end
+
+      Curses.setpos i, 0
+
+      if @rs.line_mode
+        cattr LINE_ATTR do
+          lineno = line.instance_variable_get(:@lineno)
+          ln_str = '%5d |' % lineno
+          if @rs.goto == lineno - 1 || (@rs.search && (@rs.search === line))
+            standout do
+              Curses.addstr(ln_str)
+            end
+          else
+            Curses.addstr(ln_str)
+          end
+          cols -= ln_str.size
+        end
+      end
+
+      line = line[self.x, cols] || ''
+
+      if !@rs.search || !(Regexp === @rs.search)
+        Curses.addstr line
+      else
+        partition(line, @rs.search).each{|(matched, str)|
+          if matched == :match
+            standout{
+              Curses.addstr str
+            }
+          else
+            Curses.addstr str
+          end
+        }
+      end
+    }
+  end
+
+  def search_str
+    if @rs.search
+      if str = @rs.search.instance_variable_get(:@search_str)
+        str
+      else
+        @rs.search.inspect
+      end
+    else
+      nil
+    end
+  end
+
+  def render_status
+    name = @name ? "<#{@name}>" : ''
+    mouse  = @mouse ? ' [MOUSE]' : ''
+    search = @rs.search ? " search[#{search_str}]" : ''
+    loading = @loading ? " (loading...#{@load_unlimited ? '!' : nil}#{@following_mode ? ' following' : ''}) " : ''
+    x = self.x > 0 ? " x:#{self.x}" : ''
+    screen_status "#{name} lines:#{self.y+1}/#{@lines.size}#{x}#{loading}#{search}#{mouse}"
+  end
+
+  def check_update
+    if @loading == false
+      if @filename && File.exist?(@filename) && File.mtime(@filename) > @file_mtime
+        input = open(@filename)
+
+        if input.size < @file_lastpos
+          screen_status "#{@filename} is truncated. Rewinded."
+          pause
+          @lineno = 0
+        else
+          input.seek @file_lastpos
+        end
+        read_async input
+      end
+    end
+  end
+
+  def render_screen
+    ev = nil
+
+    ms = @following_mode ? 100 : 500
+
+    ctimeout ms do
+      while ev == nil
+        render_data
+        render_status
+        ev = Curses.getch
+        check_update
+        if @following_mode
+          if @rs.search && search_next_move(self.y + 1)
+            break
+          end
+          self.y = self.y_max
+        end
+      end
+
+      if @following_mode
+        @following_mode = false
+        @load_unlimited = false
+      end
+
+      return ev
+    end
+  end
+
+  def search_next_move start
+    (start...@lines.size).each{|i|
+      if @rs.search === @lines[i]
+        self.y = i
+        return true
+      end
+    }
+    return false
+  end
+
+  def search_next start
+    if search_next_move start
+      # OK
+    else
+      screen_status "not found: [#{self.search_str}]"
+      pause
+    end
+  end
+
+  def search_prev start
+    start.downto(0){|i|
+      if @rs.search === @lines[i]
+        self.y = i
+        return true
+      end
+    }
+    screen_status "not found: [#{self.search_str}]"
+    pause
+  end
+
+  def key_name ev
+    Curses.constants.grep(/KEY/){|c|
+      return c if Curses.const_get(c) == ev
+    }
+    ev
+  end
+
+  def input_str pattern, str = ''.dup, other_actions: nil
+    loop{
+      ev = Curses.getch
+
+      case ev
+      when 10
+        return str
+      when Curses::KEY_BACKSPACE
+        str.chop!
+      when pattern
+        str << ev
+      else
+        if other_actions && (action = other_actions[ev])
+          action.call(ev)
+        else
+          log "failure: #{key_name ev}"
+          return nil
+        end
+      end
+    }
+  end
+
+  def pause
+    ev = Curses.getch
+    Curses.ungetch ev if ev
+  end
+
+  def control_screen
+    ev = render_screen
+
+    case ev
+    when 'q'
+      raise KV_PopScreen
+
+    when Curses::KEY_UP, 'k'
+      self.y -= 1
+    when Curses::KEY_DOWN, 'j'
+      self.y += 1
+    when Curses::KEY_LEFT, 'h'
+      self.x -= 1
+    when Curses::KEY_RIGHT, 'l'
+      self.x += 1
+    when 'g'
+      self.y = 0
+      self.x = 0
+    when 'G'
+      self.y = self.y_max
+      self.x = 0
+    when ' ', Curses::KEY_NPAGE, Curses::KEY_CTRL_D
+      self.y += Curses.lines-1
+    when Curses::KEY_PPAGE, Curses::KEY_CTRL_U
+      self.y -= Curses.lines-1
+
+    when /[0-9]/
+      screen_status "Goto:", ev
+      ystr = input_str(/\d/, ev)
+      if ystr && !ystr.empty?
+        @rs.goto = ystr.to_i - 1
+        self.y = @rs.goto
+      end
+
+    when 'F'
+      @following_mode = true
+      @load_unlimited = true
+      @yq << true
+
+    when 'L'
+      @load_unlimited = !@load_unlimited
+      @yq << true
+
+    when '/'
+      search_str = ''.dup
+
+      update_search_status = -> do
+        regexp = @search_regexp ? 'regexp' : 'string'
+        ignore = @search_ignore_case ? '/ignore' : ''
+        screen_status "Search[#{regexp}#{ignore}]:", search_str
+      end
+
+      update_search_status[]
+      input_str(/./, search_str, other_actions: {
+        Curses::KEY_CTRL_I => -> ev do
+          @search_ignore_case = !@search_ignore_case
+          update_search_status[]
+        end,
+        Curses::KEY_CTRL_R => -> ev do
+          @search_regexp = !@search_regexp
+          update_search_status[]
+        end,
+      })
+
+      if search_str && !search_str.empty?
+        ic = @search_ignore_case ? [Regexp::IGNORECASE] : []
+        if @search_regexp
+          begin
+            @rs.search = Regexp.compile(search_str, *ic)
+          rescue RegexpError => e
+            @rs.search = nil
+            screen_status "regexp compile error: #{e.message}"
+            pause
+          end
+        else
+          @rs.search = Regexp.compile(Regexp.escape(search_str), *ic)
+        end
+      else
+        @rs.search = nil
+      end
+      if @rs.search
+        @rs.search.instance_variable_set(:@search_str, search_str)
+        search_next self.y
+      end
+    when 'n'
+      search_next self.y+1 if @rs.search
+    when 'p'
+      search_prev self.y-1 if @rs.search
+    when 'f'
+      if @rs.search
+        filter_mode_title = "*filter mode [#{self.search_str}]*"
+        if @name != filter_mode_title
+          lines = @lines.grep(@rs.search)
+          fscr = KV_Screen.new nil, lines: lines, search: @rs.search, name: filter_mode_title
+          raise KV_PushScreen.new(fscr)
+        end
+      end
+
+    when 's'
+      screen_status "Save file:"
+      file = input_str /./
+      begin
+        if file && !file.empty?
+          if File.exist? file
+            screen_status "#{file.dump} exists. Override? [y/n] "
+            yn = input_str(/[yn]/)
+            if yn == 'y'
+              File.write(file, @lines.join("\n"))
+            else
+              # do nothing
+              end
+            else
+              File.write(file, @lines.join("\n"))
+            end
+          end
+        rescue SystemCallError
+          # TODO: status line
+        end
+
+    when 'v'
+      if @filename
+        system("vi #{@filename} +#{self.y + 1}")
+        @last_rs = nil
+      end
+
+    when 'm'
+      @mouse = !@mouse
+      Curses.close_screen
+      init_screen
+    when Curses::KEY_MOUSE
+      m = Curses.getmouse
+      log m, "mouse ->"
+      # log [m.bstate, m.x, m.y, m.z, m.eid]
+      log @lines[self.y + m.y]
+
+    when 'N'
+      @rs.line_mode = !@rs.line_mode
+    when 't'
+      Curses.close_screen
+      @mode = :terminal
+
+    when '?'
+      raise KV_PushScreen.new(KV_Screen.new help_io)
+
+    when nil
+      # ignore
+
+    else
+      screen_status "unknown: #{key_name(ev)}"
+      pause
+    end
+  end
+
+  def control_terminal
+    @rs.instance_eval('binding').irb
+
+    @mode = :screen
+    init_screen
+    @last_rs = nil
+  end
+
+  def control
+    case @mode
+    when :screen
+      control_screen
+    when :terminal
+      control_terminal
+    else
+      raise
+    end
+  end
+end
+
+class KV
+  def initialize argv
+    @opts = {
+      following_mode: false,
+      first_line: 0,
+      line_mode: false,
+    }
+
+    files = parse_option(argv)
+
+    @pipe_in = nil
+
+    if files.empty?
+      if STDIN.isatty
+        input = help_io
+        name = 'HELP'
+      else
+        input = STDIN.dup
+        STDIN.reopen('/dev/tty')
+        name = nil
+        @pipe_in = input
+      end
+    else
+      name = files.shift
+      begin
+        input = open(name)
+      rescue
+        if /(.+):(\d+)/ =~ name
+          name = $1
+          @first_line = $2.to_i - 1
+          retry
+        end
+        raise
+      end
+    end
+
+    trap(:INT){
+      log "SIGINT"
+    }
+
+    @screens = [KV_Screen.new(input, name: name, **@opts)]
+  end
+
+  def parse_option argv
+    opts = OptionParser.new
+    opts.on('-f', 'following mode like "tail -f"'){
+      @opts[:following_mode] = true
+    }
+    opts.on('-n', '--line-number LINE', 'goto LINE'){|n|
+      @opts[:first_line] = n.to_i - 1
+    }
+    opts.on('-N', 'Show lines'){
+      @opts[:line_mode] = true
+    }
+    opts.parse!(argv)
+  end
+
+  def control
+    @screens.last.init_screen
+    until @screens.empty?
+      begin
+        @screens.last.control
+      rescue KV_PopScreen
+        @screens.pop
+      rescue KV_PushScreen => e
+        @screens.push e.screen
+      end
+    end
+  ensure
+    Curses.close_screen
+    log "terminate"
+  end
+end
+end
+
+$debug_log = ENV['KV_DEBUG']
+
+def log obj, prefix = ''
+  if $debug_log
+    File.open($debug_log, 'a'){|f|
+      f.puts "#{$$} #{prefix}#{obj.inspect}"
+    }
+  end
+end
+
+def partition str, search
+  results = []
+  loop{
+    r = str.match(search){|m|
+      break if m.post_match == str
+      results << [:unmatch, m.pre_match]
+      results << [:match, m.to_s]
+      str = m.post_match
+    }
+    break unless r
+  }
+  results << [:unmatch, str]
+end
+
+def help_io
+  readme = File.read(File.join(__dir__, '../README.md'))
+  help = []
+  readme.each_line{|line|
+    if /kv: A pager by Ruby Command list/ =~ line
+      help << line
+    elsif /^```/ =~ line && !help.empty?
+      break
+    elsif !help.empty?
+      help << line
+    end
+  }
+
+  help_io = StringIO.new(help.join)
+end

metadata

@@ -0,0 +1,68 @@
+--- !ruby/object:Gem::Specification
+name: kv
+version: !ruby/object:Gem::Version
+  version: 0.2.0
+platform: ruby
+authors:
+- Koichi Sasada
+autorequire: 
+bindir: exe
+cert_chain: []
+date: 2020-02-08 00:00:00.000000000 Z
+dependencies:
+- !ruby/object:Gem::Dependency
+  name: curses
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: '1.3'
+  type: :runtime
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: '1.3'
+description: kv is a page viewer designed for streaming data written by Ruby.
+email:
+- ko1@atdot.net
+executables:
+- kv
+extensions: []
+extra_rdoc_files: []
+files:
+- ".gitignore"
+- LICENSE
+- README.md
+- Rakefile
+- exe/kv
+- kv.gemspec
+- lib/kv.rb
+- lib/kv/version.rb
+homepage: https://github.com/ko1/kv
+licenses:
+- MIT
+metadata:
+  homepage_uri: https://github.com/ko1/kv
+  source_code_uri: https://github.com/ko1/kv
+post_install_message: 
+rdoc_options: []
+require_paths:
+- lib
+required_ruby_version: !ruby/object:Gem::Requirement
+  requirements:
+  - - ">="
+    - !ruby/object:Gem::Version
+      version: 2.3.0
+required_rubygems_version: !ruby/object:Gem::Requirement
+  requirements:
+  - - ">="
+    - !ruby/object:Gem::Version
+      version: '0'
+requirements: []
+rubygems_version: 3.2.0.pre1
+signing_key: 
+specification_version: 4
+summary: 'kv: A page viewer written by Ruby'
+test_files: []