ned 0.0.1 → 0.0.2

data/lib/ned/commands/read.rb

@@ -0,0 +1,40 @@
+module Ned
+  class Read < Ned::Command
+    def initialize(inputs)
+      @inputs = inputs
+    end
+
+    def execute
+      line = @next || next_line
+      @next = next_line
+      line.ensure_trailing_newline if @next
+      line.nil? ? nil : line
+    end
+
+    def next_line
+      @current ||= @inputs.shift
+      return unless @current
+
+      line = @current.gets("\n")
+      return line if line
+
+      @current.close
+      @current = nil
+
+      next_line
+    end
+
+    def execute_all
+      lines = []
+      current = @inputs.shift
+      while current
+        lines.concat(current.readlines)
+        current.close
+        current = @inputs.shift
+        lines[-1].ensure_trailing_newline if !current.nil? && lines[-1]
+      end
+
+      lines
+    end
+  end
+end

data/lib/ned/commands/sort.rb

@@ -1,38 +1,52 @@
-# frozen_string_literal: true
-
 module Ned
-  module Sort
+  class Sort < Ned::AllCommand
     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
-      []
+    long_name   'sort'
+    short_name  's'
+
+    option_parser do |opts|
+      opts.banner = <<~EOF
+        Sort input lines.
+
+        Usage: ned sort [--numeric]
+
+        Options:
+      EOF
+
+      opts.on('-n', '--numeric', 'Sort numerically.') do |numeric|
+        raise OptionParser::ParseError.new('duplicate flag') if options[:numeric]
+
+        numeric
+      end
+
+      opts.on('-r', '--reverse', 'Reverse the sort order.') do |reverse|
+        raise OptionParser::ParseError.new('duplicate flag') if options[:reverse]
+
+        reverse
+      end
     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]
+
+    def execute_internal(lines)
+      ensure_trailing_newline
+      if options.fetch(:numeric, false)
+        sortable = lines.map do |line|
+          match = line.match(DIGIT_MATCH)
+          if match
+            [0, Float(match[1]), match[2], line]
+          else
+            [1, nil, nil, line]
+          end
         end
+        lines = sortable.sort.map { |v| v[3] }
+      else
+        lines.sort!
       end
-      context.lines = sortable.sort.map { |v| v[3] }
+
+      lines.reverse! if options.fetch(:reverse, false)
+      lines
     end
-  end,
-  all: true
-)
+
+    Ned::CommandRegistry.add(Sort)
+  end
+end

data/lib/ned/commands/tail.rb

@@ -1,22 +1,31 @@
-# 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
-      []
+module Ned
+  class Tail < AllCommand
+    long_name   'tail'
+    short_name  't'
+
+    option_parser do |opts|
+      opts.banner = <<~EOF
+        Print only the last input lines.
+
+        Usage: ned tail [--num NUM]
+
+        Options:
+      EOF
+
+      opts.on('-n', '--num NUM', Integer, 'Number of input lines to print. Defaults to 10.') do |num|
+        raise OptionParser::ParseError.new('duplicate flag') if options[:num]
+
+        raise OptionParser::ParseError.new("invalid num: #{num}") if num < 0
+
+        num
+      end
     end
-  end,
-  execute:     lambda do |context, num=10|
-    if num < context.lines.length
-      context.lines = context.lines[-num..-1] 
+
+    def execute_internal(lines)
+      num = options.fetch(:num, 10)
+      num < lines.length ? lines[-num..-1] : lines
     end
-  end,
-  all:         true
-)
+
+    Ned::CommandRegistry.add(Tail)
+  end
+end

data/lib/ned/commands/uniq.rb

@@ -1,20 +1,55 @@
-# 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
-        []
+module Ned
+  class Uniq < Ned::AllCommand
+    long_name   'uniq'
+    short_name  'u'
+
+    option_parser do |opts|
+      opts.banner = <<~EOF
+        Filter out repeated input lines.
+
+        Usage: ned uniq [--count]
+
+        Options:
+      EOF
+
+      opts.on('-c', '--count', 'Precede each output line with the number of times the line occurred in the input, followed by a space.') do |count|
+        raise OptionParser::ParseError.new('duplicate flag') if options[:count]
+
+        count
       end
     end
-  end,
-  all:         true
-)
+
+    def execute_internal(lines)
+      ensure_trailing_newline
+
+      previous = nil
+      count = 1
+      lines.each_with_index.flat_map do |line, i|
+        result = []
+        if previous && line != previous
+          if options.fetch(:count, false)
+            previous.insert(0, "#{count} ")
+            result << previous
+          else
+            result << previous
+          end
+          count = 1
+        elsif previous
+          count += 1
+        end
+        previous = line
+        if i == lines.length - 1
+          if options.fetch(:count, false)
+            line.insert(0, "#{count} ")
+            result << line
+          else
+            result << line
+          end
+        end
+        result
+      end
+    end
+
+    Ned::CommandRegistry.add(Uniq)
+  end
+end

