ned 0.0.1

checksums.yaml

@@ -0,0 +1,7 @@
+---
+SHA256:
+  metadata.gz: 23d27cc1a81863250fe7b264e9199fb794c8d3e62fe879dab529f3201019e2f2
+  data.tar.gz: 6a1124febf6502f5a54693617da98eb869a0c181ae90aa678ec670937b26879d
+SHA512:
+  metadata.gz: 99fd8ede92eea52aed8a2308f6e05487219769c06a92104e7fe43fdbb96ea33aa833b598bbe5305a6741758657a7c0b16cfe01c7d96a38727c4166a83ec3fc78
+  data.tar.gz: 5f800186643b9638f32cdee823b64694fd0b4a60041af701e178d9c68967c63849726b0c29758899a483906c8a148103dda11495489d5219b9ae2949dff8e59d

data/.gitignore

@@ -0,0 +1,2 @@
+ned-*.gem
+.idea

data/Gemfile

@@ -0,0 +1,9 @@
+# frozen_string_literal: true
+
+source 'https://rubygems.org'
+
+gemspec
+
+group :test do
+  gem 'rspec'
+end

data/Gemfile.lock

@@ -0,0 +1,32 @@
+PATH
+  remote: .
+  specs:
+    ned (0.0.1)
+
+GEM
+  remote: https://rubygems.org/
+  specs:
+    diff-lcs (1.5.0)
+    rspec (3.11.0)
+      rspec-core (~> 3.11.0)
+      rspec-expectations (~> 3.11.0)
+      rspec-mocks (~> 3.11.0)
+    rspec-core (3.11.0)
+      rspec-support (~> 3.11.0)
+    rspec-expectations (3.11.0)
+      diff-lcs (>= 1.2.0, < 2.0)
+      rspec-support (~> 3.11.0)
+    rspec-mocks (3.11.1)
+      diff-lcs (>= 1.2.0, < 2.0)
+      rspec-support (~> 3.11.0)
+    rspec-support (3.11.0)
+
+PLATFORMS
+  x86_64-darwin-20
+
+DEPENDENCIES
+  ned!
+  rspec
+
+BUNDLED WITH
+   2.3.3

data/README.md

@@ -0,0 +1,24 @@
+# Ned
+
+```
+A stream editor.
+
+Usage: ned [file] [options ...]
+
+Options:
+        --help                         Print this message.
+        --version                      Print version.
+    -a, --append string                Append the specified string to each line.
+    -b, --backward                     Invert all input lines.
+    -g, --grep pattern                 Search using the specified pattern.
+    -h, --head [num]                   Print the first n lines. Defaults to 10.
+    -i, --index start[..end]           Print only the specified lines. Use -1 etc to index from end.
+    -j, --join [string]                Join input lines, optionally with the specified string.
+    -o, --only pattern                 Search using the specified pattern. Only print matching part of line.
+    -p, --prepend string               Prepend the specified string to each line.
+    -q, --quote [string]               Quote each line, optionally with the specified string.
+    -r, --replace pattern replacement  Regex replace.
+    -s, --sort ["num"|"alpha"]         Sort. Defaults to alphabetical.
+    -t, --tail [num]                   Print the last n lines. Defaults to 10.
+    -u, --uniq                         Unique.
+```

data/bin/ned

@@ -0,0 +1,7 @@
+#!/usr/bin/env ruby
+
+$LOAD_PATH.unshift "#{__dir__}/../lib"
+
+require 'ned'
+
+exit Ned.run

data/lib/ned/command.rb

@@ -0,0 +1,18 @@
+module Ned
+  class Command
+    attr_reader :config, :params
+
+    def initialize(config, params)
+      @config = config
+      @params = params
+    end
+
+    def all?
+      config.all?(params)
+    end
+
+    def execute(context)
+      config.execute(context, *params)
+    end
+  end
+end

data/lib/ned/commands/append.rb

