user_input 1.0.0

data/lib/user_input.rb

@@ -0,0 +1,246 @@
+# Adds the method from_user_input to various built-in classes as both a class and instance method. 
+# On a class, the method returns a validated instance of that class if it can be coerced into one 
+# (or nil if not). On an instance, it validates more strictly against the value of that instance.
+
+class String
+	# All strings validate as strings
+	def String.from_user_input(value)
+		return value.to_s
+	end
+
+	# instance form does a straight comparison of the string with self.
+	def from_user_input(value)
+		if (self == value.to_s)
+			return value.to_s
+		else
+			return nil
+		end
+	end
+end
+
+class Boolean
+	# Must be a string that is either "true" or "false"
+	def Boolean.from_user_input(value)
+		if (value.kind_of?(TrueClass) || value.kind_of?(FalseClass) ||
+			  /(true|false|on|off|y|n|enabled|disabled)/ =~ value.to_s)
+			return !!(/(true|on|y|enabled)/ =~ value.to_s)
+		else
+			return nil
+		end
+	end
+end
+
+class TrueClass
+	# Either a 'positive' string or an actual instance of true.
+	def from_user_input(value)
+		if (value.kind_of?(TrueClass) || /(true|on|y|enabled)/ =~ value.to_s)
+			return true
+		else
+			return nil
+		end
+	end
+end
+
+class FalseClass
+	# Either a 'negative' string or an actual instance of false.
+	def from_user_input(value)
+		if (value.kind_of?(FalseClass) || /(false|off|n|disabled)/ =~ value.to_s)
+			return false
+		else
+			return nil
+		end
+	end
+end
+
+class Date
+	# Check for a string of the regex /[0-9]{1,2}\/[0-9]{1,2}\/[0-9]{4}/
+	# and make a Date object out of it
+	def Date.from_user_input(value)
+		if (value.kind_of?(Date))
+			return value
+		end
+		begin
+			return Date.parse(value.to_s)
+		rescue ArgumentError
+			return nil
+		end
+	end
+end
+
+class Integer
+	# All characters must be numbers, except for the first which may be -
+	def Integer.from_user_input(value)
+		if (value.kind_of?(Integer) || /^\s*-?[0-9]+\s*$/ =~ value.to_s)
+			return value.to_i
+		else
+			return nil
+		end
+	end
+
+	# instance form does a straight comparison of value.to_i with self.
+	def from_user_input(value)
+		if (!value.kind_of?(Float) && self == value.to_i)
+			return value.to_i
+		else
+			return nil
+		end
+	end
+end
+
+class Float
+	# All characters must be numbers, except there can be up to one decimal
+	# and a negative sign at the front
+	def Float.from_user_input(value)
+		if (value.kind_of?(Float) || /^\s*-?[0-9]*(\.[0-9]+)?\s*$/ =~ value.to_s)
+			return value.to_f
+		else
+			return nil
+		end
+	end
+
+	# instance form does a straight comparison of value.to_f with self.
+	def from_user_input(value)
+		if (self == value.to_f)
+			return value.to_f
+		else
+			return nil
+		end
+	end
+end
+
+class Regexp
+	# Returns the string if value matches self's regex, returns nil otherwise.
+	def from_user_input(value)
+		if (value.kind_of?(String) && matches = self.match(value))
+			return matches
+		else
+			return nil
+		end
+	end
+end
+
+class Range
+	def from_user_input(value)
+		value = self.first.class.from_user_input(value)
+
+		if(!value || !(self === value))
+			return nil
+		end
+
+		return value
+	end
+end
+
+class Array
+	def Array.from_user_input(value)
+		return [*value]
+	end
+	
+	# Checks each element of the value array to ensure that they match against
+	# the first element of self
+	def from_user_input(value)
+		value = [*value]
+		# eliminate the obvious
+		if (self.length != 1)
+			raise ArgumentError, "Must supply only one element to an array you're calling from_user_input on."
+		end
+		innertype = self[0]
+		# now check whether the inner elements of the array match
+		output = value.collect {|innervalue|
+			# if innertype is not an array, but value is, we need to flatten it
+			if (!innertype.kind_of?(Array) && innervalue.kind_of?(Array))
+				innervalue = innervalue[0]
+			end
+			innertype.from_user_input(innervalue); # returns
+		}.compact()
+
+		if (output.length > 0)
+			return output
+		else
+			return nil
+		end
+	end
+end
+
+class Hash
+	def from_user_input(value)
+		if (self.length != 1)
+			raise ArgumentError, "Must supply only one element to a hash you're calling from_user_input on."
+		end
+		if (!value.kind_of?(Hash))
+			return nil
+		end
+		keytype = nil
+		valtype = nil
+		self.each {|k,v| keytype = k; valtype = v}
+		output = {}
+		value.each {|k, v|
+			if (!(k = keytype.from_user_input(k)).nil? && !(v = valtype.from_user_input(v)).nil?)
+				output[k] = v
+			end
+		}
+		if (output.length > 0)
+			return output
+		else
+			return nil
+		end
+	end
+end
+
+class Set
+	def from_user_input(value)
+		each {|i|
+			val = i.from_user_input(value)
+			return val if val
+		}
+		return nil
+	end
+end
+
+class Symbol
+	def Symbol.from_user_input(value)
+		raise ArgumentError, "You should never arbitrarily turn user input into symbols. It can cause leaks that could lead to DoS."
+	end
+
+	# instance form does a straight comparison of value.to_sym with self.
+	def from_user_input(value)
+		if (self.to_s == value.to_s)
+			return self
+		else
+			return nil
+		end
+	end
+end
+
+class IPAddr
+	def IPAddr.from_user_input(value)
+		if (value.kind_of?(self))
+			return value
+		end
+		begin
+			return self.new(value.to_s)
+		rescue ArgumentError
+			return nil
+		end
+	end
+end
+
+class Class
+	def from_user_input(value)
+		if (value.kind_of?(Class) && value <= self)
+			return value
+		elsif (value.kind_of?(self))
+			return value
+		end
+		return nil
+	end
+end
+
+class Object
+	def from_user_input(value)
+		if (value == self)
+			return value
+		end
+		return nil
+	end
+end

