Life's End

Ruby snipits

Aaron Radke — Thu, 22 May 2008 12:18:18 +0000

Simple Definition Test
Super Test
Database
1. Active Record
User Interaction
1. Highline

Simple definition test

def test
   puts "this is a test"
end

Super Test

class YammDB < Hash
   def initialize(opts={})
      puts "making YammDB #{opts.inspect}"
      super
   end
end
class Sims < YammDB
   def initialize(opts={})
      puts "making Sims with opts: #{opts.inspect}"
      super(opts)
   end
end
   
Sims.new(:blah)
Sims.new()

Database

Active Record

#!/usr/bin/ruby
require 'rubygems'
require 'sqlite3'
require 'activerecord'
   
# connect to database.  This will create one if it doesn't exist
MY_DB_NAME = File.dirname(__FILE__) + "/my.db"
MY_DB = SQLite3::Database.new(MY_DB_NAME)
   
# get active record set up
ActiveRecord::Base.establish_connection(:adapter => 'sqlite3', :database => MY_DB_NAME)
ActiveRecord::Base.logger = Logger.new(File.open("db.log","a"))
ActiveRecord::Base.colorize_logging = false
#ActiveRecord::Base.logger = Logger.new(STDERR)
   
# create your AR class
class Routing < ActiveRecord::Base
   has_and_belongs_to_many :destinations
   has_and_belongs_to_many :sources
end
class Source < ActiveRecord::Base
   has_many :routings
   has_many :subsystems
end
class Destinations < ActiveRecord::Base
   has_many :routings
   has_many :subsystems
end
class Subsystem < ActiveRecord::Base
   has_many :destinations
   has_many :sources
end
   
class CreateTable01 < ActiveRecord::Migration
   def self.up
      create_table :routings do |t|
         t.column :name, :string, :null => false
         t.column :description, :string
         t.column :xml_file, :string, :null => false
      end
      create_table :subsystems do |t|
         t.column :name, :integer
         t.column :version, :integer
      end
      create_table :sources do |t|
         t.column :subsystem_id, :integer
      end
      create_table :destinations do |t|
         t.column :subsystem_id, :integer
      end
      create_table :sources_routings, id => false do |t|
         t.column :routing_id, :integer
         t.column :subsystem_id, :integer
      end
      create_table :destinations_routings, id => false do |t|
         t.column :subsystem_id, :integer
      end
   end
      
   def self.down
      drop_table :routings
      drop_table :sources
      drop_table :destinations
      drop_table :sources_routings
      drop_table :destinations_routings
      drop_table :subsystems
   end
end
   
      
#CreateTable01.migrate(:down)
#CreateTable01.migrate(:up)
   
r = Routing.create(:name => 'test', :description => 'test routing', :xml_file => 'test.xml')
r = Routing.find_by_name('test')
   
puts r.name

User interaction

Highline

#!/usr/bin/ruby
require 'rubygems'
require 'highline'
   
      
@hl = HighLine.new
   
@hl.choose do |menu|
   menu.prompt = "Please choose your favorite programming language?  "
      
   menu.choice(:ruby) { @hl.say("Good choice!") }
   menu.choices(:python, :perl) { @hl.say("Not from around here, are you?") }
end

rpass

Aaron Radke — Thu, 22 May 2008 12:17:59 +0000

Download: rpass.rb

#!/usr/bin/ruby
#title:rpass
#date: 2008-05-19
#author:Aaron Radke
# TODO: add an optional encrypted file to use
require 'rubygems'
require 'crypt/rijndael'
require 'base64'
require 'stringio'
require 'crypt/blowfish'
#require 'highline/import'
require 'highline'
   
      
class RPass
   def initialize(opts={})
      @highline = HighLine.new
      @opts = opts
      @opts[:file] = File.dirname(__FILE__) + "/stored.aes" unless @opts.key?(:file)
      @key = @highline.ask("key for #{@opts[:file]}? ") { |q| q.echo = false}
      @rijndael = Crypt::Rijndael.new("%-32.32s" % @key)
      self.decrypt
   end
      
   def decrypt
      if File.exists?(@opts[:file])
         puts "Decrypting ..."
         #---decrypt
         encryptedString = ""
         File.open(@opts[:file], "r").each{|line|
            encryptedString << line
         }
         # TODO?   Need to add the proper logic if the string did not decrypt
         f = File.open(@opts[:file], "r")
         begin
            @decryptedString = @rijndael.decrypt_string(encryptedString)
         rescue RuntimeError
            puts "Error: Could not decrypt: " + $!
            exit
         end
            
         if decryptedString.class != String
            puts "Error: could not decrypt unkown type"
            exit
         end
            
         #some other key will cause the header to be scrambled
         if decryptedString =~ /^title:rpass/
            @decryptedLines = decryptedString.split(/\n/)[1..-1]
         else
            puts "Error: could not decrypt"
            exit
         end
            
      else
         key2 = @highline.ask("new file: renter key ? ") { |q| q.echo = false}
         if key2 != @key
            puts "Error: Setting up new key failed"
            exit
         else
            @decryptedLines = []
         end
      end
   end
      
   def encrypt
      puts "Saving encrypted version..."
      plainString = @decryptedLines.join("\n")
      plainString = "title:rpass\n" + plainString
      f = File.open(@opts[:file],"w")
      print @rijndael.encrypt_stream(plainString)
      f.close
   end
      
   def insert(text, index = -1)
      @decryptedLines.insert(index, text)
   end
      
   def replace(text, index = -1)
      @decryptedLines[index] = text
   end
   def delete(index = -1)
      @decryptedLines.delete_at(index)
   end
      
   def grep(pattern)
      @decryptedLines.each_with_index{|line,i|
         if line =~ /#{pattern}/i
            puts "#{i}: #{line}"
         end
      }
   end
      
   def ask
      command = @highline.ask("rpass> ", String)
         
      command.sub!(/^\s+/,'')
      command.sub!(/\s+$/,'')
         
      if command =~ /^h(elp)?$/
         puts "Available commands:"
         puts %{---------
            (h)elp
            (l)ist
            exit
            (s)ave
            reload
            (g)rep pattern
            (d)elete index
            (i)nsert index text
            (a)dd text
            newkey key
            (r)eplace index text
         }.gsub(/\t+/,'')
      elsif command =~ /^(exit|quit)$/
         encrypt
         return false
      elsif command =~ /^s(ave)?$/
         encrypt
      elsif command =~ /^reload$/
         decrypt
      elsif command =~ /^l(ist)?$/
         grep(".?")
      elsif command =~ /^g(rep)?\s+(.*)$/
         grep($2)
      elsif command =~ /^d(elete)?\s+(-?\d+)$/
         delete($2.to_i)
      elsif command =~ /^i(nsert)?\s+(-?\d+)\s+(.*)$/
         insert($3,$2.to_i)
      elsif command =~ /^a(dd)?\s+(.*)$/
         insert($2,-1)
         grep($2)
      elsif command =~ /^r(eplace)?\s+(-?\d+)\s+(.*)$/
         replace($3,$2.to_i)
      elsif command =~ /^newkey$/
         key1 = @highline.ask("Enter a new key? ") { |q| q.echo = false}
         key2 = @highline.ask("Renter new key? ") { |q| q.echo = false}
         if key1 == key2
            puts "Setting up new key..."
            @key = key1
            @rijndael = Crypt::Rijndael.new(@key)
         else
            puts "Error, key not duplicated.  New key not set."
         end
         replace($2,$1.to_i)
      else
         grep(command)
      end
         
      return true
   end
      
