ix-cli 0.0.1

data/bin/ix-slider

@@ -0,0 +1,201 @@
+#!/usr/bin/env ruby
+
+# TODO: decide if we should load current_value from flag or file override. 
+# TODO: allow user to type numbers to jump to a given part of the slider.
+
+require 'io/console'
+require 'timeout'
+require 'isna'
+require 'optparse'
+
+$options = {}
+
+# $options[:left_arrow]    ||= "\e[D"
+# $options[:right_arrow]   ||= "\e[C"
+$options[:left_arrow]    ||= 'h'
+$options[:right_arrow]   ||= 'l'
+$options[:up_arrow]      ||= 'k'
+$options[:down_arrow]    ||= 'j'
+$options[:bar_width]     ||= 40
+$options[:minimum_value] ||= 0
+$options[:maximum_value] ||= 100
+$options[:current_value] ||= 50
+$options[:running] = true
+
+OptionParser.new do |opts|
+
+  opts.banner = "Usage: #{File.basename($0)} [OPTIONS]"
+
+  opts.on('-r', '--right-arrow [KEY]', 'Keyboard key to use as a right arrow.') do |value|
+    $options[:right_arrow] = value
+  end
+
+  opts.on('-l', '--left-arrow [KEY]', 'Keyboard key to use as a left arrow.') do |value|
+    $options[:left_arrow] = value
+  end
+
+  opts.on('-u', '--up-arrow [KEY]', 'Keyboard key to use as an up arrow.') do |value|
+    $options[:up_arrow] = value
+  end
+
+  opts.on('-d', '--down-arrow [KEY]', 'Keyboard key to use as a down arrow.') do |value|
+    $options[:down_arrow] = value
+  end
+
+  opts.on('-b', '--bar-width [NUMBER]', 'Number of chars to use for bar the bar width.') do |value|
+    $options[:bar_width] = value.to_i
+  end
+
+  opts.on('-m', '--minimum-value [NUMBER]', 'Minimum value of slider.') do |value|
+    $options[:minimum_value] = value.to_i
+  end
+
+  opts.on('-a', '--maximum-value [NUMBER]', 'Maximum value of slider.') do |value|
+    $options[:maximum_value] = value.to_i
+  end
+
+  opts.on('-c', '--current-value [NUMBER]', 'Current value of slider.') do |value|
+    $options[:current_value] = value.to_i
+  end
+
+  opts.on('-f', '--file [FILE]', 'The filename where the value of slider will be written to.') do |value|
+    $options[:file] = value
+  end
+
+end.parse!
+
+required_options = [
+  :left_arrow,
+  :right_arrow,
+  :up_arrow,
+  :down_arrow,
+  :bar_width,
+  :minimum_value,
+  :maximum_value,
+  :current_value,
+  :file
+]
+
+required_options.each do |option|
+  unless $options[option]
+    $stderr.puts "Can not run #{option.to_s} was not given."
+    exit 1
+  end
+end
+
+def readkey
+  c = ''
+  result = ''
+  $stdin.raw do |stdin|
+    c = stdin.getc
+    result << c
+    if c == "\e"
+      begin
+        while (c = Timeout::timeout(0.0001) { stdin.getc })
+          result << c
+        end
+      rescue Timeout::Error
+        # no action required
+      end
+    end
+  end
+  result
+end
+
+def legend
+  labels = {
+    $options[:right_arrow] => 'right',
+    $options[:left_arrow]  => 'left',
+    $options[:up_arrow]    => 'finish',
+    $options[:down_arrow]  => 'start',
+    'q'                    => 'quit'
+  }
+  parts = labels.keys.sort.map do |key|
+    "#{key.to_ansi.green.to_s} = #{labels[key]}"
+  end
+  parts * ', '
+end
+
+def print_slider(min, max, needle, open, close, spacer, marker)
+  print open
+  per_abstract_unit = (needle.to_f / max.to_f * $options[:bar_width])
+  print rainbow(marker, per_abstract_unit, $options[:bar_width])
+  print (spacer * ($options[:bar_width] - per_abstract_unit.to_i ))
+  print close
+  print " value: #{needle}   "
+end
+
+def rainbow(marker, current, max)
+  result = (marker * current)
+  percent = (100 / $options[:bar_width].to_f * current)
+  case percent
+  when 0..25
+    return result
+  when 25..50
+    return result.to_ansi.green.to_s
+  when 50..75
+    return result.to_ansi.yellow.to_s
+  when 75..100
+    return result.to_ansi.red.to_s
+  end
+end
+
+def update_file(file, value)
+  File.open(file, 'w+') do |file|
+    file.puts value
+  end
+end
+
+$stdout.sync = true
+puts legend
+
+if File.exists?($options[:file])
+  $options[:current_value] = File.read($options[:file]).to_i
+end
+
+Thread.new do
+  loop do
+    update_file($options[:file], $options[:current_value])
+    sleep 0.5
+    break unless $options[:running]
+  end
+end
+
+loop do
+  char = readkey
+  if char == 'q'
+    puts 'bye.'
+    $options[:running] = false
+    break
+  end
+  if char == $options[:right_arrow]
+    if ($options[:current_value] + 1) <= $options[:maximum_value]
+      $options[:current_value] += 1
+    end
+  end
+  if char == $options[:left_arrow]
+    if ($options[:current_value] - 1) >= $options[:minimum_value]
+      $options[:current_value] -= 1
+    end
+  end
+  if char == $options[:up_arrow]
+    $options[:current_value] = $options[:maximum_value]
+  end
+  if char == $options[:down_arrow]
+    $options[:current_value] = $options[:minimum_value]
+  end
+
+  print "\b" * 5000
+
+  print_slider(
+    $options[:minimum_value],
+    $options[:maximum_value],
+    $options[:current_value],
+    '[',
+    ']',
+    ' ',
+    '|'
+  )
+
+end
+