@@ -0,0 +1,15 @@
+# frozen_string_literal: true
+
+Ned::Config.add(
+  name:        'append',
+  description: 'Append the specified string to each line.',
+  short:       '-a',
+  long:        '--append',
+  params:      'string',
+  validator:   Ned::Validators.num(1),
+  execute:     lambda do |context, string|
+    context.lines = context.lines.flat_map do |line|
+      "#{line}#{string}".split("\n")
+    end
+  end
+)

data/lib/ned/commands/backward.rb

@@ -0,0 +1,14 @@
+# frozen_string_literal: true
+
+Ned::Config.add(
+  name:        'backward',
+  description: 'Invert all input lines.',
+  short:       '-b',
+  long:        '--backward',
+  params:      nil,
+  validator:   Ned::Validators.none(),
+  execute:     lambda do |context|
+    context.lines.reverse!
+  end,
+  all:         true
+)

data/lib/ned/commands/grep.rb

@@ -0,0 +1,16 @@
+# frozen_string_literal: true
+
+Ned::Config.add(
+  name:        'grep',
+  description: 'Search using the specified pattern.',
+  short:       '-g',
+  long:        '--grep',
+  params:      'pattern',
+  validator:   Ned::Validators.num(1),
+  execute:     lambda do |context, pattern|
+    regexp = Regexp.new(pattern)
+    context.lines = context.lines.flat_map do |line|
+      line.match(pattern) ? [line] : []
+    end
+  end
+)

data/lib/ned/commands/head.rb

@@ -0,0 +1,21 @@
+# frozen_string_literal: true
+
+Ned::Config.add(
+  name:        'head',
+  description: 'Print the first n lines. Defaults to 10.',
+  short:       '-h',
+  long:        '--head',
+  params:      '[num]',
+  validator:   Ned::Validators.num(0, 1) do |num|
+    if num
+      Integer(num) rescue nil
+    else
+      []
+    end
+  end,
+  execute:     lambda do |context, num=10|
+    context.lines = context.lines.flat_map do |line|
+      context.start_index < num ? [line] : []
+    end
+  end
+)

data/lib/ned/commands/index.rb

@@ -0,0 +1,27 @@
+# frozen_string_literal: true
+
+Ned::Config.add(
+  name:        'index',
+  description: 'Print only the specified lines. Use -1 etc to index from end.',
+  short:       '-i',
+  long:        '--index',
+  params:      'start[..end]',
+  validator: Ned::Validators.num(1) do |param|
+    if param.index('..')
+      parts = param.split('..')
+      next unless parts.size == 2
+
+      [Integer(parts[0]), Integer(parts[1])] rescue nil
+    else
+      Integer(param) rescue nil
+    end
+  end,
+  execute: lambda do |context, start, ending = nil|
+    context.lines = (ending.nil? ? context.lines[start..start] : context.lines[start..ending]) || []
+  end,
+  all: lambda do |start, ending = nil|
+    true
+    # todo
+    #start < 0 || (!ending.nil? && ending < 0)
+  end
+)

data/lib/ned/commands/join.rb

@@ -0,0 +1,14 @@
+# frozen_string_literal: true
+
+Ned::Config.add(
+  name:        'join',
+  description: 'Join input lines, optionally with the specified string.',
+  short:       '-j',
+  long:        '--join',
+  params:      '[string]',
+  validator:   Ned::Validators.num(0, 1),
+  execute:     lambda do |context, string=''|
+    context.lines = context.lines.join(string).split("\n")
+  end,
+  all:         true
+)

data/lib/ned/commands/only.rb

@@ -0,0 +1,17 @@
+# frozen_string_literal: true
+
+Ned::Config.add(
+  name:        'only',
+  description: 'Search using the specified pattern. Only print matching part of line.',
+  short:       '-o',
+  long:        '--only',
+  params:      'pattern',
+  validator:   Ned::Validators.num(1),
+  execute:     lambda do |context, pattern|
+    regexp = Regexp.new(pattern)
+    context.lines = context.lines.flat_map do |line|
+      match = line.match(pattern)
+      match ? [match[0]] : []
+    end
+  end
+)