data/lib/ned/string.rb

@@ -0,0 +1,14 @@
+class String
+  def ensure_trailing_newline
+    self << "\n" unless self[-1] == "\n"
+  end
+
+  def insert_before_newline(string)
+    if self[-1] == "\n"
+      self.insert(-2, string)
+    else
+      self.insert(-1, string)
+    end
+  end
+end
+

data/lib/ned/strings.rb

@@ -23,7 +23,7 @@ module Ned
         i = i + 1
       end
 
-      string
+      nil
     end
   end
 end

data/lib/ned/version.rb

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

data/lib/ned.rb

@@ -1,193 +1,236 @@
-# frozen_string_literal: true
+require 'optparse'
 
 require 'ned/command'
-require 'ned/config'
-require 'ned/context'
+require 'ned/command_registry'
+require 'ned/string'
 require 'ned/strings'
-require 'ned/validators'
 require 'ned/version'
 
 Dir["#{__dir__}/ned/commands/**/*.rb"].sort.each { |f| require f }
 
+# todo
+#  - uniq shouldn't be an all command
+#  - split into files
+#  - commands shouldn't have to implement execute_all, put this in the base or use a wrapper or something
+#  - implement help
+#  - add --version
+#  - write tests
+#  - add tail
+#  - add head
+#  - add replace
+#  - add grep
+#  - add grep -o or only
+#  - add grep -v or except
+#  - add index
+#  - add join
+#  - add count or something like wc
+#  - implement inline editing
+#  - implement highlighting
+#  - implement append
+#  - add ability for a command to turn one line into many
+#  - add ability for a command to turn one line into zero
+#  - handle newlines in quote, replace, etc.
+#  - add numeric sort
+#  - add reverse sort
+#  - maybe add append and prepend
+#  - figure out how to distrute as gem without bundle
+#  - use OptionParser on main args.
+#  - uniq should not need to be an AllCommand. Add ability to check whether there are more lines.
+#  - 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 editing files in place
+#  - add ljust
+#  - maybe add ability to highlight columns, not just full lines
+#  - write readme
+#  - add support for to_set in uniq
+#  - add support for overriding existing commands
+#  - index shouldn't always be an all command. It should be based on the indices.
 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
+  class Main
+    def initialize
+      @options = { }
 
-    lines.each do |line|
-      error_output.puts "    #{line[0].ljust(max)}  #{line[1]}"
-    end
-  end
+      @option_parser = OptionParser.new do |opts|
+        opts.banner = <<~EOF
+          Ned, a stream editor.
 
-  def self.failure(error_output, message)
-    error_output.puts "fatal: #{message}\n\n"
-    help(error_output)
-  end
+          Usage: ned [[ned_arg ...] --] [[command] [: command ...]]
 
-  def self.run(input: $stdin, output: $stdout, error_output: $stderr, args: ARGV)
-    args = args.map do |arg|
-      Ned::Strings.unescape!(arg.dup)
-    end
+          OPTIONS
+        EOF
 
-    if args.include?('--help')
-      help(error_output)
-      return 0
-    end
+        opts.on('-i', '--inplace', 'Edit each file in place by processing each file independently.') do |inplace|
+          raise OptionParser::ParseError.new('duplicate flag') if @options[:inplace]
 
-    if args.include?('--version')
-      output.puts("Ned version #{Ned::VERSION}")
-      return 0
-    end
+          inplace
+        end
 
-    inputs = []
-    while args.first && !args.first.match(/^-./)
-      arg = args.shift
+        opts.on('-h', '--help [COMMAND]', 'Print this help.') do |help|
+          help || true
+        end
 
-      if arg == '-'
-        inputs << input
-      else
-        unless File.exist?(arg)
-          failure(error_output, "no such file: #{arg}")
-          return 1
+        opts.on('-v', '--version', 'Print Ned version.') do |version|
+          version
         end
-        inputs << arg
       end
     end
 
-    if input.tty? && (inputs.empty? || (inputs.size == 1 && inputs[0] == input))
-      failure(error_output, 'no input')
-      return 1
-    end
+    def help
+      help = @option_parser.help
 
-    inputs = inputs.unshift(input) if !input.tty? && !inputs.index(input)
+      help << "\nCOMMANDS\n"
 
-    if inputs.count(input) > 1
-      failure(error_output, "can't read from standard in twice, silly")
-      return 1
+      Ned::CommandRegistry.all.each do |command|
+        help << "\n#{command.long_name} (#{command.short_name})\n\n"
+        command.help.split("\n").each do |line|
+          help << "  #{line}\n"
+        end
+      end
+      help
     end
 
-    if inputs.size > 1
-      failure(error_output, "more than one input not yet supported")
-      return 1
-    end
+    def run(args, input, output, error)
+      args = args.map do |arg|
+        arg = arg.dup
+        Ned::Strings.unescape!(arg)
+        arg
+      end
 