data/spec/option_parser_spec.rb

@@ -0,0 +1,158 @@
+require File.expand_path(File.dirname(__FILE__) + '/spec_helper')
+require 'lib/user_input/option_parser'
+
+describe UserInput::OptionParser do
+	IOptionParser = UserInput::OptionParser
+	
+	it "Should optionally take an argument for program prefix, setting it to $0 if none set" do
+		IOptionParser.new().program_prefix.should == $0
+		IOptionParser.new("blah").program_prefix.should == "blah"
+	end
+	
+	it "Should let you set the program prefix after initialization" do
+		opt = IOptionParser.new
+		opt.program_prefix.should == $0
+		opt.program_prefix = "blah"
+		opt.program_prefix.should == "blah"
+	end
+	
+	it "Should generate a default banner if none specified" do
+		IOptionParser.new().banner.should be_kind_of(String)
+	end
+	it "Should let you set the banner" do
+		opt = IOptionParser.new
+		opt.banner = "blah"
+		opt.banner.should == "blah"
+	end
+	
+	it "Should yield the object for use if a block is given to the constructor" do
+		IOptionParser.new("boom") {|p|
+			p.should be_kind_of(IOptionParser)
+			p.program_prefix.should == "boom"
+		}
+	end
+	
+	it "Should not allow multicharacter short options or single character long options" do
+		IOptionParser.new {|p|
+			proc { p.flag "boom", "boom", "what?" }.should raise_error(ArgumentError)
+			proc { p.flag "a", "a", "what?" }.should raise_error(ArgumentError)
+		}
+	end
+	
+	before :each do
+		@opt = IOptionParser.new("testing")
+		@opt.flag "a", "abba", "stuff goes here"
+		@opt.flag "b", "boom", "this one goes boom" do raise "BOOM" end
+		@opt.argument "c", "cool", "this one is awesome", "whatever"
+		@opt.gap
+		@opt.argument "d", "dumb", "this one is dumb. It wants nothing but an integer.", 5, Integer
+		@opt.argument "e", "everything", "this one's really clever, it's always 'everything'", "what?" do "everything" end
+		@opt.argument "f", "fugged-aboudit", "this one has a hyphen, which makes it scary", "stuff"
+	end
+	
+	it "Should have defined the right methods" do
+		[:abba?, :boom?, :cool, :dumb, :everything, :fugged_aboudit].each {|i|
+			@opt.respond_to?(i).should be_true
+		}
+	end
+	
+	it "Should set the correct defaults" do
+		@opt.abba?.should be_false
+		@opt.boom?.should be_false
+		@opt.cool.should == "whatever"
+		@opt.dumb.should == 5
+		@opt.everything.should == "what?"
+		@opt.fugged_aboudit.should == "stuff"
+	end
+	
+	it "Should return itself from both parse and parse!" do
+		@opt.parse(["-a"]).should == @opt
+		@opt.parse!(["-a"]).should == @opt
+	end
+
+	it "Should parse a simple short flag" do
+		@opt.parse(["-a"])
+		@opt.abba?.should be_true
+	end
+	
+	it "Should parse a simple long flag" do
+		@opt.parse(["--abba"])
+		@opt.abba?.should be_true
+	end
+	
+	it "Should raise an error if we try to set the exploding flag" do
+		proc { @opt.parse(["-b"]) }.should raise_error("BOOM")
+	end
+	
+	it "Should raise if an argument isn't supplied to a normal argument" do
+		proc { @opt.parse(["-c"]) }.should raise_error(ArgumentError)
+	end
+	
+	it "Should parse a simple argument with properly specified" do
+		@opt.parse(["-c", "stuff"])
+		@opt.cool.should == "stuff"
+	end
+	
+	it "Should parse a simple argument in its long form properly specified" do
+		@opt.parse(["--cool", "stuff"])
+		@opt.cool.should == "stuff"
+	end
+
+	it "Should deal with a hyphen in the command line argument" do
+		@opt.parse(["--fugged-aboudit", "boom"])
+		@opt.fugged_aboudit.should == "boom"
+	end
+	
+	it "should parse a flag and an argument separately" do
+		@opt.parse(["-a", "-c", "stuff"])
+		@opt.abba?.should be_true
+		@opt.cool.should == "stuff"
+	end
+	
+	it "Should validate input using from_user_input" do
+		proc { @opt.parse(["-d", "whatever"]) }.should raise_error(ArgumentError)
+		@opt.dumb.should == 5
+		@opt.parse(["-d", "99"])
+		@opt.dumb.should == 99
+	end
+	
+	it "Should validate input using a proc object" do
+		@opt.parse(["-e", "stufffff"])
+		@opt.everything.should == "everything"
+	end
+	
+	it "should parse correctly if you specify multiple arguments in a group" do
+		@opt.parse(["-acd", "what", "1"])
+		@opt.abba?.should be_true
+		@opt.cool.should == "what"
+		@opt.dumb.should == 1
+	end
+	
+	it "Should raise an error if you supply a flag or argument it doesn't understand" do
+		proc { @opt.parse(["-z"]) }.should raise_error(ArgumentError)
+		proc { @opt.parse(["--zoom"]) }.should raise_error(ArgumentError)
+	end
+
+	it "should parse destructively if you use parse!" do
+		arr = ["-a"]
+		@opt.parse!(arr)
+		arr.should == []
+	end
+	
+	it "should stop parsing on finding a non-flag word unexpectedly and return the remainder" do
+		arr = ["-a", "boom", "whatever"]
+		@opt.parse!(arr)
+		arr.should == ["boom", "whatever"]
+	end
+	
+	it "should stop parsing on finding --, but should still consume it" do
+		arr = ["-a", "--", "whatever"]
+		@opt.parse!(arr)
+		arr.should == ["whatever"]
+	end
+	
+	it "should return a string from to_s" do
+		# Possibly this spec should include an example to compare against, but that seems too rigid.
+		@opt.to_s.should be_kind_of(String)
+	end
+end