data/lib/ned/commands/prepend.rb

@@ -0,0 +1,15 @@
+# frozen_string_literal: true
+
+Ned::Config.add(
+  name:        'prepend',
+  description: 'Prepend the specified string to each line.',
+  short:       '-p',
+  long:        '--prepend',
+  params:      'string',
+  validator:   Ned::Validators.num(1),
+  execute:     lambda do |context, string|
+    context.lines = context.lines.flat_map do |line|
+      "#{string}#{line}".split("\n")
+    end
+  end
+)

data/lib/ned/commands/quote.rb

@@ -0,0 +1,15 @@
+# frozen_string_literal: true
+
+Ned::Config.add(
+  name:        'quote',
+  description: 'Quote each line, optionally with the specified string.',
+  short:       '-q',
+  long:        '--quote',
+  params:      '[string]',
+  validator:   Ned::Validators.num(0, 1),
+  execute:     lambda do |context, char='"'|
+    context.lines = context.lines.flat_map do |line|
+      "#{char}#{line}#{char}".split("\n")
+    end
+  end
+)

data/lib/ned/commands/replace.rb

@@ -0,0 +1,15 @@
+# frozen_string_literal: true
+
+Ned::Config.add(
+  name:        'replace',
+  description: 'Regex replace.',
+  short:       '-r',
+  long:        '--replace',
+  params:      'pattern replacement',
+  validator:   Ned::Validators.num(2),
+  execute:     lambda do |context, pattern, string|
+    context.lines = context.lines.flat_map do |line|
+      line.gsub(Regexp.new(pattern), string).split("\n")
+    end
+  end
+)

data/lib/ned/commands/sort.rb

@@ -0,0 +1,38 @@
+# frozen_string_literal: true
+
+module Ned
+  module Sort
+    DIGIT_MATCH = /^ *((?:0|-?[1-9][0-9]*)(?:[.][0-9]+)?)(.*)/
+  end
+end
+
+Ned::Config.add(
+  name:        'sort',
+  description: 'Sort. Defaults to alphabetical.',
+  short:       '-s',
+  long:        '--sort',
+  params:      '["num"|"alpha"]',
+  validator:   Ned::Validators.num(0, 1) do |type|
+    if type
+      ['num', 'alpha'].include?(type) ? [type] : nil
+    else
+      []
+    end
+  end,
+  execute:     lambda do |context, type='alpha'|
+    if type == 'alpha'
+      context.lines.sort!
+    else
+      sortable = context.lines.map do |line|
+        match = line.match(Ned::Sort::DIGIT_MATCH)
+        if match
+          [0, Float(match[1]), match[2], line]
+        else
+          [1, nil, nil, line]
+        end
+      end
+      context.lines = sortable.sort.map { |v| v[3] }
+    end
+  end,
+  all: true
+)

data/lib/ned/commands/tail.rb

@@ -0,0 +1,22 @@
+# frozen_string_literal: true
+
+Ned::Config.add(
+  name:        'tail',
+  description: 'Print the last n lines. Defaults to 10.',
+  short:       '-t',
+  long:        '--tail',
+  params:      '[num]',
+  validator:   Ned::Validators.num(0, 1) do |num|
+    if num
+      Integer(num) rescue nil
+    else
+      []
+    end
+  end,
+  execute:     lambda do |context, num=10|
+    if num < context.lines.length
+      context.lines = context.lines[-num..-1] 
+    end
+  end,
+  all:         true
+)

data/lib/ned/commands/uniq.rb

