ix-cli 0.0.1

data/bin/ix-catan

@@ -0,0 +1,6 @@
+#!/usr/bin/env ruby
+
+# machin request.
+
+puts 'chill!'
+

data/bin/ix-chain

@@ -0,0 +1,13 @@
+#!/usr/bin/env ruby
+
+items = []
+
+STDIN.each_line do |line|
+  items.push(line.chomp)
+end
+
+items.map! do |item|
+  "[#{item}]"
+end
+
+puts items.join(' -> ')

data/bin/ix-chars

@@ -0,0 +1,4 @@
+#!/usr/bin/env ruby
+
+system "ix scan '.'"
+

data/bin/ix-checklist

@@ -0,0 +1,23 @@
+#!/usr/bin/env ruby
+
+
+template = "
+<p>
+  <input id='%s' type='checkbox' />
+  <label for='%s'>
+    %s
+  </label>
+</p>
+"
+
+counter = 0
+
+STDIN.each_line do |line|
+  counter += 1
+  id = "item_#{counter}"
+  bindings = []
+  bindings.push(id)
+  bindings.push(id)
+  bindings.push(line.chomp)
+  puts template % bindings
+end

data/bin/ix-child-math

@@ -0,0 +1,10 @@
+#!/usr/bin/env ruby
+
+standard = '0123456789'
+children = '1000101021'
+
+STDIN.each_line do |line|
+  line = line.chomp
+  puts line.chomp.tr(standard, children)
+end
+

data/bin/ix-chomp

@@ -0,0 +1,6 @@
+#!/usr/bin/env bash
+
+STDIN.each_line do |line|
+  $stdout.write line.chomp
+end
+

data/bin/ix-chr

@@ -0,0 +1,6 @@
+#!/usr/bin/env ruby
+
+STDIN.each_line do |line|
+  puts line.chomp.to_i.chr
+end
+

data/bin/ix-class

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

data/bin/ix-columns

@@ -0,0 +1,41 @@
+#!/usr/bin/env ruby
+
+require 'tmpdir'
+
+# decomposes each line into columns
+# applying transformations on each column.
+
+class Formatter
+  REGEX = /(\d+)(\:)([^$]+)/
+  def initialize(string)
+    @string = string
+  end
+  def valid?
+    @string =~ REGEX
+  end
+  def column
+    @string.scan(REGEX)[0][0].to_i
+  end
+  def processor
+    @string.scan(REGEX)[0][2]
+  end
+end
+
+def resolve_processor(column)
+end
+
+SPLITTER = /\s+/
+
+STDIN.each_line do |line|
+  output = []
+  columns = line.chomp.split(SPLITTER)
+
+  ARGV.each do |value|
+    formatter = Formatter.new(value)
+    next unless formatter.valid?
+    output.push(`echo #{columns[formatter.column]} | #{formatter.processor}`.chomp)
+  end
+
+  puts output * ' '
+end
+

data/bin/ix-combinations

@@ -0,0 +1,11 @@
+#!/usr/bin/env ruby
+
+sets = []
+
+STDIN.each_line do |line|
+  sets.push(line)
+end
+
+sets.combination((ARGV[0] || 2).to_i).each do |set|
+  puts set * "\t"
+end

data/bin/ix-command-class

@@ -0,0 +1,21 @@
+#!/usr/bin/env ruby
+
+attributes = ARGV[1..(ARGV.size - 1)]
+
+template = attributes.map do |attribute|
+  "%<#{attribute}>s"
+end
+
+template = (template * ' ').inspect
+
+puts "class #{ARGV[0]}"
+  puts "ATTRIBUTES = #{attributes.inspect}"
+  puts "TEMPLATE = #{template}"
+  attributes.each do |attribute|
+    puts "  attr_accessor :#{attribute}"
+  end
+  puts "def to_s"
+  puts "end"
+  puts "def execute"
+  puts "end"
+puts "end"

data/bin/ix-commandify

@@ -0,0 +1,22 @@
+#!/usr/bin/env ruby
+
+def commandify(string)
+  words = {}
+  interpolation_buffer = []
+  string.scan(/\w+/).each do |word|
+    word.downcase!
+    interpolation_buffer.push(word)
+  end
+  interpolation = (interpolation_buffer * '_')
+  words[string] = "%<#{interpolation}>s"
+  words
+end
+
+STDIN.each_line do |line|
+  line = line.chomp!
+  hash = commandify(line)
+  hash.each do |k, v|
+    puts "#{k} #{v}" 
+  end
+end
+

data/bin/ix-commit