data/bin/ix-snake

@@ -0,0 +1,25 @@
+#!/usr/bin/env ruby
+
+WORDS_REGEX = /\w+/
+UPPER_CASE_WORDS = /([A-Z])/
+SPACE_PADDING = /^\s+/
+STARTS_WITH_UPPERCASE = /\s*[A-Z]/
+
+starts_with_uppercase = false
+
+STDIN.each_line do |line|
+  line.chomp!
+  if line =~ STARTS_WITH_UPPERCASE
+    starts_with_uppercase = true
+  end
+  line.gsub!(UPPER_CASE_WORDS, ' \1')
+  padding = line.scan(SPACE_PADDING)[0].to_s
+  words = line.scan(WORDS_REGEX)
+
+  if starts_with_uppercase
+    padding = padding[1..(padding.size - 1)]
+  end
+
+  puts padding + words.map { |word| word.downcase } * '_'
+end
+

data/bin/ix-split

@@ -0,0 +1,9 @@
+#!/usr/bin/env ruby
+
+STDIN.each_line do |line|
+  line.chomp.split(Regexp.new(ARGV[0])).each do |chunk|
+    puts chunk
+  end
+end
+
+

data/bin/ix-stack

@@ -0,0 +1,42 @@
+#!/usr/bin/env ruby
+
+if ARGV[0]
+  Dir.chdir ARGV[0]
+end
+
+STDIN.each do |line|
+  chunks = line.split(':')
+  file = chunks[0]
+  line_number = chunks[1].to_i
+  spacer = file.scan(/^\s*/)[0]
+  file.gsub!(/^\s+/, '')
+  unless File.exists? file
+    puts line
+    next
+  end
+
+  if File.directory? file
+    puts line
+    next
+  end
+
+  puts ''
+  puts line.chomp
+  puts "#{spacer}vim +#{line_number} #{file}"
+  data = File.read(file)
+  counter = 0
+  data.each_line do |line|
+    counter += 1
+    if counter > line_number -10
+      if counter < line_number +10
+        if counter == line_number
+          puts "#{spacer}" + counter.to_s.rjust(8, ' ') + "| #{line.chomp}"
+        else
+          puts spacer +counter.to_s.rjust(8, ' ') + "| #{line}"
+        end
+      end
+    end
+  end
+
+end
+