@@ -0,0 +1,20 @@
+# frozen_string_literal: true
+
+Ned::Config.add(
+  name:        'uniq',
+  description: 'Unique.',
+  short:       '-u',
+  long:        '--uniq',
+  params:      nil,
+  validator:   Ned::Validators.none,
+  execute:     lambda do |context|
+    context.lines = context.lines.each_with_index.flat_map do |line, index|
+      if index == 0 || context.lines[index - 1] != line
+        [line]
+      else
+        []
+      end
+    end
+  end,
+  all:         true
+)

data/lib/ned/commands/visual.rb

@@ -0,0 +1,22 @@
+# frozen_string_literal: true
+
+Ned::Config.add(
+  name:        'visual',
+  short:       '-v',
+  long:        '--visual',
+  params:      'start[..end]',
+  description: 'Select a range to apply commands to. Use -1 etc to index from end.',
+  validator:   Ned::Validators.num(1) do |param|
+    if param.index('..')
+      parts = param.split('..')
+      next unless parts.size == 2
+
+      [Integer(parts[0]), Integer(parts[1])] rescue nil
+    else
+      Integer(param) rescue nil
+    end
+  end,
+  execute:     lambda do |context, start, ending = nil|
+  end,
+  hidden:      true
+)

data/lib/ned/config.rb

@@ -0,0 +1,73 @@
+# frozen_string_literal: true
+
+module Ned
+  class Config
+    class << self
+      attr_reader :all
+    end
+
+    @all = []
+
+    def self.add(name:, description:, short:, long:, params:, validator:, execute:, all: nil, hidden: false)
+      @all.each do |config|
+        if config.short.start_with?(short) || short.start_with?(config.short)
+          raise "Cannot add command #{name}. Flag conflicts with #{config.name}."
+        end
+
+        if config.long.start_with?(long) || long.start_with?(config.long)
+          raise "Cannot add command #{name}. Flag conflicts with #{config.name}."
+        end
+      end
+
+      @all << Config.new(
+        name: name,
+        description: description,
+        short: short,
+        long: long,
+        params: params,
+        validator: validator, 
+        execute: execute,
+        all: all,
+        hidden: hidden
+      )
+    end
+
+    attr_reader :name, :description, :short, :long, :params
+
+    def initialize(name:, description:, short:, long:, params:, validator:, execute:, all: nil, hidden: false)
+      @name = name
+      @description = description
+      @short = short
+      @long = long
+      @params = params
+      @validator = validator
+      @execute = execute
+      @hidden = hidden
+
+      all = all || false
+      if [true, false].include? all
+        @all = lambda { |*params| all }
+      elsif all.is_a? Proc
+        @all = all
+      else
+        raise "Invalid all type for #{name}: #{all.class}"
+      end
+    end
+
+    def validate(*args)
+      @validator.call(*args)
+    end
+
+    def all?(params)
+      @all.call(*params)
+    end
+
+    def hidden?
+      @hidden
+    end
+
+    def execute(*args)
+      @execute.call(*args)
+    end
+  end
+end

data/lib/ned/context.rb

@@ -0,0 +1,10 @@
+module Ned
+  class Context
+    attr_accessor :lines, :start_index
+
+    def initialize(lines, start_index)
+      @lines = lines
+      @start_index = start_index
+    end
+  end
+end

data/lib/ned/strings.rb

@@ -0,0 +1,29 @@
+# frozen_string_literal: true
+
+module Ned
+  class Strings
+    SEQUENCES = {
+      'n' => "\n",
+      't' => "\t",
+      '\\' => '\\'
+    }
+
+    def self.unescape!(string)
+      i = 0
+      while i < string.size - 1
+        if string[i] == '\\'
+          raise 'eof' if i == (string.size - 1)
+          c = string[i + 1]
+          r = SEQUENCES[c]
+          if r
+            string[i] = r
+            string[i + 1] = ''
+          end
+        end
+        i = i + 1
+      end
+
+      string
+    end
+  end
+end

