muflax 0.1.34

data/README

@@ -0,0 +1,39 @@
+Convenience library that pulls in all standard libraries and hacks I use in quick scripts.
+
+[ TODO
+
+- shortcut for "@var = var" initializations; I think Rails ships it even?
+- .to_i!, .max!
+- a few more extensions to range_math, notably "pass method call to numbers"
+
+]
+[ Memoization
+
+Should work like this:
+
+- get file and body of the method to be memoized (via method_source gem)
+- hash that as the method signature
+- take arguments, hash them (via Ruby) (you shouldn't pass fancy arguments, only trivially hashable ones, like strings or symbols, not arrays or some custom object shit)
+- save/retrieve result in/from hash (as simple pickle)
+- initialize hash from database, "checkpoint.cache" and save results
+
+- annotate all methods that can be memoized? memoize everything by default? not sure yet, but opt-in is probably the most predictable behavior
+
+This enables checkpoint-esque behavior: any method that hasn't changed (same signature) and takes the same arguments just loads the result from a big hash instead of re-generating it every time, but any actual change will be taken into account.
+
+The database can simply be regularly cleaned / deleted, or just discard old signatures (when initializing, look up method name -> test signature -> different? discard cache for this method)
+
+Like:
+
+~~~
+require "muflax/checkpoint"
+
++Checkpoint
+def method args
+  ...
+end
+
+method(42)
+~~~
+
+]

data/Rakefile

@@ -0,0 +1,23 @@
+desc "open a pry session preloaded with this library"
+task :pry do
+  sh "pry -Ilib -rmuflax"
+end
+
+desc "build a gem from the gemspec"
+task :build do
+  sh "mkdir -p pkg"
+  sh "gem build muflax.gemspec"
+  sh "mv muflax-*.gem pkg/"
+end
+
+desc "clean pkg"
+task :clean do
+  sh "rm -f pkg/*"
+end
+
+desc "install a gem"
+task :install => [:clean, :build] do
+  sh "gem install -l --no-format-executable pkg/muflax-*.gem"
+end
+
+task :default => :install

data/lib/muflax.rb

@@ -0,0 +1,34 @@
+#!/usr/bin/env ruby
+# coding: utf-8
+# Copyright muflax <mail@muflax.com>, 2013
+# License: GNU GPL 3 <http://www.gnu.org/copyleft/gpl.html>
+
+# ruby libs
+require "csv"
+require "date"
+require "fileutils"
+require "set"
+require "yaml"
+require "zlib"
+
+# external libs
+require "awesome_print"
+require "highline/import"
+require "range_math"
+require "trollop"
+
+# rails
+require "active_support"
+require "active_support/all"
+
+# avoid rails deprecation warning
+I18n.enforce_available_locales = false
+
+def require_local_libs path, location=__FILE__
+  Dir["#{File.join(File.dirname(location), path)}/*.rb"].each do |lib|
+    require lib
+  end
+end
+
+# gem libs
+require_local_libs "muflax"

data/lib/muflax/array.rb

@@ -0,0 +1,59 @@
+#!/usr/bin/env ruby
+# -*- encoding: utf-8 -*-
+# Copyright muflax <mail@muflax.com>, 2013
+# License: GNU GPL 3 <http://www.gnu.org/copyleft/gpl.html>
+
+class Array
+  def align str=" ", alignment: :left
+    lines = []
+    columns = 0
+
+    # split all lines
+    self.each do |line|
+      line = line.split(str, -1)
+      lines << line
+      columns = [columns, line.size - 1].max
+    end
+
+    just_function = case alignment
+                    when :left   ; :ljust
+                    when :right  ; :rjust
+                    when :center ; :center
+                    else
+                      raise "invalid alignment: #{alignment}"
+                    end
+
+    # justify all columns
+    (0..columns).each do |column|
+      length = lines.map{|line| line[column]}.length_of_longest
+
+      lines.each do |line|
+        elem = line[column]
+        unless elem.nil?
+          # how much the element is internally longer than it appears
+          elem_diff = elem.to_s.length - elem.str_length
+
+          line[column] = elem.send(just_function, length + elem_diff)
+        end
+      end
+    end
+
+    # join lines back together
+    lines.map{|line| line.join(str)}
+  end
+
+  def align! str=" ", alignment: :left
+    self.replace(self.align(str, alignment: alignment))
+  end
+
+  def triangle
+    return to_enum(:triangle) unless block_given?
+
+    self.each.with_index do |a, ai|
+      self.each.with_index do |b, bi|
+        next if bi < ai
+        yield [a, b]
+      end
+    end
+  end
+end

data/lib/muflax/debug.rb

@@ -0,0 +1,31 @@
+#!/usr/bin/env ruby
+# -*- encoding: utf-8 -*-
+# Copyright muflax <mail@muflax.com>, 2013
+# License: GNU GPL 3 <http://www.gnu.org/copyleft/gpl.html>
+
+# This is very stupid and shouldn't be used in real code, which is why I will use it in real code.
+
+def bp
+  require "debug_inspector"
+  require "pry"
+  RubyVM::DebugInspector.open do |inspector|
+    eval("binding.pry", inspector.frame_binding(2))
+  end
+end
+
+def bpe
+  require "debug_inspector"
+  require "pry"
+  RubyVM::DebugInspector.open do |inspector|
+    eval("binding.pry; exit", inspector.frame_binding(2))
+  end
+end
+
+def v *variables
+  require "debug_inspector"
+  RubyVM::DebugInspector.open do |inspector|
+    variables.each do |variable|
+      eval("print '#{variable}: '; ap #{variable}", inspector.frame_binding(2))
+    end
+  end
+end

data/lib/muflax/dir.rb

@@ -0,0 +1,16 @@
+#!/usr/bin/env ruby
+# -*- encoding: utf-8 -*-
+# Copyright muflax <mail@muflax.com>, 2014
+# License: GNU GPL 3 <http://www.gnu.org/copyleft/gpl.html>
+
+class Dir
+  class << self
+    alias_method :"_[]", :"[]"
+
+    # make glob sort by default
+    def [] *args
+
+      self.send(:"_[]", *(args.map{|a| File.expand_path(a)})).sort
+    end
+  end
+end

data/lib/muflax/enumerable.rb

@@ -0,0 +1,67 @@
+#!/usr/bin/env ruby
+# -*- encoding: utf-8 -*-
+# Copyright muflax <mail@muflax.com>, 2013
+# License: GNU GPL 3 <http://www.gnu.org/copyleft/gpl.html>
+
+module Enumerable
+  # find shortest element
+  def shortest
+    self.min_by{|s| s.str_length}
+  end
+
+  # find longest element
+  def longest
+    self.max_by{|s| s.str_length}
+  end
+
+  def length_of_longest
+    self.longest.str_length
+  end
+
+  def length_of_shortest
+    self.shortest.str_length
+  end
+
+  def average
+    self.sum.to_f / self.size.to_f
+  end
+  alias :mean :average
+  alias :avg  :average
+
+  def geometric_mean
+    self.reduce(:*).to_f ** (1.0 / self.size.to_f)
+  end
+
+  def median
+    self.percentile 0.5
+  end
+
+  def median_by &block
+    self.percentile_by 0.5, &block
+  end
+
+  def percentile percent
+    self.sort[(self.size * percent).round]
+  end
+
+  def percentile_by percent, &block
+    self.sort_by(&block)[(self.size * percent).round]
+  end
+
+  def triangle
+    self.to_a.triangle
+  end
+
+  def histogram &block
+    histo = vivaHash 0
+    self.each do |el|
+      histo[block.call(el)] += 1
+    end
+
+    histo
+  end
+
+  def count_by &block
+    self.histogram(&block).sort_by(&:second).to_h
+  end
+end

data/lib/muflax/file.rb

@@ -0,0 +1,39 @@
+#!/usr/bin/env ruby
+# -*- encoding: utf-8 -*-
+# Copyright muflax <mail@muflax.com>, 2013
+# License: GNU GPL 3 <http://www.gnu.org/copyleft/gpl.html>
+
+class File
+  def self.save name, as: :text, &blk
+    name = File.expand_path(name)
+
+    # make sure directory exists
+    dir = File.dirname(name)
+    FileUtils.mkdir_p dir if not Dir.exists? dir
+
+    # now open it
+    case as
+    when :anki
+      f = CSV.open(name, "w", :col_sep => "\t", &blk)
+    when :text
+      f = File.open(name, "w", &blk)
+    else
+      raise "unsupported file format: #{as}"
+    end
+
+    f
+  end
+
+  def self.load name
+    name = File.expand_path(name)
+
+    file = case name
+           when /\.gz$/
+             Zlib::GzipReader.open(name)
+           else
+             File.open(name)
+           end
+
+    file
+  end
+end

data/lib/muflax/hash.rb

@@ -0,0 +1,14 @@
+#!/usr/bin/env ruby
+# -*- encoding: utf-8 -*-
+# Copyright muflax <mail@muflax.com>, 2013
+# License: GNU GPL 3 <http://www.gnu.org/copyleft/gpl.html>
+
+# simple auto-vivifying hash
+# TODO support nested hashes
+def vivaHash default=[]
+  hash = Hash.new do |h, k|
+    h[k] = default.duplicable? ? default.dup : default
+  end
+
+  hash
+end

data/lib/muflax/kernel.rb

@@ -0,0 +1,21 @@
+#!/usr/bin/env ruby
+# -*- encoding: utf-8 -*-
+# Copyright muflax <mail@muflax.com>, 2014
+# License: GNU GPL 3 <http://www.gnu.org/copyleft/gpl.html>
+
+module Kernel
+  def hr
+    width, height	= HighLine::SystemExtensions.terminal_size
+    linewidth    	= [(width || 0) - 1, 1].max
+
+    puts "-" * (linewidth)
+  end
+
+  def zsh command
+    system "zsh", "-l", "-c", command
+  end
+
+  def fish command
+    system "fish", "-l", "-c", command
+  end
+end

data/lib/muflax/library.rb

@@ -0,0 +1,16 @@
+#!/usr/bin/env ruby
+# -*- encoding: utf-8 -*-
+# Copyright muflax <mail@muflax.com>, 2013
+# License: GNU GPL 3 <http://www.gnu.org/copyleft/gpl.html>
+
+def require_local lib_name, location=__FILE__
+  file = File.symlink?(location) ? File.readlink(location) : location
+  lib = File.join File.dirname(file), "/../lib/#{lib_name}.rb"
+
+  if File.exists? lib
+    # using local version
+    require lib
+  else
+    require lib_name
+  end
+end

data/lib/muflax/objects.rb

@@ -0,0 +1,51 @@
+#!/usr/bin/env ruby
+# -*- encoding: utf-8 -*-
+# Copyright muflax <mail@muflax.com>, 2013
+# License: GNU GPL 3 <http://www.gnu.org/copyleft/gpl.html>
+
+# make it possible to track data in attributes
+class Class
+  alias_method :attr_reader_without_tracking, :attr_reader
+  def attr_reader(*names)
+    attr_readers.concat(names)
+    attr_reader_without_tracking(*names)
+  end
+
+  def attr_readers
+    @attr_readers ||= [ ]
+  end
+
+  alias_method :attr_writer_without_tracking, :attr_writer
+  def attr_writer(*names)
+    attr_writers.concat(names)
+    attr_writer_without_tracking(*names)
+  end
+
+  def attr_writers
+    @attr_writers ||= [ ]
+  end
+
+  alias_method :attr_accessor_without_tracking, :attr_accessor
+  def attr_accessor(*names)
+    attr_readers.concat(names)
+    attr_writers.concat(names)
+    attr_accessor_without_tracking(*names)
+  end
+end
+
+class Object
+  def differences_with(other)
+    # get list of all attributes
+    attrs = (self.class.attr_readers + self.class.attr_writers).uniq.sort
+
+    # pick all attributes that they disagree about
+    attrs.reject do |attr|
+      self.respond_to? attr and other.respond_to? attr and self.send(attr) == other.send(attr)
+    end
+  end
+
+  # consistent string length
+  def str_length
+    HighLine.uncolor(self.to_s).length
+  end
+end

data/lib/muflax/regex.rb

@@ -0,0 +1,25 @@
+#!/usr/bin/env ruby
+# -*- encoding: utf-8 -*-
+# Copyright muflax <mail@muflax.com>, 2013
+# License: GNU GPL 3 <http://www.gnu.org/copyleft/gpl.html>
+
+class String
+  def mgsub replacements={}
+    str = self.dup
+
+    str.mgsub! replacements
+
+    str
+  end
+  alias :gsub_all :mgsub
+  
+  def mgsub! replacements={}
+    replacements.each do |a, b|
+      self.gsub! a, b
+    end
+
+    self
+  end
+  alias :gsub_all! :mgsub!
+end
+