data/bin/ix-stack-2

@@ -0,0 +1,31 @@
+#!/usr/bin/env ruby
+
+require 'isna'
+
+STDIN.each_line do |stack_line|
+  filepath, line = stack_line.split(':')
+  puts ''
+  puts '-' * 80
+  puts "file: #{filepath}" 
+  puts "line: #{line}" 
+
+  line = line.to_i
+  range_left = ((line - 5)..line).to_a
+  range_right = (line..(line + 5)).to_a
+  full_range = (range_left + range_right).sort
+
+  if File.exists?(filepath)
+    file_line = 0
+    File.read(filepath).each_line do |fline|
+      file_line += 1
+      if full_range.include?(file_line)
+        if line == file_line
+          r = "%10.f | %s" % [file_line, fline]
+          puts r.chomp.to_ansi.red.to_s
+        else
+          puts "%10.f | %s" % [file_line, fline]
+        end
+      end
+    end
+  end
+end

data/bin/ix-stamp

@@ -0,0 +1,5 @@
+#!/usr/bin/env ruby
+
+STDIN.each_line do |line|
+  puts "#{'%20.6f' % Time.now.to_f} #{line}"
+end

data/bin/ix-stats

@@ -0,0 +1,11 @@
+#!/bin/sh
+
+echo "sum\tcount\taverage\tmedian\tmin\tmax"
+
+sort -n |
+awk 'BEGIN{c=0;sum=0;}\
+/^[^#]/{a[c++]=$1;sum+=$1;}\
+END{ave=sum/c;\
+if((c%2)==1){median=a[int(c/2)];}\
+else{median=(a[c/2]+a[c/2-1])/2;}\
+print sum,"\t",c,"\t",ave,"\t",median,"\t",a[0],"\t",a[c-1]}'

data/bin/ix-stream

@@ -0,0 +1,15 @@
+#!/usr/bin/env ruby
+
+chunks = ARGV[0].to_i
+interval = ARGV[1].to_i
+counter = 0
+
+STDIN.each_line do |line|
+  counter += 1
+  puts line.chomp
+
+  if counter == chunks
+    counter = 0
+    sleep interval
+  end
+end

data/bin/ix-string-similarity