data/lib/ned/validators.rb

@@ -0,0 +1,19 @@
+# frozen_string_literal: true
+
+module Ned
+  class Validators
+    def self.none
+      lambda { |*params| params.length == 0 ? [] : nil }
+    end
+
+    def self.num(min, max = nil, &block)
+      lambda do |*params| 
+        max = min unless max
+
+        return nil if params.length < min || params.length > max
+
+        block.nil? ? params : yield(*params)
+      end
+    end
+  end
+end

data/lib/ned/version.rb

@@ -0,0 +1,5 @@
+# frozen_string_literal: true
+
+module Ned
+  VERSION = "0.0.1"
+end

data/lib/ned.rb

@@ -0,0 +1,193 @@
+# frozen_string_literal: true
+
+require 'ned/command'
+require 'ned/config'
+require 'ned/context'
+require 'ned/strings'
+require 'ned/validators'
+require 'ned/version'
+
+Dir["#{__dir__}/ned/commands/**/*.rb"].sort.each { |f| require f }
+
+module Ned
+  def self.help(error_output)
+    error_output.puts <<~EOF
+      A stream editor.
+
+      Usage: ned [file] [options ...]
+
+      Options:
+    EOF
+
+    lines = [
+      ['    --help',    'Print this message.'],
+      ['    --version', 'Print version.']
+    ]
+    max = lines[0][0].length
+    Ned::Config.all.each do |config|
+      next if config.hidden?
+
+      line = "#{config.short}, #{config.long} #{config.params}"
+      lines << [line, config.description]
+      max = [max, line.length].max
+    end
+
+    lines.each do |line|
+      error_output.puts "    #{line[0].ljust(max)}  #{line[1]}"
+    end
+  end
+
+  def self.failure(error_output, message)
+    error_output.puts "fatal: #{message}\n\n"
+    help(error_output)
+  end
+
+  def self.run(input: $stdin, output: $stdout, error_output: $stderr, args: ARGV)
+    args = args.map do |arg|
+      Ned::Strings.unescape!(arg.dup)
+    end
+
+    if args.include?('--help')
+      help(error_output)
+      return 0
+    end
+
+    if args.include?('--version')
+      output.puts("Ned version #{Ned::VERSION}")
+      return 0
+    end
+
+    inputs = []
+    while args.first && !args.first.match(/^-./)
+      arg = args.shift
+
+      if arg == '-'
+        inputs << input
+      else
+        unless File.exist?(arg)
+          failure(error_output, "no such file: #{arg}")
+          return 1
+        end
+        inputs << arg
+      end
+    end
+
+    if input.tty? && (inputs.empty? || (inputs.size == 1 && inputs[0] == input))
+      failure(error_output, 'no input')
+      return 1
+    end
+
+    inputs = inputs.unshift(input) if !input.tty? && !inputs.index(input)
+
+    if inputs.count(input) > 1
+      failure(error_output, "can't read from standard in twice, silly")
+      return 1
+    end
+
+    if inputs.size > 1
+      failure(error_output, "more than one input not yet supported")
+      return 1
+    end
+
+    commands = []
+
+    while arg = args.shift
+      config = Ned::Config.all.find do |config|
+        arg.start_with?(config.short) || arg == config.long || arg.start_with?("#{config.long}=")
+      end
+
+      unless config
+        failure(error_output, "invalid option: #{arg}")
+        return 1
+      end
+
+      params = []
+
+      if arg.start_with?("#{config.long}=")
+        params << arg["#{config.long}=".size..-1]
+      elsif arg.start_with?(config.short) && arg != config.short
+        params << arg[config.short.size..-1]
+      else
+        while !args.empty? && !args.first.start_with?('-')
+          arg = args.shift
+          if arg.start_with? '\\-'
+            arg = arg[1..-1]
+          end
+          params << arg
+        end
+      end
+
+      valid = config.validate(*params)
+      if valid.nil?
+        if config.params.nil?
+          failure(error_output, "invalid param for #{config.name}. found: #{params}, expected none")
+          return 1
+        else
+          failure(error_output, "invalid param for #{config.name}. found: #{params}, expected: #{config.params}")
+          return 1
+        end
+      end
+
+      commands << Ned::Command.new(config, valid)
+    end
+
+    if commands.any?(&:all?)
+      lines = inputs.flat_map do |i|
+        if i.is_a? String
+          IO.readlines(i, sep="\n")
+        else
+          i.readlines(sep="\n")
+        end
+      end
+      process_all(commands, lines, output)
+    else
+      process_each(commands, inputs, output)
+    end
+
+    0
+  end
+
+  def self.process_all(commands, lines, output)
+    final_newline = lines[-1]&.[](-1) == "\n" ? "\n" : ''
+
+    lines = lines.map { |line| line.chomp("\n") }
+    context = Context.new(lines, 0)
+    commands.each do |command|
+      command.execute(context)
+    end
+    last = context.lines.length - 1
+    context.lines.each_with_index do |line, index|
+      output.print "#{line}#{index == last ? final_newline : "\n"}"
+    end
+  end
+
+  def self.process_each(commands, inputs, output)
+    input = inputs[0]
+
+    if input.is_a? String
+      input = File.open(input)
+    end
+
+    current = input.gets(sep="\n")
+    next_line = input.gets(sep="\n")
+    index = 0
+
+    while current
+      final_newline = current[-1]&.[](-1) == "\n" ? "\n" : ''
+      context = Context.new([current.chomp("\n")], index)
+      commands.each do |command|
+        command.execute(context)
+      end
+      index = context.start_index + context.lines.size
+      last = context.lines.length - 1
+      context.lines.each_with_index do |line, index|
+        output.print "#{line}#{index == last && next_line.nil? ? final_newline : "\n"}"
+      end
+
+      current = next_line
+      next_line = input.gets(sep="\n")
+    end
+
+    input.close
+  end
+end

