ru2 2.1.4

data/lib/ru/array.rb

@@ -0,0 +1,88 @@
+module Ru
+  class Array
+    def initialize(array)
+      @data = array.to_a
+    end
+
+    def each_line
+      Ru::Iterator.new(self)
+    end
+
+    def files
+      @data.map! do |line|
+        Ru::File.new(line)
+      end
+      self
+    end
+
+    def format(format='l')
+      @data.map! do |item|
+        item.format(format)
+      end
+      self
+    end
+
+    def grep(pattern)
+      if pattern.kind_of?(String)
+        pattern = Regexp.new(pattern)
+      end
+      select! do |item|
+        item.to_s =~ pattern
+      end
+      self
+    end
+
+    def map(method=nil, *args, &block)
+      if method.nil? && !block_given?
+        to_a.map
+      elsif method.nil?
+        array = to_a.map(&block)
+        self.class.new(array)
+      else
+        array = to_a.map { |item| item.send(method, *args) }
+        self.class.new(array)
+      end
+    end
+
+    def select(*args, &block)
+      delegate_to_array(:select, *args, &block)
+    end
+
+    def to_a
+      @data
+    end
+
+    def to_ary
+      to_a
+    end
+
+    def to_s
+      to_a.join("\n")
+    end
+
+    def to_self
+      self
+    end
+
+    def ==(other)
+      self.to_a == other.to_a
+    end
+
+    private
+
+    def method_missing(method, *args, &block)
+      delegate_to_array(method, *args, &block)
+    end
+
+    def delegate_to_array(method, *args, &block)
+      result = @data.send(method, *args, &block)
+      if result.kind_of? Enumerator::Lazy
+        Ru::Stream.new(result)
+      elsif result.kind_of? ::Array
+        self.class.new(result)
+      else
+        result
+      end
+    end
+  end
+end

data/lib/ru/file.rb

@@ -0,0 +1,94 @@
+require 'etc'
+
+module Ru
+  class File
+    def initialize(path)
+      @path = path
+    end
+
+    def basename
+      delegate_to_file(:basename)
+    end
+
+    def ctime
+      delegate_to_file(:ctime)
+    end
+
+    def extname
+      delegate_to_file(:extname)
+    end
+
+    def format(format='l')
+      separator = "\t"
+      case format
+      when 'l'
+        datetime = ctime.strftime(%w{%Y-%m-%d %H:%M}.join(separator))
+        return [omode, owner, group, size, datetime, name].join(separator)
+      else
+        raise 'format not supported'
+      end
+    end
+
+    def ftype
+      delegate_to_file(:ftype)
+    end
+
+    def gid
+      delegate_to_stat(:gid)
+    end
+
+    def group
+      Etc.getgrgid(gid).name
+    end
+
+    def mode
+      delegate_to_stat(:mode)
+    end
+
+    def mtime
+      delegate_to_file(:mtime)
+    end
+
+    def omode
+      '%o' % world_readable?
+    end
+
+    def owner
+      Etc.getpwuid(uid).name
+    end
+
+    def size
+      delegate_to_file(:size)
+    end
+
+    def to_s
+      name
+    end
+
+    def uid
+      delegate_to_stat(:uid)
+    end
+
+    def world_readable?
+      delegate_to_stat(:world_readable?)
+    end
+
+    def <=>(other)
+      name <=> other.name
+    end
+
+    alias_method :name, :basename
+    alias_method :created_at, :ctime
+    alias_method :updated_at, :mtime
+
+    private
+
+    def delegate_to_file(method)
+      ::File.send(method, @path)
+    end
+
+    def delegate_to_stat(method)
+      ::File.stat(@path).send(method)
+    end
+  end
+end

data/lib/ru/iterator.rb

@@ -0,0 +1,56 @@
+module Ru
+  class Iterator
+    class << self
+      def redefined_methods
+        @redefined_methods ||= begin
+          preserved_methods = %{initialize method_missing respond_to? to_a}
+          [].public_methods.select do |method|
+            method = method.to_s
+            method =~ /^[a-z]/ && !preserved_methods.include?(method)
+          end
+        end
+      end
+    end
+
+    def initialize(enum)
+      @enum = enum
+    end
+
+    def to_a
+      case @enum
+      when ::Array
+        Ru::Array.new(@enum)
+      when Ru::Array
+        @enum
+      when Ru::Stream
+        @enum.to_a
+      end
+    end
+
+    def to_stdout
+      case @enum
+      when ::Array
+        @enum.join("\n")
+      else
+        @enum.to_s
+      end
+    end
+
+    private
+
+    def method_missing(method, *args, &block)
+      map_method(method, *args, &block)
+    end
+
+    def map_method(method, *args, &block)
+      @enum = @enum.map { |item| item.send(method, *args, &block) }
+      self
+    end
+
+    redefined_methods.each do |method|
+      define_method(method) do |*args|
+        map_method(method, *args)
+      end
+    end
+  end
+end