@@ -0,0 +1,152 @@
+#!/usr/bin/env ruby
+
+require 'optparse'
+require 'ostruct'
+
+configuration = OpenStruct.new
+
+OptionParser.new do |opts|
+
+  opts.banner = "Find similarity in a set of strings."
+  opts.separator ''
+  opts.separator "Usage: #{File.basename($0)} [OPTIONS]"
+  opts.separator ''
+
+  configuration.group = false
+  configuration.threshold = 50
+  configuration.summary = false
+
+  description = "Group input in batches and process each individually (faster)"
+  opts.on("-g", "--group", description) do |v|
+    configuration.group = v
+  end
+
+  description = "Limit the number of results by threshold, default is 50"
+  opts.on("-t", "--threshhold [NUMBER]", OptionParser::DecimalNumeric, description) do |v|
+    configuration.threshold = v
+  end
+
+  description = "Print a Summary of the groups found"
+  opts.on("-s", "--summary", description) do |v|
+    configuration.summary = v
+  end
+
+
+  opts.separator ''
+
+end.parse!
+
+# puts configuration.inspect
+
+class Array
+  def product
+    inject do |cumulative, value|
+      cumulative += value
+    end
+  end
+end
+
+class String
+  def to_a
+    array = []
+    size.times do |n|
+      array << self[n]
+    end
+    array
+  end
+
+  def scores(other_string)
+    longest_string = nil
+    if other_string.size > self.size
+      longest_string = other_string
+      shortest_string = self
+    else
+      longest_string = self
+      shortest_string = other_string
+    end
+    scores = longest_string.to_a.map do |char|
+      0
+    end
+    shortest_string.size.times do |index|
+      if shortest_string[index] == longest_string[index]
+        scores[index] = 1
+      end
+    end
+    scores
+  end
+
+  def similarity(other_string)
+    scores(other_string).product * 100.0 / size
+  end
+end
+
+class TargetString
+  attr_accessor :evaluated
+  attr_accessor :data
+  def to_s
+    data
+  end
+end
+
+# client
+
+strings = []
+
+STDIN.each_line do |line|
+  next if line.chomp == ''
+  strings << line.chomp
+end
+
+strings.sort! do |n1, n2|
+  n1.size <=> n2.size
+end
+  
+strings.reverse!
+
+strings.map! do |string|
+  target_string = TargetString.new
+  target_string.evaluated = false
+  target_string.data = string
+  target_string
+end
+
+if configuration.group
+  groups = strings.group_by do |string|
+    string.data.size
+  end
+else
+  groups = { 0 => strings }
+end
+
+counter = 0
+groups.each do |key, group|
+  group.each do |string_1|
+    counter = 0
+    unless string_1.evaluated
+      if configuration.summary
+        summary_string = string_1.to_s
+      else
+        puts "****>>" + string_1.to_s
+      end
+    end
+    string_1.evaluated = true
+    group.each do |string_2|
+      next if string_2.evaluated
+      similarity = string_1.to_s.similarity(string_2.to_s)
+      scores = string_1.to_s.scores(string_2.to_s).inspect
+      template = "%5.f %s"
+      bindings = [similarity, string_2, scores]
+      if similarity >= configuration.threshold
+        string_2.evaluated = true
+        counter += 1
+        unless configuration.summary
+          puts template % bindings
+        end
+      end
+    end
+    if counter > 0
+      puts "#{counter} #{summary_string}"
+    end
+  end
+end
+

data/bin/ix-string-similarity2

@@ -0,0 +1,35 @@
+#!/usr/bin/env ruby
+
+# http://stackoverflow.com/questions/9822078/ruby-compare-two-strings-similarity-percentage
+
+def string_difference_percent(a, b)
+  longer = [a.size, b.size].max
+  same = a.each_char.zip(b.each_char).select { |a,b| a == b }.size
+  (longer - same) / a.size.to_f
+end
+
+lines = []
+
+STDIN.each_line do |line|
+  lines.push(line.chomp)
+end
+
+scores = {}
+
+target_line = lines.shift
+
+puts "00 - Comparing: #{target_line}"
+
+lines.each do |line|
+  score = string_difference_percent(target_line, line)
+  scores[score] ||= []
+  scores[score].push(line)
+end
+
+scores.keys.sort.reverse.each do |score|
+  puts ''
+  scores[score].each do |line|
+    puts "\t#{score} #{line}"
+  end
+end
+

data/bin/ix-strip

@@ -0,0 +1,6 @@
+#!/usr/bin/env ruby
+
+STDIN.each_line do |line|
+  puts line[0..(ARGV[0].to_i)]
+end
+

data/bin/ix-substract

@@ -0,0 +1,5 @@
+#!/usr/bin/env ruby
+
+STDIN.each_line do |line|
+  puts line.to_f - ARGV[0].to_f
+end

data/bin/ix-success

@@ -0,0 +1,2 @@
+#!/usr/bin/env ruby
+echo success

data/bin/ix-suffix

@@ -0,0 +1,7 @@
+#!/usr/bin/env ruby
+
+suffix = ARGV.join(' ')
+
+STDIN.each_line do |line|
+  puts line.chomp + suffix
+end