data/ned.gemspec

@@ -0,0 +1,26 @@
+# frozen_string_literal: true
+
+require_relative "lib/ned/version"
+
+Gem::Specification.new do |spec|
+  spec.name          = "ned"
+  spec.version       = Ned::VERSION
+  spec.authors       = ["Nick Dower"]
+  spec.email         = ["nicholasdower@gmail.com"]
+
+  spec.summary       = "A command line editor."
+  spec.description   = "A command line editor"
+  spec.homepage      = "https://github.com/nicholasdower/ned"
+  spec.license       = "MIT"
+
+  spec.metadata["homepage_uri"] = spec.homepage
+  spec.metadata["source_code_uri"] = "https://github.com/nicholasdower/ned"
+  spec.metadata["changelog_uri"] = "https://github.com/nicholasdower/ned/releases"
+
+  spec.files = Dir.chdir(File.expand_path(__dir__)) do
+    `git ls-files -z`.split("\x0").reject { |f| f.match(%r{\A(?:test|spec|features)/}) }
+  end
+  spec.bindir        = 'bin'
+  spec.executables   << 'ned'
+  spec.require_paths = ["lib"]
+end

data/scripts/generate_readme

@@ -0,0 +1,8 @@
+#!/usr/bin/env ruby
+
+puts <<~EOF
+# Ned
+
+```
+#{`bundle exec ned --help 2>&1`}```
+EOF

data/scripts/release