data/lib/ru/option_printer.rb

@@ -0,0 +1,33 @@
+require 'erb'
+
+module Ru
+  class OptionPrinter
+    def exists?(option_key)
+      options[option_key].present?
+    end
+
+    def run(option_key, option_value=nil)
+      send(options[option_key], *option_value)
+    end
+
+    private
+
+    def options
+      {
+        help: :get_help,
+        version: :get_version
+      }
+    end
+
+    def get_help
+      namespace = OpenStruct.new(version: Ru::VERSION)
+      template_path = ::File.expand_path("../../../doc/help.erb", __FILE__)
+      template = ::File.open(template_path).read
+      ERB.new(template).result(namespace.instance_eval { binding })
+    end
+
+    def get_version
+      Ru::VERSION
+    end
+  end
+end

data/lib/ru/process.rb

@@ -0,0 +1,121 @@
+require 'optparse'
+
+module Ru
+  class Process
+
+    def initialize
+      @option_printer = OptionPrinter.new
+    end
+
+    def run
+      output = process_options
+      return output if output
+
+      args  = ARGV.dup
+      @code = args.shift
+
+      if @code.blank?
+        $stderr.puts @option_printer.run(:help)
+        return
+      end
+
+      @stdin = get_stdin(args, @options[:stream]) unless @code.start_with?('! ')
+      @code  = prepare_code(@code)
+
+      context =
+        if @stdin.nil?
+          Ru::Array.new([])
+        else
+          if @options[:stream]
+            if @options[:binary]
+              Ru::Stream.new(@stdin.each_byte.lazy)
+            else
+              Ru::Stream.new(@stdin.each_line.lazy.map { |line| line.chomp("\n".freeze) })
+            end
+          else
+            if @options[:binary]
+              Ru::Array.new(@stdin.bytes)
+            else
+              # Prevent 'invalid byte sequence in UTF-8'
+              @stdin.encode!('UTF-8', 'UTF-8', invalid: :replace)
+              Ru::Array.new(@stdin.split("\n"))
+            end
+          end
+        end
+      output  = context.instance_eval(@code) || @stdin
+
+      prepare_output(output)
+    end
+
+    private
+
+    def prepare_code(code)
+      if code.kind_of?(String)
+        if code.start_with?('[')
+          code = 'to_self' + code
+        elsif code.start_with?('! ')
+          code = code[2..-1]
+        end
+      end
+      code
+    end
+
+    def prepare_output(output)
+      if output.respond_to?(:to_stdout)
+        output = output.to_stdout
+      end
+      if output.kind_of?(::Array)
+        output = output.join("\n")
+      end
+      output.to_s
+    end
+
+    def process_options
+      @options = get_options
+      @options.each do |option, value|
+        if @option_printer.exists?(option)
+          return @option_printer.run(option)
+        end
+      end
+      nil
+    end
+
+    def get_options
+      options = {}
+      OptionParser.new do |opts|
+        opts.on("-h", "--help", "Print help") do
+          options[:help] = true
+        end
+
+        opts.on("-v", "--version", "Print version") do
+          options[:version] = true
+        end
+
+        opts.on('-s', '--stream', 'Stream mode') do
+          options[:stream] = true
+        end
+
+        opts.on('-b', '--binary', 'Binary mode') do
+          options[:binary] = true
+        end
+      end.parse!
+      options
+    end
+
+    def get_stdin(paths, stream)
+      if paths.present?
+        if stream
+          ::File.open(paths[0])
+        else
+          paths.map { |path| ::File.read(path) }.join("\n")
+        end
+      else
+        if stream
+          $stdin
+        else
+          $stdin.read
+        end
+      end
+    end
+  end
+end

data/lib/ru/stream.rb

