nrser-rash 0.2.0

data/dev/scratch/main.rb

@@ -0,0 +1,4 @@
+# load 'inc.rb', true
+require './inc.rb'
+
+f 'blah'

data/dev/scratch/optparse.rb

@@ -0,0 +1,43 @@
+# play with optparse
+
+# A script that will pretend to resize a number of images
+require 'optparse'
+
+# This hash will hold all of the options
+# parsed from the command-line by
+# OptionParser.
+options = {}
+
+optparse = OptionParser.new do |opts|
+
+  # Define the options, and what they do
+  options[:verbose] = false
+  opts.on( '-v', '--verbose', 'Output more information' ) do
+    options[:verbose] = true
+  end
+
+  options[:quick] = false
+  opts.on( '-q', '--quick', 'Perform the task quickly' ) do
+    options[:quick] = true
+  end
+
+  options[:logfile] = nil
+  opts.on( '-l', '--logfile FILE', 'Write log to FILE' ) do |file|
+    options[:logfile] = file
+  end
+end
+
+puts ARGV.inspect
+
+# Parse the command-line. Remember there are two forms
+# of the parse method. The 'parse' method simply parses
+# ARGV, while the 'parse!' method parses ARGV and removes
+# any options found there, as well as any parameters for
+# the options. What's left is the list of files to resize.
+optparse.parse!
+
+puts "Being verbose" if options[:verbose]
+puts "Being quick" if options[:quick]
+puts "Logging to file #{options[:logfile]}" if options[:logfile]
+
+p ARGV

data/dev/scratch/overridding-cd.sh

@@ -0,0 +1,53 @@
+# want to override `cd` so that it will try and change to a local github repo
+# iff regular `cd` fails...
+
+function alias_function {
+    local ORIG_FUNC=$(declare -f $1)
+    local NEWNAME_FUNC="$2${ORIG_FUNC#$1}"
+    eval "$NEWNAME_FUNC"
+}
+
+function is_function {
+  local TYPE=$(type "$1")
+  if [[ "$TYPE" =~ "is a function" ]]; then
+    return 0
+  else
+    return 1
+  fi
+}
+
+is_function "cd"
+if [ $? -ne 0 ]; then
+  alias_function "cd" "old_cd"
+else
+  function old_cd {
+    builtin cd "$@"
+  }
+fi
+
+function cd {
+  # first, try to execute the `cd`
+  old_cd "$@"
+  local RTN="$?"
+  if [[ $RTN != 0 ]]; then
+    echo "looking for a project..." 1>&2
+    if rash call 'Project.resolve_repo' "$1"; then
+      old_cd `rash call 'Project.dir' $1`
+      return $?
+    fi
+  fi
+  return $RTN
+  # echo "cd'ing into '$1'"
+  # # see if it looks like `$1` will be a directory we can change to from
+  # # here, which takes precendence
+  # if [ ! -d $1 ]; then
+  #   # it doesn't look like it's a dir, so try to 
+  #   rash call 'Project.cd' "$1" --RASH_PRINT_ERRORS=0
+  #   if [ $? -ne 0 ]; then
+  #   echo "using old_cd"
+  #   old_cd "$1"
+  # else
+  #   echo "using Project.cd"
+  #   Project.cd "$1" 
+  # fi
+}

data/dev/scratch/path.sh

@@ -0,0 +1,22 @@
+function split {
+  local IFS=:
+  local array
+  set -f
+  array=( $@ )
+  set +f
+  printf '%s\n' "${array[@]}"
+}
+
+# split $PATH
+
+function path_prepend {
+  export PATH="$1:$PATH"
+}
+
+function path_append {
+  export PATH="$PATH:$1"
+}
+
+path_prepend "blah"
+
+echo $PATH

data/dev/scratch/pirating_methods.rb

@@ -0,0 +1,62 @@
+# define a module with a class method
+module M
+  def self.f
+    puts 'success!'
+  end
+
+  def self.h
+    puts 'and again!'
+  end
+end
+
+# this allows it be invoked via
+M.f
+
+# but now we want to make it available globally
+#
+# [1]: http://softwarebyjosh.com/2012/01/21/Pirating-Ruby-Methods-For-Fun-And-Profit.html
+# [2]: http://stackoverflow.com/questions/4390329/how-do-we-copy-singleton-methods-between-different-ruby-classes
+# [3]: http://stackoverflow.com/questions/3782026/how-do-i-dynamically-define-a-method-as-private
+
+main = self
+# pirate = main.class.new.extend(M)
+M.singleton_methods.each do |name|
+  # main.class.send(:define_method, name, &M.method(name))
+  Object.instance_eval do 
+    define_method name, &M.method(name)
+    private name
+  end
+  # M.method(name).unbind.bind(main)
+end
+
+# now, will this work?
+f
+# after much fiddling, it seems so
+
+# however, we should not be able to invoke f on an `Object` instance
+begin
+  Object.new.f
+rescue NoMethodError => e
+  puts "success! failed to call `Object.new.f` with: #{ e }"
+end
+
+# this matches behavoir when defining on the top-level
+def g
+  puts 'blah'
+end
+begin
+  Object.new.g
+rescue NoMethodError => e
+  puts "success! failed to call `Object.new.g` with: #{ e }"
+end
+
+# note that we can use this to fuck up methods on `Object`:
+def to_s
+  "hey!"
+end
+class C; end
+begin
+  C.new.to_s
+rescue NoMethodError => e
+  puts "fuck, we broke `Object.to_s`"
+end