-    commands = []
+      ned_args = []
+      command_args = []
+      has_stdin = !input.tty?
 
-    while arg = args.shift
-      config = Ned::Config.all.find do |config|
-        arg.start_with?(config.short) || arg == config.long || arg.start_with?("#{config.long}=")
+      if index = args.index('--')
+        ned_args.concat(args.shift(index))
+        args.shift
+      elsif args[0]&.start_with?('-')
+        ned_args = args
+        args = []
       end
 
-      unless config
-        failure(error_output, "invalid option: #{arg}")
+      command_args.concat(args.shift(args.size))
+
+      begin
+        @option_parser.parse!(ned_args, into: @options)
+      rescue OptionParser::ParseError  => e
+        error.puts "fatal: error while parsing options: #{e.message}"
         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]
+      if help_option = @options[:help]
+        if help_option.is_a? TrueClass
+          output.puts help
+          return 0
+        elsif help_option.is_a? String
+          command = Ned::CommandRegistry.find(help_option)
+          unless command
+            error.puts "fatal: \"#{help_option}\" is not a valid command"
+            return 1
           end
-          params << arg
+          output.puts command.help
+          return 0
         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
+      if @options[:version]
+        output.puts "Ned version #{Ned::VERSION}"
+        return 0
+      end
+
+      raise 'in-place not implemented' if @options[:inplace]
+
+      inputs = ned_args.map do |current|
+        if current == '-'
+          input
         else
-          failure(error_output, "invalid param for #{config.name}. found: #{params}, expected: #{config.params}")
-          return 1
+          unless File.exist? current
+            error.puts "fatal: file not found \"#{current}\""
+            return 1
+          end
+          File.new(current)
         end
       end
 
-      commands << Ned::Command.new(config, valid)
-    end
+      inputs << input if inputs.empty?
+      inputs.unshift input if !inputs.index(input) && has_stdin
 
-    if commands.any?(&:all?)
-      lines = inputs.flat_map do |i|
-        if i.is_a? String
-          IO.readlines(i, sep="\n")
+      command_args = command_args.inject([[]]) do |array, arg|
+        if arg == ':'
+          array << []
         else
-          i.readlines(sep="\n")
+          array[-1] << arg
         end
+        array
       end
-      process_all(commands, lines, output)
-    else
-      process_each(commands, inputs, output)
-    end
 
-    0
-  end
+      if command_args.size == 1 && command_args[0] == []
+        command_args.clear
+      end
 
-  def self.process_all(commands, lines, output)
-    final_newline = lines[-1]&.[](-1) == "\n" ? "\n" : ''
+      if command_args.index([])
+        error.puts 'fatal: empty command found'
+        return 1
+      end
 
-    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
+      command_args.each do |array|
+        array.each_with_index do |arg, i|
+          array[i] = arg[1..-1] if arg == '\:'
+        end
+      end
 
-  def self.process_each(commands, inputs, output)
-    input = inputs[0]
+      command_args.each do |args|
+        unless Ned::CommandRegistry.find(args[0])
+          error.puts "fatal: \"#{args[0]}\" is not a valid command"
+          return 1
+        end
+      end
 
-    if input.is_a? String
-      input = File.open(input)
-    end
+      if inputs.count(input) > 1
+        error.puts 'fatal: can\'t read from stdin more than once'
+        return 1
+      end
 
-    current = input.gets(sep="\n")
-    next_line = input.gets(sep="\n")
-    index = 0
+      if inputs.index(input) && @in_place
+        error.puts "fatal: option -i specified with stdin"
+        return 1
+      end
+
+      previous = Ned::Read.new(inputs)
+      command_args.each do |args|
+        command = Ned::CommandRegistry.find(args.shift).new(previous)
+        begin
+          command.parse(args)
+          raise OptionParser::ParseError.new("invalid arguments: #{args}") unless args.empty?
+        rescue OptionParser::ParseError  => e
+          error.puts "fatal: error while parsing options for #{command.class.long_name}: #{e.message}"
+          return 1
+        end
 
-    while current
-      final_newline = current[-1]&.[](-1) == "\n" ? "\n" : ''
-      context = Context.new([current.chomp("\n")], index)
-      commands.each do |command|
-        command.execute(context)
+        if command.options[:help]
+          output.puts command.class.help
+          return 0
+        end
+
+        if command.options[:version]
+          output.puts "Ned version #{Ned::VERSION}"
+          return 0
+        end
+
+        previous = command
       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"}"
+
+      if inputs.index(input) && !has_stdin
+        error.puts 'fatal: can\'t read from stdin'
+        return 1
       end
 
-      current = next_line
-      next_line = input.gets(sep="\n")
-    end
+      print = Ned::Print.new(previous, output)
+
+      while line = print.execute; end
 
-    input.close
+      0
+    end
   end
 end