@@ -0,0 +1,9 @@
+#!/usr/bin/env ruby
+
+
+STDIN.each_line do |line|
+  line.scan(/[a-f0-9]{40}/).each do |commit|
+    puts commit
+  end
+end
+

data/bin/ix-confirm

@@ -0,0 +1,47 @@
+#!/usr/bin/env ruby
+
+commands = []
+
+File.read(ARGV[0]).each_line do |line|
+  commands.push(line.chomp)
+end
+
+commands.each do |command|
+
+  puts "confirm: #{command}"
+
+  x = gets
+
+  puts x
+
+  # puts "Confirm (abort, skip, yes, or y): #{command} "
+
+  # puts "response: #{response.inspect}"
+
+  # next
+
+  # if response == "abort\n"
+  #   puts 'Exiting now..'
+  #   exit 0
+  # end
+
+  # if response == "skip\n"
+  #   puts 'Skipping..'
+  #   next
+  # end
+
+  # if response == "yes\n"
+  #   puts 'Executing..'
+  #   system command
+  #   next
+  # end
+
+  # if response == "y\n"
+  #   puts 'Executing..'
+  #   system command
+  #   next
+  # end
+
+  # puts 'doing nothing..'
+
+end

data/bin/ix-constants

@@ -0,0 +1,9 @@
+#!/usr/bin/env ruby
+
+WORDS_REGEX = /\w+/
+
+STDIN.each_line do |line|
+  words = line.scan(WORDS_REGEX)
+  puts words.map { |word| word.upcase } * '_'
+end
+

data/bin/ix-cp

@@ -0,0 +1,10 @@
+#!/usr/bin/env bash
+
+source_application=$1
+target_application=$2
+target_path=`dirname $0`
+source_file="$target_path/ix-$source_application"
+target_file="$target_path/ix-$target_application"
+
+cp $source_file $target_file
+

data/bin/ix-crack

@@ -0,0 +1,163 @@
+#!/usr/bin/env ruby
+
+# ==============================================================================
+# Array hack.
+# ==============================================================================
+# from: https://apidock.com/rails/Array/in_groups_of
+# File activesupport/lib/active_support/core_ext/array/grouping.rb, line 20
+class Array
+  def in_groups_of(number, fill_with = nil)
+    if number.to_i <= 0
+      raise ArgumentError,
+        "Group size must be a positive integer, was #{number.inspect}"
+    end
+
+    if fill_with == false
+      collection = self
+    else
+      # size % number gives how many extra we have;
+      # subtracting from number gives how many to add;
+      # modulo number ensures we don't add group of just fill.
+      padding = (number - size % number) % number
+      collection = dup.concat(Array.new(padding, fill_with))
+    end
+
+    if block_given?
+      collection.each_slice(number) { |slice| yield(slice) }
+    else
+      collection.each_slice(number).to_a
+    end
+  end
+end
+
+# ==============================================================================
+# CRACK IMPLEMENTATION.
+# ==============================================================================
+
+require 'tmpdir'
+require 'json'
+
+class Crack
+
+  MASTER_FUNCTION = %q{
+trap "exit 1" SIGQUIT
+function run_crack_file() {
+    $* 2>&1
+    if [ "$?" != "0" ]; then
+        kill -SIGQUIT $$
+    fi
+}
+}
+
+  SET_FUNCTION = %q{
+function run_command() {
+    uuid=`uuidgen`
+    echo $* > /tmp/$uuid
+    data=`bash /tmp/$uuid 2>&1`
+    status=$?
+    if [ "$status" != "0" ]; then
+        echo "$uuid NG $*"
+        echo "$data" | sed "s/^/`date +%s` `echo $uuid` /"
+        rm /tmp/$uuid
+        exit 1
+    else
+        echo "$uuid OK $*"
+        echo "$data" | sed "s/^/`date +%s` `echo $uuid` /"
+        rm /tmp/$uuid
+    fi
+}
+}
+
+  # Crack - The most lines of crack you do, the best it will feel.
+  #
+  # Receives a *queue* array of system commands to be executed.
+  # and executes them in parallel using a subshelling optimization.
+  #
+  # You may wonder what is the behavior of this parallelization.
+  # Is it asynchronous or synchronous?
+  #
+  # Crack is Asynchronous by nature because it is parallelizing
+  # execution. But it will hide all that handling complexity within
+  # itself. And it will not return until all of the asynchronicity
+  # chaos has been dealt with. So you can assume that it is asynchronous
+  # internally but this method will return only after all the executions
+  # finished.
+  #
+  # threads Fixnum can never be zero, an exception will be thrown.
+  # queue   Array  size can never be zero, an exception will be thrown.
+  #
+  def self.schedule(queue, threads = 16)
+    Dir.mktmpdir do |directory|
+      chunk_size = queue.size / threads
+      chunk_size = 1 if chunk_size == 0
+      master_file = "#{directory}/master.crack"
+      File.open(master_file, 'w+') do |master_file|
+        master_file.puts MASTER_FUNCTION
+        sets = queue.in_groups_of(chunk_size)
+        sets.each_with_index do |set, set_index|
+          set_file_name = "#{directory}/set_#{set_index}.crack"
+          if set_index == sets.size - 1
+            master_file.puts 'run_crack_file "bash ' + set_file_name + '"'
+          else
+            master_file.puts 'run_crack_file "bash ' + set_file_name + '" &'
+          end
+          File.open(set_file_name, 'w+') do |set_file|
+            set_file.puts SET_FUNCTION
+            set.compact.each do |item|
+              set_file.puts "run_command #{item.inspect}"
+            end
+          end
+        end
+        master_file.puts 'wait'
+      end
+
+      # Detects exit status of zero
+      # if process exits with error on ubuntu, fucked up right?.
+      # system "bash #{master_file} &> #{directory}/crack.log"
+      system "bash #{master_file} >>#{directory}/crack.log 2>&1"
+
+      File.read("#{directory}/crack.log").each_line do |line|
+        info = {
+          :trace     => line.chomp,
+          :threads   => threads
+        }
+        puts info.to_json
+      end
+
+      unless $?.success?
+        data = {
+          :queue   => queue,
+          :threads => threads,
+          :time    => Time.now.to_i
+        }
+        sleep 2 # process exits, but data is still streaming.
+        File.open("#{directory}/crack.log", 'a+') do |file|
+          file.puts data.inspect
+        end
+        debug_file = "/tmp/crack_debug_#{Time.now.to_f}.log"
+        system "cp #{directory}/crack.log #{debug_file}"
+        raise "Commands given to crack break, please debug: #{debug_file}"
+      end
+
+    end
+  end
+
+end
+
+# ==============================================================================
+# IX CLIENT CODE.
+# ==============================================================================
+
+commands = []
+
+STDIN.each_line do |line|
+  commands.push(line.chomp)
+end
+
+threads = ARGV[0] || 4
+threads = threads.to_i
+
+
+Crack.schedule(commands, threads)
+
+