data/spec/spec.opts

@@ -0,0 +1 @@
+--color

data/spec/spec_helper.rb

@@ -0,0 +1,9 @@
+$LOAD_PATH.unshift(File.dirname(__FILE__))
+$LOAD_PATH.unshift(File.join(File.dirname(__FILE__), '..', 'lib'))
+require 'user_input'
+require 'spec'
+require 'spec/autorun'
+
+Spec::Runner.configure do |config|
+  
+end

data/spec/type_safe_hash_spec.rb

@@ -0,0 +1,123 @@
+require File.expand_path(File.dirname(__FILE__) + '/spec_helper')
+require 'lib/user_input/type_safe_hash'
+
+describe UserInput::TypeSafeHash do
+	TypeSafeHash = UserInput::TypeSafeHash
+	
+	describe "initializer" do
+		it "should take a normal hash as an argument" do
+			TypeSafeHash.new(:a => :b).should == TypeSafeHash.new(:a => :b)
+		end
+		it "should take another type safe hash as an argument" do
+			TypeSafeHash.new(TypeSafeHash.new(:a => :b)).should == TypeSafeHash.new(:a => :b)
+		end
+		it "should raise an error for anything else" do
+			proc {
+				TypeSafeHash.new("boom")
+			}.should raise_error(ArgumentError)
+		end
+	end
+	
+	before :each do 
+		@hash = TypeSafeHash.new("blah" => "blorp", 1 => 2, 3 => [1, 2, 3])
+		@str_hash = TypeSafeHash.new("blah" => "waht", "woop" => "wonk", "woo" => "fluh")
+	end
+	
+	it "should properly implement to_hash to return the original hash object" do
+		@hash.to_hash.should be_kind_of(Hash)
+	end
+	
+	it "should compare to another TypeSafeHash as equal if they have the same real hash" do
+		(@hash == TypeSafeHash.new(@hash.to_hash)).should be_true
+		(@hash == TypeSafeHash.new()).should be_false
+	end
+	it "should compare to any other object as not equal" do
+		(@hash == Hash.new).should be_false
+	end
+	
+	describe "fetch" do
+		it "should validate as user input any requests for keys" do
+			@hash.fetch("blah", String).should == "blorp"
+			@hash.fetch("blah", /orp/)[0].should == "blorp".match(/orp/)[0]
+			@hash.fetch("blah", Integer).should be_nil
+			
+			@hash.fetch(1, Integer).should == 2
+			@hash.fetch(1, 2).should == 2
+			@hash.fetch(1, 3).should be_nil
+			
+			@hash.fetch(3, [Integer]).should == [1,2,3]
+		end
+		
+		it "should flatten an array value to a single value if the requested type is not an array" do
+			@hash.fetch(3, Integer).should == 1
+		end
+		
+		it "should take a default value for failed matching" do
+			@hash.fetch("blah", /woople/, "woople").should == "woople"
+		end
+		
+		it "should be aliased to the [] method" do
+			@hash["blah", String].should == "blorp"
+		end
+	end
+	
+	it "should properly implement each_key" do
+		keys = []
+		@hash.each_key {|x| keys.push(x)}
+		keys == @hash.to_hash.keys
+	end
+	
+	it "should properly implement each_pair" do
+		out = {}
+		@str_hash.each_pair(String) {|key, val| out[key]=val}
+		out.should == @str_hash.to_hash
+	end
+	
+	it "should properly implement each_match, returning only keys that match the regex" do
+		out = []
+		@str_hash.each_match(/woo/, String) {|match, val| out.push([match[0],val]) }
+		out.sort.should == [["woo", "fluh"], ["woo", "wonk"]].sort
+	end
+	
+	it "empty? should return true for an empty hash and false for one with values" do
+		@hash.empty?.should == false
+		TypeSafeHash.new.empty?.should == true
+	end
+	
+	it "should implement has_key? and all of its aliases (include?, key?, member?)" do
+		@hash.has_key?(3).should be_true
+		@hash.has_key?(4).should be_false
+		@hash.include?(3).should be_true
+		@hash.include?(4).should be_false
+		@hash.key?(3).should be_true
+		@hash.key?(4).should be_false
+		@hash.member?(3).should be_true
+		@hash.member?(4).should be_false
+	end
+	
+	it "should implement inspect as an alias to its real hash's inspect" do
+		@hash.inspect.should == @hash.to_hash.inspect
+	end
+	
+	it "should implement keys as returning the real hash's keys, both sorted and unsorted" do
+		@str_hash.keys.should == @str_hash.to_hash.keys
+		@str_hash.keys(true).should == @str_hash.to_hash.keys.sort
+	end
+	
+	it "should implement values as returning the values from the real hash" do
+		@hash.values.should == @hash.to_hash.values
+	end
+	
+	it "should return the number of items in the hash from length" do
+		@hash.length.should == @hash.to_hash.length
+	end
+	
+	it "should implement to_s as returning the internal hash's string representation" do
+		@hash.to_s.should == @hash.to_hash.to_s
+	end
+	
+	it "should implement TypeSafeHash.from_user_input as accepting only a hash" do
+		TypeSafeHash.from_user_input({}).should == TypeSafeHash.new({})
+		TypeSafeHash.from_user_input("Blah").should be_nil
+	end
+end