hosemonkey 0.1.0

data/.gitignore

@@ -0,0 +1,4 @@
+*.gem
+.bundle
+Gemfile.lock
+pkg/*

data/Gemfile

@@ -0,0 +1,4 @@
+source "http://rubygems.org"
+
+# Specify your gem's dependencies in hosemonkey.gemspec
+gemspec

data/Rakefile

@@ -0,0 +1,10 @@
+require 'rspec/core/rake_task'
+require "bundler/gem_tasks"
+
+task :default => :spec
+
+desc "Run all specs"
+RSpec::Core::RakeTask.new(:spec) do |t|
+  t.rspec_opts = %w{--colour --format progress}
+  t.pattern = 'spec/*_spec.rb'
+end

data/hosemonkey.gemspec

@@ -0,0 +1,27 @@
+# -*- encoding: utf-8 -*-
+$:.push File.expand_path("../lib", __FILE__)
+require "hosemonkey/version"
+
+Gem::Specification.new do |s|
+  s.name        = "hosemonkey"
+  s.version     = Hosemonkey::VERSION
+  s.authors     = ["Rob Lyon"]
+  s.email       = ["rlyon@uidaho.edu"]
+  s.homepage    = ""
+  s.summary     = %q{Write a gem summary}
+  s.description = %q{Write a gem description}
+
+  s.rubyforge_project = "hosemonkey"
+
+  s.files         = `git ls-files`.split("\n")
+  s.test_files    = `git ls-files -- {test,spec,features}/*`.split("\n")
+  s.executables   = `git ls-files -- bin/*`.split("\n").map{ |f| File.basename(f) }
+  s.require_paths = ["lib"]
+
+  # specify any dependencies here; for example:
+  s.add_development_dependency "rake"
+  s.add_development_dependency "rspec" 
+  s.add_development_dependency "mocha"
+
+  s.add_runtime_dependency "nokogiri" 
+end

data/lib/hosemonkey.rb

@@ -0,0 +1,10 @@
+require "nokogiri"
+require "hosemonkey/version"
+
+module Hosemonkey
+  
+end
+
+Dir[File.join('./lib/hosemonkey/ext', '*.rb')].each do |ext|
+  require ext
+end

data/lib/hosemonkey/ext/array.rb

@@ -0,0 +1,6 @@
+class Array
+  # From rails active_support
+  def extract_options!
+    last.is_a?(::Hash) ? pop : {}
+  end
+end

data/lib/hosemonkey/ext/boolean.rb

@@ -0,0 +1,17 @@
+module Hosemonkey
+  module Boolean
+    Mapping = {
+      true    => true,
+      'true'  => true,
+      '1'     => true, 
+      1       => true, 
+      false   => false, 
+      'false' => false,
+      '0'     => false,
+      0       => false, 
+      nil     => nil
+    }
+  end
+end
+
+class Boolean ; include Hosemonkey::Boolean ; end

data/lib/hosemonkey/ext/date.rb

@@ -0,0 +1,21 @@
+class Date
+  # From active support
+  def advance(options)
+    options = options.dup
+    d = self
+    d = d >> options.delete(:years) * 12 if options[:years]
+    d = d >> options.delete(:months)     if options[:months]
+    d = d +  options.delete(:weeks) * 7  if options[:weeks]
+    d = d +  options.delete(:days)       if options[:days]
+    d
+  end
+  
+  # From active support
+  def change(options)
+    ::Date.new(
+      options[:year]  || self.year,
+      options[:month] || self.month,
+      options[:day]   || self.day
+    )
+  end
+end

data/lib/hosemonkey/ext/fixnum.rb

@@ -0,0 +1,25 @@
+module Hosemonkey
+  module Fixnum
+    def days
+      ::Time.now + (60 * 60 * 24 * self)
+    end
+    
+    def hours
+      ::Time.now + (60 * 60 * self)
+    end
+    
+    def weeks
+      ::Time.now + (60 * 60 * 24 * 7 * self)
+    end
+    
+    def months
+      ::Time.now.advance(:months => self)
+    end
+    
+    def years
+      ::Time.now.advance(:years => self)
+    end
+  end
+end
+
+class Fixnum ; include Hosemonkey::Fixnum ; end

data/lib/hosemonkey/ext/hash.rb

@@ -0,0 +1,97 @@
+class Hash
+  def stringify_keys
+    keys.each do |key|
+      self[(key.to_s rescue key) || key] = delete(key)
+    end
+    self
+  end
+  
+  # From rails active_support.  Destructively convert all keys to symbols as long as they respond to to_sym
+  def symbolize_keys!
+    keys.each do |key|
+      self[(key.to_sym rescue key) || key] = delete(key)
+    end
+    self
+  end
+  
+  # From rails active_support.  Return a new hash with all keys converted to symbols
+  def symbolize_keys
+    dup.symbolize_keys!
+  end
+  
+  def include_only?(*args)
+    self.each do |key,value|
+      unless args.include?(key)
+        return false
+      end
+    end
+    return true
+  end
+  
+  def include_only(*args)
+    self.each do |key,value|
+      unless args.include?(key)
+        raise "Unknown Argument"
+      end
+    end
+  end
+  
+  class << self
+    # https://gist.github.com/819999
+    def from_xml_string(xml)
+      begin
+        result = Nokogiri::XML(xml) do |config|
+          config.strict.noent
+        end
+        return { result.root.name => xml_node_to_hash(result.root)}
+      rescue Exception => e
+        raise "Could not parse xml: #{e}"
+      end
+    end
+    
+    # https://gist.github.com/819999
+    def xml_node_to_hash(node)
+      # If we are at the root of the document, start the hash 
+      if node.element?
+        result_hash = {}
+        if node.attributes != {}
+          attributes = {}
+          node.attributes.keys.each do |key|
+            attributes[node.attributes[key].name] = node.attributes[key].value
+          end
+        end
+        if node.children.size > 0
+          node.children.each do |child|
+            result = xml_node_to_hash(child)
+
+            if child.name == "text"
+              unless child.next_sibling || child.previous_sibling
+                return result unless attributes
+                result_hash[child.name] = result
+              end
+            elsif result_hash[child.name]
+
+              if result_hash[child.name].is_a?(Object::Array)
+                 result_hash[child.name] << result
+              else
+                 result_hash[child.name] = [result_hash[child.name]] << result
+              end
+            else
+              result_hash[child.name] = result
+            end
+          end
+          if attributes
+             #add code to remove non-data attributes e.g. xml schema, namespace here
+             #if there is a collision then node content supersets attributes
+             result_hash = attributes.merge(result_hash)
+          end
+          return result_hash
+        else
+          return attributes
+        end
+      else
+        return node.content.to_s
+      end
+    end
+  end
+end

data/lib/hosemonkey/ext/string.rb

@@ -0,0 +1,61 @@
+class String
+  # def uncamelize
+  #   uncameled = self.each_char.inject("") do |result,c|
+  #     unless "#{c}" =~ /^[A-Z]$/
+  #       result << "#{c}"
+  #     else
+  #       result << "_" unless result.empty?
+  #       result << "#{c}".downcase
+  #     end
+  #   end
+  #   uncameled
+  # end
+
+  def camelize
+    cap_next_char = true
+    cameled = self.each_char.inject("") do |result, c|
+      unless "#{c}" =~ /^[-_]$/
+        unless cap_next_char
+          result << "#{c}"
+        else
+          result << "#{c}".upcase
+          cap_next_char = false
+        end
+      else
+        cap_next_char = true
+      end
+      result
+    end
+  end
+  
+  class << self
+    def hex(args = { :length => 24, :case => :upper })
+      unless args.include_only?( :length, :case )
+        raise "Invalid parameters in random"
+      end
+      
+      h = (((0..args[:length]).map{rand(256).chr}*"").unpack("H*")[0][0,args[:length]])
+      
+      if args[:case] == :lower
+        h.downcase
+      else
+        h.upcase
+      end
+    end
+    
+    def random(args = { :length => 24, :charset => :all })
+      unless args.include_only?( :length, :charset )
+        raise "Invalid parameters in random"
+      end 
+
+      if args[:charset] == :alpha
+        chars = ('a'..'z').to_a + ('A'..'Z').to_a
+      elsif args[:charset] == :alnum_upper
+        chars = ('A'..'Z').to_a + ('0'..'9').to_a
+      else
+        chars = ('a'..'z').to_a + ('A'..'Z').to_a + ('0'..'9').to_a
+      end
+      (0...args[:length]).collect { chars[Kernel.rand(chars.length)] }.join  
+    end
+  end  
+end

data/lib/hosemonkey/ext/time.rb

@@ -0,0 +1,119 @@
+module Hosemonkey
+  module Time
+    # Copied directly from ActiveSupport
+    COMMON_YEAR_DAYS_IN_MONTH = [nil, 31, 28, 31, 30, 31, 30, 31, 31, 30, 31, 30, 31]
+    # Copied directly from ActiveSupport
+    DAYS_INTO_WEEK = {
+      :monday    => 0,
+      :tuesday   => 1,
+      :wednesday => 2,
+      :thursday  => 3,
+      :friday    => 4,
+      :saturday  => 5,
+      :sunday    => 6
+    }
+
+    # Copied directly from ActiveSupport
+    # Return the number of days in the given month.
+    # If no year is specified, it will use the current year.
+    def days_in_month(month, year = now.year)
+      if month == 2 && ::Date.gregorian_leap?(year)
+        29
+      else
+        COMMON_YEAR_DAYS_IN_MONTH[month]
+      end
+    end
+
+    # Copied directly from ActiveSupport
+    # Uses Date to provide precise Time calculations for years, months, and days.
+    # The +options+ parameter takes a hash with any of these keys: <tt>:years</tt>,
+    # <tt>:months</tt>, <tt>:weeks</tt>, <tt>:days</tt>, <tt>:hours</tt>,
+    # <tt>:minutes</tt>, <tt>:seconds</tt>.
+    def advance(options)
+      unless options[:weeks].nil?
+        options[:weeks], partial_weeks = options[:weeks].divmod(1)
+        options[:days] = options.fetch(:days, 0) + 7 * partial_weeks
+      end
+
+      unless options[:days].nil?
+        options[:days], partial_days = options[:days].divmod(1)
+        options[:hours] = options.fetch(:hours, 0) + 24 * partial_days
+      end
+
+      d = to_date.advance(options)
+      time_advanced_by_date = change(:year => d.year, :month => d.month, :day => d.day)
+      seconds_to_advance = \
+        options.fetch(:seconds, 0) +
+        options.fetch(:minutes, 0) * 60 +
+        options.fetch(:hours, 0) * 3600
+
+      if seconds_to_advance.zero?
+        time_advanced_by_date
+      else
+        time_advanced_by_date.since(seconds_to_advance)
+      end
+    end
+
+    # Copied directly from ActiveSupport
+    # Returns a new Time where one or more of the elements have been changed according to the +options+ parameter. The time options
+    # (hour, min, sec, usec) reset cascadingly, so if only the hour is passed, then minute, sec, and usec is set to 0. If the hour and
+    # minute is passed, then sec and usec is set to 0.
+    def change(options)
+      ::Time.send(
+        utc? ? :utc_time : :local_time,
+        options.fetch(:year, year),
+        options.fetch(:month, month),
+        options.fetch(:day, day),
+        options.fetch(:hour, hour),
+        options.fetch(:min, options[:hour] ? 0 : min),
+        options.fetch(:sec, (options[:hour] || options[:min]) ? 0 : sec),
+        options.fetch(:usec, (options[:hour] || options[:min] || options[:sec]) ? 0 : Rational(nsec, 1000))
+      )
+    end
+
+    def to_z
+      self.gmtime.strftime("%Y-%m-%dT%H:%M:%S.000Z")
+    end
+    
+    def to_web
+      self.gmtime.strftime("%a, %d %b %Y %H:%M:%S %z")
+    end
+    
+    def to_short
+      self.gmtime.strftime("%Y%m")
+    end
+  end
+end
+
+
+class Time
+  include Hosemonkey::Time
+  class << self
+    # Copied directly from ActiveSupport
+    # Wraps class method +time_with_datetime_fallback+ with +utc_or_local+ set to <tt>:utc</tt>.
+    def utc_time(*args)
+      time_with_datetime_fallback(:utc, *args)
+    end
+
+    # Wraps class method +time_with_datetime_fallback+ with +utc_or_local+ set to <tt>:local</tt>.
+    def local_time(*args)
+      time_with_datetime_fallback(:local, *args)
+    end
+    # Copied directly from ActiveSupport
+    # Returns a new Time if requested year can be accommodated by Ruby's Time class
+    # (i.e., if year is within either 1970..2038 or 1902..2038, depending on system architecture);
+    # otherwise returns a DateTime.
+    def time_with_datetime_fallback(utc_or_local, year, month=1, day=1, hour=0, min=0, sec=0, usec=0)
+      time = ::Time.send(utc_or_local, year, month, day, hour, min, sec, usec)
+
+      # This check is needed because Time.utc(y) returns a time object in the 2000s for 0 <= y <= 138.
+      if time.year == year
+        time
+      else
+        ::DateTime.civil_from_format(utc_or_local, year, month, day, hour, min, sec)
+      end
+    rescue
+      ::DateTime.civil_from_format(utc_or_local, year, month, day, hour, min, sec)
+    end
+  end
+end

data/lib/hosemonkey/version.rb

@@ -0,0 +1,3 @@
+module Hosemonkey
+  VERSION = "0.1.0"
+end

data/spec/fixnum_spec.rb

@@ -0,0 +1,28 @@
+require File.dirname(__FILE__) + '/spec_helper'
+
+describe "Fixnum monkey: " do
+  it "days should return n number of days in the future" do
+    Time.stubs(:now).returns(Time.mktime(1970,1,1,0,0,0))
+    10.days.should == Time.mktime(1970,1,11,0,0,0)
+  end
+  
+  it "hours should return n number of hours in the future" do
+    Time.stubs(:now).returns(Time.mktime(1970,1,1,0,0,0))
+    10.hours.should == Time.mktime(1970,1,1,10,0,0)
+  end
+  
+  it "weeks should return n number of weeks in the future" do
+    Time.stubs(:now).returns(Time.mktime(1970,1,1,0,0,0))
+    2.weeks.should == Time.mktime(1970,1,15,0,0,0)
+  end
+  
+  it "months should return n number of months in the future" do
+    Time.stubs(:now).returns(Time.mktime(1970,1,1,0,0,0))
+    15.months.should == Time.mktime(1971,4,1,0,0,0)
+  end
+  
+  it "years should return n number of years in the future" do
+    Time.stubs(:now).returns(Time.mktime(1970,1,1,0,0,0))
+    15.years.should == Time.mktime(1985,1,1,0,0,0)
+  end
+end

data/spec/hash_spec.rb

@@ -0,0 +1,75 @@
+require File.dirname(__FILE__) + '/spec_helper'
+
+describe "Hash monkey: include_only?" do
+  it "should return true if only the provided keys are found in the hash" do
+    h = {:a => 0, :b => 1, :c => 2}
+    {}.include_only?(:a).should be_true
+    h.include_only?(:a).should be_false
+    h.include_only?(:a, :b).should be_false
+    h.include_only?(:a, :b, :c).should be_true
+    h.include_only?(:a, :b, :c, :d).should be_true
+  end
+end
+
+
+describe "Hash monkey: stringify keys" do
+  it "should turn symbols into key" do
+    h = {:a => 0, :b => 1, :c => 2}
+    h.stringify_keys
+    h.keys.size.should == 3
+    h.has_key?(:a).should be_false
+    h.has_key?(:b).should be_false
+    h.has_key?(:c).should be_false
+    h.has_key?('a').should be_true
+    h.has_key?('b').should be_true
+    h.has_key?('c').should be_true
+  end
+end
+
+describe "Hash monkey: include_only" do
+  it "shouldn't raise exception if only the provided keys are found in the hash" do
+    h = {:a => 0, :b => 1, :c => 3}
+    expect { {}.include_only(:a) }.to_not raise_error
+    expect { h.include_only(:a) }.to raise_error
+    expect { h.include_only(:a, :b) }.to raise_error
+    expect { h.include_only(:a, :b, :c) }.to_not raise_error
+    expect { h.include_only(:a, :b, :c, :d) }.to_not raise_error
+  end
+end
+
+describe "Hash monkey: from_xml_string" do
+  it "should create a hash of symbol => values" do
+    xml = "<Error><Code>Hello</Code><Message>World</Message><MyDate>Now</MyDate></Error>"
+    h = Hash.from_xml_string(xml)
+    h.has_key?('Error').should be_true
+    error = h['Error']
+    error.has_key?('Code').should be_true
+    error['Code'].should == "Hello"
+    error.has_key?('Message').should be_true
+    error['Message'].should == "World"
+    error.has_key?('MyDate').should be_true
+    error['MyDate'].should == "Now"
+  end
+  
+  it "should raise exception on invalid xml" do
+    xml = "<Error><Code>Hello</Code><Message>World</Message><MyDate>Now</BADTAG></Error>"
+    expect { h = Hash.from_xml_string(xml) ; puts h.inspect }.to raise_error
+  end
+  
+  it "should parse attributes" do
+    xml = "<Tag attr=\"hello world\">Hello</Tag>"
+    h = Hash.from_xml_string(xml)
+    tag = h['Tag']
+    tag.has_key?('attr')
+    tag['attr'].should == "hello world"
+    tag['text'].should == "Hello"
+  end
+  
+  it "should handle multiple nested entries correctly" do
+    xml = "<List><Item><Name>one</Name><Type>this</Type></Item><Item><Name>two</Name><Type>this</Type></Item><Item><Name>three</Name><Type>this</Type></Item></List>"
+    h = Hash.from_xml_string(xml)
+    list = h['List']
+    list.has_key?('Item').should be_true
+    list['Item'].length.should == 3
+  end
+end

data/spec/spec_helper.rb

@@ -0,0 +1,7 @@
+require 'rubygems'
+require 'bundler/setup'
+require 'hosemonkey'
+
+RSpec.configure do |config|
+  config.mock_with :mocha
+end

data/spec/string_spec.rb

@@ -0,0 +1,44 @@
+require File.dirname(__FILE__) + '/spec_helper'
+
+describe "String monkey: hex" do
+  it "shouldn't accept shitty args" do
+    expect { String.hex(:length => 100, :case => :upper, :bad => 'yep') }.to raise_error
+  end
+  
+  it "should return an upper case hex string" do
+    s = String.hex(:length => 100, :case => :upper)
+    (s =~ /^[abcdef0-9]+$/).should be_nil
+    (s =~ /^[ABCDEF0-9]+$/).should >= 0
+  end
+  
+  it "should return a lower case hex string" do
+    s = String.hex(:length => 100, :case => :lower)
+    (s =~ /^[abcdef0-9]+$/).should >= 0
+    (s =~ /^[ABCDEF0-9]+$/).should be_nil
+  end
+end
+
+describe "String monkey: random" do
+  it "should return an exception if an invalid option is passed" do
+    expect { String.random(:length => 100, :bad => 'yep') }.to raise_error
+  end
+  
+  it "should return a alpha only string" do
+    s = String.random(:length => 100, :charset => :alpha)
+    (s =~ /^[a-zA-Z]+$/).should >= 0
+    (s =~ /^[0-9]+$/).should be_nil
+  end
+  
+  it "should return a uppercase alphanumeric only string" do
+    s = String.random(:length => 100, :charset => :alnum_upper)
+    (s =~ /^[0-9A-Z]+$/).should >= 0
+    (s =~ /^[a-z]+$/).should be_nil
+  end
+end
+
+describe "String monkey: camalize" do
+  it "should camelize a string" do
+    c = "hello_world"
+    c.camelize.should == "HelloWorld"
+  end
+end

data/spec/time_spec.rb

@@ -0,0 +1,21 @@
+require File.dirname(__FILE__) + '/spec_helper'
+
+describe "Time monkey: " do
+  it "to_z should return the correct value" do
+    # Converts to gmt
+    Time.stubs(:now).returns(Time.mktime(1970,1,1,0,0,0))
+    Time.now.to_z.should == "1970-01-01T08:00:00.000Z"
+  end
+  
+  it "to_web should return the correct value" do
+    # Converts to gmt
+    Time.stubs(:now).returns(Time.mktime(1970,1,1,0,0,0))
+    Time.now.to_web.should == "Thu, 01 Jan 1970 08:00:00 +0000"
+  end
+  
+  it "to_yearmonth should return the correct value" do
+    # Converts to gmt
+    Time.stubs(:now).returns(Time.mktime(1970,1,1,0,0,0))
+    Time.now.to_short.should == "197001"
+  end
+end

metadata

@@ -0,0 +1,133 @@
+--- !ruby/object:Gem::Specification
+name: hosemonkey
+version: !ruby/object:Gem::Version
+  version: 0.1.0
+  prerelease: 
+platform: ruby
+authors:
+- Rob Lyon
+autorequire: 
+bindir: bin
+cert_chain: []
+date: 2012-07-01 00:00:00.000000000 Z
+dependencies:
+- !ruby/object:Gem::Dependency
+  name: rake
+  requirement: !ruby/object:Gem::Requirement
+    none: false
+    requirements:
+    - - ! '>='
+      - !ruby/object:Gem::Version
+        version: '0'
+  type: :development
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    none: false
+    requirements:
+    - - ! '>='
+      - !ruby/object:Gem::Version
+        version: '0'
+- !ruby/object:Gem::Dependency
+  name: rspec
+  requirement: !ruby/object:Gem::Requirement
+    none: false
+    requirements:
+    - - ! '>='
+      - !ruby/object:Gem::Version
+        version: '0'
+  type: :development
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    none: false
+    requirements:
+    - - ! '>='
+      - !ruby/object:Gem::Version
+        version: '0'
+- !ruby/object:Gem::Dependency
+  name: mocha
+  requirement: !ruby/object:Gem::Requirement
+    none: false
+    requirements:
+    - - ! '>='
+      - !ruby/object:Gem::Version
+        version: '0'
+  type: :development
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    none: false
+    requirements:
+    - - ! '>='
+      - !ruby/object:Gem::Version
+        version: '0'
+- !ruby/object:Gem::Dependency
+  name: nokogiri
+  requirement: !ruby/object:Gem::Requirement
+    none: false
+    requirements:
+    - - ! '>='
+      - !ruby/object:Gem::Version
+        version: '0'
+  type: :runtime
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    none: false
+    requirements:
+    - - ! '>='
+      - !ruby/object:Gem::Version
+        version: '0'
+description: Write a gem description
+email:
+- rlyon@uidaho.edu
+executables: []
+extensions: []
+extra_rdoc_files: []
+files:
+- .gitignore
+- Gemfile
+- README
+- Rakefile
+- hosemonkey.gemspec
+- lib/hosemonkey.rb
+- lib/hosemonkey/ext/array.rb
+- lib/hosemonkey/ext/boolean.rb
+- lib/hosemonkey/ext/date.rb
+- lib/hosemonkey/ext/fixnum.rb
+- lib/hosemonkey/ext/hash.rb
+- lib/hosemonkey/ext/string.rb
+- lib/hosemonkey/ext/time.rb
+- lib/hosemonkey/version.rb
+- spec/fixnum_spec.rb
+- spec/hash_spec.rb
+- spec/spec_helper.rb
+- spec/string_spec.rb
+- spec/time_spec.rb
+homepage: ''
+licenses: []
+post_install_message: 
+rdoc_options: []
+require_paths:
+- lib
+required_ruby_version: !ruby/object:Gem::Requirement
+  none: false
+  requirements:
+  - - ! '>='
+    - !ruby/object:Gem::Version
+      version: '0'
+required_rubygems_version: !ruby/object:Gem::Requirement
+  none: false
+  requirements:
+  - - ! '>='
+    - !ruby/object:Gem::Version
+      version: '0'
+requirements: []
+rubyforge_project: hosemonkey
+rubygems_version: 1.8.20
+signing_key: 
+specification_version: 3
+summary: Write a gem summary
+test_files:
+- spec/fixnum_spec.rb
+- spec/hash_spec.rb
+- spec/spec_helper.rb
+- spec/string_spec.rb
+- spec/time_spec.rb