data/bin/ix-crap

@@ -0,0 +1,26 @@
+#!/usr/bin/env ruby
+
+regex = /[a-z0-9A-Z]+/
+
+replace = ARGV[0] || 'crap'
+
+needle = 0
+
+upper_case_chars = ('A'..'Z').to_a
+
+STDIN.each_char do |char|
+  if char =~ regex
+    if upper_case_chars.include?(char)
+      print replace[needle].upcase
+    else
+      print replace[needle]
+    end
+    needle += 1
+    if needle == replace.size
+      needle = 0
+    end
+  else
+    print char
+  end
+end
+

data/bin/ix-crazy-case

@@ -0,0 +1,9 @@
+#!/usr/bin/env ruby
+
+options = [:downcase, :upcase]
+
+STDIN.each_char do |char|
+  STDOUT.write(char.send(options.shuffle.first))
+end
+
+

data/bin/ix-create-cluster-nodes

@@ -0,0 +1,15 @@
+#!/usr/bin/env ruby
+
+target = ARGV[0].to_i
+
+STDIN.each_line do |line|
+  puts ''
+  puts 'node = ClusterNode.new'
+  puts "node.ip = #{line.chomp.inspect}"
+  puts "node.target = 'fusion#{target}'"
+  puts "node.name = 'Fusion Render Node #{target}'"
+  puts "node.enabled = false"
+  puts "node.save!"
+  target += 1
+end
+

data/bin/ix-csv-to-json

@@ -0,0 +1,16 @@
+#!/usr/bin/env ruby
+
+require 'rubygems'
+require 'json'
+require 'csv'
+
+STDIN.each_line do |line|
+  CSV.parse(line.force_encoding("iso-8859-1").encode("utf-8")) do |row|
+    object = {}
+    row.size.times do |column|
+      key = ARGV[column] || "column-#{column}"
+      object[key] = row[column]
+    end
+    puts object.to_json
+  end
+end

data/bin/ix-day