end
   
      
if ARGV.size == 1
   rpass = RPass.new(:file => ARGV[0])
else
   rpass = RPass.new
end
   
while rpass.ask
end

rgrep

Aaron Radke — Mon, 26 Nov 2007 15:23:04 +0000

Download: rgrep.rb

dirname = ARGV[0]
regexp_string = ARGV[1]
def search_file(file,regexp)
   f = File.open(file,'r')
   found = false
#	puts file
   f.each{|line|
      if line.match(regexp)
         if not found
            puts "\n#{file}"
         end
         puts "\t" + line
         found = true
      end
   }
   f.close
end
   
require 'find'
Find.find(dirname) do |file|
   print '.'
   search_file(file,/#{regexp_string}/) if File.file?(file)
end

rhttpd

Aaron Radke — Mon, 26 Nov 2007 15:23:04 +0000

Download: cgi_handler.rb

require 'webrick'
include WEBrick
   
def start_webrick(config = {})
   # always listen on port 8080
   config.update(:Port => 8080)
   server = HTTPServer.new(config)
   yield server if block_given?
   ['INT', 'TERM'].each {|signal|
   trap(signal) {server.shutdown}
   }
   server.start
end
   
#start_webrick(:DocumentRoot => "g:/infoproweb/webfolder/cgi-bin/ruby",:CGIInterpreter => "g:/ruby/bin/ruby.exe")
#start_webrick(:DocumentRoot => File.expand_path(".."), :CGIInterpreter => "c:/ruby/bin/ruby.exe")
   
      
start_webrick( {:CGIInterpreter => "c:/ruby/bin/ruby.exe"}) {|server|
   cgi_dir = File.expand_path('cgi')
   fh = HTTPServlet::FileHandler
   fh.add_handler("rb",HTTPServlet::CGIHandler);
   fh.add_handler("rbw",HTTPServlet::CGIHandler);
   opts = {:FancyIndexing =>false}
   server.mount("/cgi", fh, "cgi", opts)
   server.mount("/", fh, ".." , opts)
}
#

Using the caps key for the control key

Aaron Radke — Mon, 26 Nov 2007 15:23:04 +0000

Windows

Double click the following text field to move your caps lock key to a less used key and gain a nicer control key.

Download: user_swap_caps_lock_as_control_caps_to_scroll.reg

tag and cdt

Aaron Radke — Mon, 26 Nov 2007 15:23:04 +0000

Download: tag

#!/usr/bin/env ruby
#title:tag
#author:Aaron Radke
#date:2008-01-30
#abstract:a simple tagging app to save snippits and retreave them back
#------------
tag_file = "#{ENV['HOME']}/.tags"
   
#puts "ARGV: #{ARGV.join(",")}"
   
key = ARGV.shift
   
if key == "-s" and ARGV.size >= 2
   f = File.open(tag_file,"a")
   tag = ARGV.shift
   value = ARGV.join(" ")
   f.puts "#{tag}\t#{value}"
   f.close
   exit
end
   
unless key
   null
      puts "Requries an argument"
      exit
end
   
tag_string = <

Life's End

Ruby snipits

Ruby Snipits

Table of Contents

Super Test

Database

Active Record

User interaction

Highline

rpass

Rpass

rgrep

Rgrep

rhttpd

Rhttpd

Using the caps key for the control key

Using the Caps Key for the Control Key

Windows

tag and cdt

Tag and Cdt