@@ -0,0 +1,126 @@
+class Enumerator::Lazy
+  def [](number_or_range, length=1)
+    if number_or_range.kind_of? Range
+      range = number_or_range
+      if range.begin < 0 || range.end < -1 || (range.exclude_end? && range.end == -1)
+        raise ArgumentError, "Stream doesn't support negative indexes, except x..-1"
+      end
+      if range.end == -1
+        drop(range.begin)
+      else
+        each_with_index.select { |_, index|
+          range.cover?(index)
+        }
+      end
+    else
+      number = number_or_range
+      if number >= 0
+        result = drop(number)
+        if length >= 0
+          result.take(length)
+        else
+          nil
+        end
+      else
+        raise ArgumentError, "Stream doesn't support negative indexes"
+      end
+    end
+  end
+
+  def length
+    count
+  end
+
+  def uniq
+    seen = Set.new
+    select { |item|
+      seen.add?(item)
+    }
+  end
+end
+
+module Ru
+  class Stream
+
+    attr :stream
+
+    # @param [Enumerator::Lazy] stream
+    def initialize(stream)
+      raise ArgumentError unless stream.kind_of? Enumerator::Lazy
+      @stream = stream
+    end
+
+    def each_line
+      Ru::Iterator.new(self)
+    end
+
+    def files
+      self.class.new @stream.map { |line| Ru::File.new(line) }
+    end
+
+    def format(format='l')
+      self.class.new @stream.map { |item| item.format(format) }
+    end
+
+    def grep(pattern)
+      if pattern.kind_of? String
+        pattern = Regexp.new(pattern)
+      end
+      self.class.new @stream.select { |item| item.to_s =~ pattern }
+    end
+
+    def map(method=nil, *args, &block)
+      if method.nil? && !block_given?
+        each_line
+      elsif method.nil?
+        self.class.new @stream.map(&block)
+      else
+        self.class.new @stream.map { |item| item.send(method, *args) }
+      end
+    end
+
+    def select(*args, &block)
+      self.class.new @stream.select(*args, &block)
+    end
+
+    def to_a
+      Ru::Array.new(@stream.to_a)
+    end
+
+    alias_method :to_ary, :to_a
+
+    def to_s
+      result = ''
+      result.concat @stream.next.to_s
+      loop do
+        item = @stream.next.to_s
+        result.concat "\n".freeze
+        result.concat item
+      end
+      result
+    rescue StopIteration
+      result
+    end
+
+    def to_self
+      self
+    end
+
+    def ==(other)
+      other.is_a?(self.class) && self.stream == other.stream
+    end
+
+    private
+
+    def method_missing(method, *args, &block)
+      result = @stream.send(method, *args, &block)
+      if result.kind_of? Enumerator::Lazy
+        self.class.new(result)
+      elsif result.kind_of? ::Array
+        Ru::Array.new(result)
+      else
+        result
+      end
+    end
+  end
+end

data/lib/ru/version.rb

@@ -0,0 +1,3 @@
+module Ru
+  VERSION = '2.1.4'
+end

data/lib/ru.rb

@@ -0,0 +1,7 @@
+require 'active_support/all'
+
+directory = File.dirname(File.absolute_path(__FILE__))
+Dir.glob("#{directory}/ru/*.rb") { |file| require file }
+
+module Ru
+end

data/ru.gemspec

@@ -0,0 +1,20 @@
+require File.expand_path('../lib/ru/version', __FILE__)
+
+Gem::Specification.new do |s|
+  s.authors       = ['Tom Benner', 'Alexander Pavlenko']
+  s.email         = ['tombenner@gmail.com', 'alerticus@gmail.com']
+  s.description = s.summary = %q{Ruby in your shell!}
+  s.homepage      = 'https://github.com/AlexanderPavlenko/ru'
+
+  s.files         = `git ls-files`.split($\)
+  s.name          = 'ru2'
+  s.executables   = ['ru']
+  s.require_paths = ['lib']
+  s.version       = Ru::VERSION
+  s.license       = 'MIT'
+
+  s.add_dependency 'activesupport', '>= 3.2.0'
+
+  s.add_development_dependency 'appraisal', '~> 1.0'
+  s.add_development_dependency 'rspec', '~> 3.1'
+end

data/spec/examples/misc_examples_spec.rb