@@ -0,0 +1,31 @@
+#!/bin/bash
+
+set -e
+
+if [ $# -ne 1 ]; then
+  echo "usage: $0 <version>" >&2
+  exit 1
+fi
+
+if [ -n "$(git status --porcelain)" ]; then
+  echo "error: stage or commit your changes." >&2
+  exit 1;
+fi
+
+NEW_VERSION=$1
+CURRENT_VERSION=$(grep VERSION lib/ned/version.rb | cut -d'"' -f 2)
+
+./scripts/test
+
+echo "Updating from v$CURRENT_VERSION to v$NEW_VERSION. Press enter to continue."
+read
+
+sed -E -i '' "s/VERSION = \"[^\"]+\"/VERSION = \"$NEW_VERSION\"/g" lib/ned/version.rb
+
+./scripts/generate_readme > README.md
+
+gem build
+gem push ned-$NEW_VERSION.gem
+bundle install
+git commit -a -m "v$NEW_VERSION Release"
+open "https://github.com/nicholasdower/ned/releases/new?title=v$NEW_VERSION%20Release&tag=v$NEW_VERSION&target=$(git rev-parse HEAD)"

data/scripts/test

@@ -0,0 +1,3 @@
+#!/bin/bash
+
+bundle exec rspec

data/todo

@@ -0,0 +1,15 @@
+add support for a ~/.ned/ dir
+implement highlight
+add color
+add support for more escape sequences, see https://github.com/ruby/ruby/blob/master/doc/syntax/literals.rdoc#label-Strings
+add support for operating on one or more files
+add support for editing files in place
+handle --
+add ljust
+maybe add ability to highlight columns, not just full lines
+write readme
+add support for to_set
+add support for overriding existing commands
+add support for ommitting short or long flags
+add support for uniq with count?
+consider giving commands a way to operate on entire line with newline. currently can't replicate tr.

metadata

@@ -0,0 +1,78 @@
+--- !ruby/object:Gem::Specification
+name: ned
+version: !ruby/object:Gem::Version
+  version: 0.0.1
+platform: ruby
+authors:
+- Nick Dower
+autorequire:
+bindir: bin
+cert_chain: []
+date: 2022-05-29 00:00:00.000000000 Z
+dependencies: []
+description: A command line editor
+email:
+- nicholasdower@gmail.com
+executables:
+- ned
+extensions: []
+extra_rdoc_files: []
+files:
+- ".gitignore"
+- Gemfile
+- Gemfile.lock
+- README.md
+- bin/ned
+- lib/ned.rb
+- lib/ned/command.rb
+- lib/ned/commands/append.rb
+- lib/ned/commands/backward.rb
+- lib/ned/commands/grep.rb
+- lib/ned/commands/head.rb
+- lib/ned/commands/index.rb
+- lib/ned/commands/join.rb
+- lib/ned/commands/only.rb
+- lib/ned/commands/prepend.rb
+- lib/ned/commands/quote.rb
+- lib/ned/commands/replace.rb
+- lib/ned/commands/sort.rb
+- lib/ned/commands/tail.rb
+- lib/ned/commands/uniq.rb
+- lib/ned/commands/visual.rb
+- lib/ned/config.rb
+- lib/ned/context.rb
+- lib/ned/strings.rb
+- lib/ned/validators.rb
+- lib/ned/version.rb
+- ned.gemspec
+- scripts/generate_readme
+- scripts/release
+- scripts/test
+- todo
+homepage: https://github.com/nicholasdower/ned
+licenses:
+- MIT
+metadata:
+  homepage_uri: https://github.com/nicholasdower/ned
+  source_code_uri: https://github.com/nicholasdower/ned
+  changelog_uri: https://github.com/nicholasdower/ned/releases
+post_install_message:
+rdoc_options: []
+require_paths:
+- lib
+required_ruby_version: !ruby/object:Gem::Requirement
+  requirements:
+  - - ">="
+    - !ruby/object:Gem::Version
+      version: '0'
+required_rubygems_version: !ruby/object:Gem::Requirement
+  requirements:
+  - - ">="
+    - !ruby/object:Gem::Version
+      version: '0'
+requirements: []
+rubygems_version: 3.3.3
+signing_key:
+specification_version: 4
+summary: A command line editor.
+test_files: []