@@ -0,0 +1,12 @@
+#!/usr/bin/env ruby
+
+require 'time'
+
+map = {}
+
+STDIN.each_line do |line|
+  ts = line.chomp.to_i
+  time = Time.at(ts)
+  puts "#{ts} - #{time.year}.#{time.month}.#{time.day}"
+end
+

data/bin/ix-debugging

@@ -0,0 +1,33 @@
+#!/usr/bin/env ruby
+
+class Counter
+  class << self
+    def get
+      File.read('/tmp/counter').to_i 
+    end
+    def set(value)
+      File.open('/tmp/counter', 'w+') do |file|
+        file.puts(value)
+      end
+    end
+    def increase
+      set(get + 1)
+    end
+    def decrease
+      set(get - 1)
+    end
+    def to_human
+      get.to_s.rjust(4, '0')
+    end
+  end
+end
+
+
+STDIN.each_line do |line|
+  puts ''
+  Counter.increase
+  puts "#{Counter.to_human} - Debugging: #{ARGV[0]}: #{line.chomp}"
+  puts '--------------------------------------------------------------------------------'
+  puts ''
+end
+

data/bin/ix-decode-base64

@@ -0,0 +1,8 @@
+#!/usr/bin/env ruby
+
+require 'json'
+require 'base64'
+
+STDIN.each_line do |line|
+  print Base64.decode64(line)
+end

data/bin/ix-dequote

@@ -0,0 +1,3 @@
+#!/usr/bin/env bash
+
+ix scan '"[^"]+"' | sed 's/"//g'

data/bin/ix-df

@@ -0,0 +1,15 @@
+#!/usr/bin/env ruby
+
+# /dev/xvdi       2.9T  1.2T  1.7T  42% /ebs/stage-new
+
+STDIN.each_line do |line|
+  puts ''
+  chunks = line.chomp.split(/\s+/)
+  puts "Device: #{chunks[0]}"
+  puts "Total Size: #{chunks[1]}"
+  puts "Space Used: #{chunks[2]}"
+  puts "Space Available: #{chunks[3]}"
+  puts "Percentage Used: #{chunks[4]}"
+  puts "Mount Point: #{chunks[5]}"
+end
+

data/bin/ix-diagram

@@ -0,0 +1,47 @@
+#!/usr/bin/env ruby
+
+require 'tree_node'
+
+class Node
+  include Tree::Node
+  attr_accessor :level
+  attr_accessor :label
+  def initialize(level, label)
+    @level = level
+    @label = label
+  end
+  def to_s
+    "<Node level:#{level}, label:#{label}, children: #{children.size}>"
+  end
+  def relations
+    children.map do |child|
+      "#{label.inspect} -> #{child.label.inspect}"
+    end
+  end
+end
+
+SPACER = /\s\s\s\s/
+
+nodes = []
+
+STDIN.each_line do |line|
+  label = line.chomp.gsub(SPACER, '')
+  level = line.chomp.scan(SPACER).size
+  node = Node.new(level, label)
+  nodes.push(node)
+  nodes.reverse.find do |previous_node|
+    if previous_node.level < node.level
+      previous_node.add_child(node)
+    end
+  end
+end
+
+puts 'digraph diagram {'
+puts "rankdir = #{ARGV[0] || 'LR'};"
+nodes.first.map(:down) do |node|
+  node.relations.each do |relation|
+    puts relation
+  end
+end
+puts '}'
+

data/bin/ix-dirname

@@ -0,0 +1,5 @@
+#!/usr/bin/env ruby
+
+STDIN.each_line do |line|
+  puts File.dirname(line.chomp)
+end

data/bin/ix-divide

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

data/bin/ix-done

@@ -0,0 +1,11 @@
+#!/usr/bin/env ruby
+
+REGEX = /(^\s*)(.*)/
+PREFIX = ARGV[0] || '# '
+
+STDIN.each_line do |line|
+  chunks = line.chomp.scan(REGEX)
+  space, data = chunks[0]
+  puts "#{space}# DONE: #{data}"
+end
+

data/bin/ix-dot-case

@@ -0,0 +1,15 @@
+#!/usr/bin/env ruby
+
+def to_dot_case(string)
+  string.gsub!('_', ' ')
+  words = string.scan(/\w+/)
+  words.map! do |word|
+    word.downcase
+  end
+  words * '.'
+end
+
+STDIN.each_line do |line|
+  puts to_dot_case(line.chomp!)
+end
+

data/bin/ix-downcase

@@ -0,0 +1,5 @@
+#!/usr/bin/env ruby
+
+STDIN.each_line do |line|
+  puts line.chomp.downcase
+end