@@ -0,0 +1,40 @@
+require 'spec_helper'
+
+describe 'misc examples' do
+  include FixturesHelper
+  include ProcessHelper
+
+  # http://stackoverflow.com/questions/450799/shell-command-to-sum-integers-one-per-line
+  context "summing integers" do
+    it "sums" do
+      lines = (1..10).to_a.map(&:to_s)
+      out = run('map(:to_i).sum', lines)
+      expect(out).to eq('55')
+    end
+  end
+
+  # http://stackoverflow.com/questions/6022384/bash-tool-to-get-nth-line-from-a-file
+  context "printing the nth line" do
+    it "prints" do
+      lines = (1..10).to_a.map(&:to_s)
+      out = run('[4]', lines)
+      expect(out).to eq('5')
+    end
+  end
+
+  # https://coderwall.com/p/ueazhw
+  context "sorting an Apache access log by response time" do
+    it "sorts" do
+      file = fixture_path('files', 'access.log')
+      out = run(['map { |line| [line[/(\d+)( ".+"){2}$/, 1].to_i, line] }.sort.reverse.map(:join, " ")', file])
+      expect(out).to eq(<<-EOF.strip
+584912 66.249.64.14 - - [18/Sep/2004:11:07:48 +1000] "GET /file.txt HTTP/1.0" 200 584912 "-" "Googlebot/2.1"
+6433 66.249.64.14 - - [18/Sep/2004:11:07:48 +1000] "GET / HTTP/1.0" 200 6433 "-" "Googlebot/2.1"
+6433 66.249.64.13 - - [18/Sep/2004:11:07:48 +1000] "GET / HTTP/1.0" 200 6433 "-" "Googlebot/2.1"
+468 66.249.64.14 - - [18/Sep/2004:11:07:48 +1000] "GET /robots.txt HTTP/1.0" 200 468 "-" "Googlebot/2.1"
+468 66.249.64.13 - - [18/Sep/2004:11:07:48 +1000] "GET /robots.txt HTTP/1.0" 200 468 "-" "Googlebot/2.1"
+EOF
+      )
+    end
+  end
+end

data/spec/examples/sed_examples_spec.rb

@@ -0,0 +1,95 @@
+require 'spec_helper'
+
+# https://www.gnu.org/software/sed/manual/sed.html#Examples
+describe 'sed examples' do
+  include FixturesHelper
+  include ProcessHelper
+
+  context "centering lines" do
+    it "centers" do
+      lines = %w{john paul george} + ['             ringo      ']
+      out = run('each_line.strip.center(10)', lines)
+      expect(out).to eq("   john   \n   paul   \n  george  \n  ringo   ")
+    end
+  end
+
+  context "increment a number" do
+    it "increments" do
+      lines = ('5'..'10').to_a
+      out = run('(each_line.to_i+1)', lines)
+      expect(out).to eq(('6'..'11').to_a.join("\n"))
+    end
+  end
+
+  context "reverse characters of lines" do
+    it "reverses" do
+      lines = %w{john paul george ringo}
+      out = run('each_line.reverse', lines)
+      expect(out).to eq("nhoj\nluap\negroeg\nognir")
+    end
+  end
+
+  context "numbering lines" do
+    it "numbers" do
+      lines = %w{john paul george ringo}
+      out = run('map.with_index { |line, index| "#{(index+1).to_s.rjust(6)}  #{line}" }', lines)
+      expect(out).to eq("     1  john\n     2  paul\n     3  george\n     4  ringo")
+    end
+  end
+
+  context "counting lines" do
+    it "counts" do
+      lines = %w{john paul george ringo}
+      out = run('length', lines)
+      expect(out).to eq("4")
+    end
+  end
+
+  context "printing the first lines" do
+    it "prints" do
+      lines = %w{john paul george ringo}
+      out = run('[0,2]', lines)
+      expect(out).to eq("john\npaul")
+    end
+  end
+
+  context "printing the last lines" do
+    it "prints" do
+      lines = %w{john paul george ringo}
+      out = run('[2..-1]', lines)
+      expect(out).to eq("george\nringo")
+    end
+  end
+
+  context "make duplicate lines unique" do
+    it "dedupes" do
+      lines = %w{john john paul george george george ringo}
+      out = run('uniq', lines)
+      expect(out).to eq("john\npaul\ngeorge\nringo")
+    end
+  end
+
+  context "print duplicated lines of input" do
+    it "prints" do
+      lines = %w{john john paul george george george ringo}
+      out = run('select { |line| self.count(line) > 1 }', lines)
+      expect(out).to eq("john\njohn\ngeorge\ngeorge\ngeorge")
+    end
+  end
+
+  context "remove all duplicated lines" do
+    it "removes" do
+      lines = %w{john john paul george george george ringo}
+      out = run('select { |line| self.count(line) == 1 }', lines)
+      expect(out).to eq("paul\nringo")
+    end
+  end
+
+  context "squeezing blank lines" do
+    it "squeezes" do
+      lines = "john\n\npaul\ngeorge\n\n\nringo"
+      out = run('to_s.squeeze("\n")', lines)
+      expect(out).to eq("john\npaul\ngeorge\nringo")
+    end
+  end
+end