data/bin/ix-sum

@@ -0,0 +1,10 @@
+#!/usr/bin/env ruby
+
+total = 0
+
+STDIN.each_line do |line|
+  total += line.to_f
+end
+
+puts total
+

data/bin/ix-swap

@@ -0,0 +1,3 @@
+#!/usr/bin/env ruby
+
+system "awk '{print $2, $1}'"

data/bin/ix-symlink

@@ -0,0 +1,13 @@
+#!/usr/bin/env ruby
+
+STDIN.each_line do |line|
+  path = ''
+  chunks = line.chomp.split('/')
+  chunks.each do |chunk|
+    path << '/' + chunk
+    if File.symlink?(path)
+      puts "Symlink found: #{path}"
+      system "ls -al #{path}"
+    end
+  end
+end

data/bin/ix-tab

@@ -0,0 +1,6 @@
+#!/usr/bin/env ruby
+
+STDIN.each_line do |line|
+  puts "\t#{line}"
+end
+

data/bin/ix-tabify

@@ -0,0 +1,7 @@
+#!/usr/bin/env ruby
+
+STDIN.each_line do |line|
+  chunks = line.chomp.split(/\s+/)
+  puts chunks * "\t"
+end
+

data/bin/ix-tac

@@ -0,0 +1,11 @@
+#!/usr/bin/env ruby
+
+lines = []
+
+STDIN.read.each_line do |line|
+    lines << line
+end
+
+lines.reverse.each do |line|
+  puts line
+end

data/bin/ix-task

@@ -0,0 +1,20 @@
+#!/usr/bin/env ruby
+
+OK_REGEX = /\s*OK - .*/
+NG_REGEX = /\s*-- - .*/
+LEADING_SPACE = /(^\s*)([^\s].*$)/
+
+STDIN.each_line do |line|
+  line.chomp!
+  if line =~ OK_REGEX
+    line.gsub!('OK - ', '-- - ')
+    puts line
+    next
+  end
+  if line =~ NG_REGEX
+    line.gsub!('-- - ', 'OK - ')
+    puts line
+    next
+  end
+  puts line.gsub(LEADING_SPACE, '\1-- - \2')
+end

data/bin/ix-technical

@@ -0,0 +1,7 @@
+#!/usr/bin/env ruby
+
+STDIN.each_line do |line|
+  puts "[#{line.chomp}]"
+  puts "  | 1. ."
+  puts "  V"
+end

data/bin/ix-template

@@ -0,0 +1,48 @@
+#!/usr/bin/env ruby
+
+require 'fileutils'
+
+INTERPOLATOR_TOKEN = /%\d+s/
+
+# puts interpolate(['world', 'other world'], 'hello %1s')
+def interpolate(values, template) 
+  copy = "#{template}"
+  copy.scan(INTERPOLATOR_TOKEN).each do |interpolator|
+    needle = interpolator.scan(/\d+/).first.to_i
+    value = (values[needle - 1] || 'n/a')
+    copy.gsub!(interpolator, value)
+  end
+  copy
+end
+
+if ARGV[0]
+  template = "#{ARGV[0]}"
+  if File.exists?(template)
+    template = File.read(template)
+  end
+end
+
+STDIN.each_line do |line|
+
+  if line =~ /\t/
+    values = line.chomp.split(/\t/)
+  else
+    values = line.chomp.split(/\s+/)
+  end
+
+  unless ARGV[1]
+    STDOUT.puts interpolate(values, template)
+    next
+  end
+
+  fname = interpolate(values, ARGV[1])
+  dir = File.dirname(fname)
+  unless File.directory?(dir)
+    # puts "creating #{dir}"
+    FileUtils.mkdir_p(dir)
+  end
+  File.open(fname, 'w+') do |file|
+    file.puts interpolate(values, template)
+  end
+end
+