kelredd-useful 0.1.0

data/README.rdoc

@@ -0,0 +1,44 @@
+= Useful
+
+== Description
+
+A collection of useful helpers for various ruby things.  Includes
+helpers for sinatra, ruby base classes, mysql, rails, erb, etc...
+
+You probably never want them all, all the time, but just require in
+the pieces you are interested in.
+
+== Installation
+
+    sudo gem install kelredd-useful --source http://gems.github.com
+
+== Usage
+
+    require 'rubygems'
+    require 'useful/sinatra_helpers'
+    require 'useful/mysql_helpers'
+
+== License
+
+Copyright (c) 2009 Kelly Redding
+
+Permission is hereby granted, free of charge, to any person
+obtaining a copy of this software and associated documentation
+files (the "Software"), to deal in the Software without
+restriction, including without limitation the rights to use,
+copy, modify, merge, publish, distribute, sublicense, and/or sell
+copies of the Software, and to permit persons to whom the
+Software is furnished to do so, subject to the following
+conditions:
+
+The above copyright notice and this permission notice shall be
+included in all copies or substantial portions of the Software.
+
+THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND,
+EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES
+OF MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND
+NONINFRINGEMENT. IN NO EVENT SHALL THE AUTHORS OR COPYRIGHT
+HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER LIABILITY,
+WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING
+FROM, OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR
+OTHER DEALINGS IN THE SOFTWARE.

data/Rakefile

@@ -0,0 +1,40 @@
+require 'rubygems'
+require 'rake/gempackagetask'
+require 'rake/testtask'
+
+require 'lib/useful/version'
+
+task :default => :test
+
+spec = Gem::Specification.new do |s|
+  s.name             = 'useful'
+  s.version          = Useful::Version.to_s
+  s.has_rdoc         = true
+  s.extra_rdoc_files = %w(README.rdoc)
+  s.rdoc_options     = %w(--main README.rdoc)
+  s.summary          = "A collection of useful helpers for various ruby things."
+  s.author           = 'Kelredd'
+  s.email            = ''
+  s.homepage         = ''
+  s.files            = %w(README.rdoc Rakefile) + Dir.glob("{lib,test}/**/*")
+  # s.executables    = ['useful']
+  
+  # s.add_dependency('gem_name', '~> 0.0.1')
+end
+
+Rake::GemPackageTask.new(spec) do |pkg|
+  pkg.gem_spec = spec
+end
+
+Rake::TestTask.new do |t|
+  t.libs << 'test'
+  t.test_files = FileList["test/**/*_test.rb"]
+  t.verbose = true
+end
+
+desc 'Generate the gemspec to serve this Gem from Github'
+task :github do
+  file = File.dirname(__FILE__) + "/#{spec.name}.gemspec"
+  File.open(file, 'w') {|f| f << spec.to_ruby }
+  puts "Created gemspec: #{file}"
+end

data/lib/useful/ruby_extensions/array.rb

@@ -0,0 +1,45 @@
+module Useful
+  module RubyExtensions
+    module Array
+      
+      module ClassMethods; end
+      def self.included(klass)
+        klass.extend(ClassMethods) if klass.kind_of?(Class)
+      end
+
+      module ClassMethods
+
+        # adds the contents of a2 to a1, removing duplicates
+        def merge(a1,a2)
+          a2.each{|item| a1 << item unless a1.include?(item)}
+          a1
+        end
+        
+      end
+
+      # returns a new array, containing the contents of an_a with the contents of this array, removing duplicates
+      def merge(an_a)
+        self.class.merge(self.clone, an_a)
+      end
+      # adds the contents of an_a to this array, removing duplicates (inline version of #merge)
+      def merge!(an_a)
+        self.class.merge(self, an_a)
+      end
+
+      # split into an array of sized-arrays
+      def groups(size=1)
+        return [] if size <= 0
+        n,r = self.size.divmod(size)
+        grps = (0..(n-1)).collect{|i| self[i*size,size]}
+        r > 0 ? grps << self[-r,r] : grps
+      end
+      alias / groups
+      alias chunks groups
+
+    end
+  end
+end
+
+class Array
+  include Useful::RubyExtensions::Array
+end

data/lib/useful/ruby_extensions/fixnum.rb

@@ -0,0 +1,30 @@
+module Useful
+  module RubyExtensions
+    module Fixnum
+      
+      # returns a string reprensentation of the number padded with pad_num to a specified length
+      def pad(length = 3, pad_num = 0)
+        self.to_s.rjust(length,pad_num.to_s) rescue self.to_s
+      end
+
+      # return the value in values that is nearest to the number
+      def to_nearest_value(values = [])
+        return self if values.length == 0
+        value = values.first.to_i rescue self
+        diff = (self-value).abs
+        values.each do |val|
+          if (self-val.to_i).abs < diff
+            diff = (self-val.to_i).abs
+            value = val.to_i
+          end
+        end
+        value
+      end
+
+    end
+  end
+end
+
+class Fixnum
+  include Useful::RubyExtensions::Fixnum
+end

data/lib/useful/ruby_extensions/hash.rb

@@ -0,0 +1,108 @@
+require 'cgi'
+
+module Useful
+  module RubyExtensions
+    module Hash
+
+      module ClassMethods; end
+      def self.included(klass)
+        klass.extend(ClassMethods) if klass.kind_of?(Class)
+      end
+
+      module ClassMethods
+
+        # inspired by ActiveSupport::CoreExtensions::Hash::Keys (http://api.rubyonrails.org/)
+        def stringify_keys(hash)
+          hash.keys.each{ |key| hash[(key.to_s rescue key)] ||= hash.delete(key) }
+          hash
+        end
+        
+        # inspired by from ActiveSupport::CoreExtensions::Hash::Keys (http://api.rubyonrails.org/)
+        def symbolize_keys(hash)
+          hash.keys.each{ |key| hash[(key.to_sym rescue key)] ||= hash.delete(key) }
+          hash
+        end
+        
+        def only(hash, *keys)
+          hash.delete_if{ |k,v| !keys.flatten.include?(k) }
+          hash
+        end
+        
+        def except(hash, *keys)
+          hash.delete_if{ |k,v| keys.flatten.include?(k) }
+          hash
+        end
+        
+      end
+
+      # Return a new hash with all keys converted to strings.
+      def stringify_keys
+        self.class.stringify_keys(self.clone)
+      end
+      # Destructively convert all keys to strings. 
+      def stringify_keys!
+        self.class.stringify_keys(self)
+      end
+
+      # Return a new hash with all keys converted to strings.
+      def symbolize_keys
+        self.class.symbolize_keys(self.clone)
+      end
+      # Destructively convert all keys to strings. 
+      def symbolize_keys!
+        self.class.symbolize_keys(self)
+      end
+
+      # Return a new hash with only keys in *keys
+      def only(*keys)
+        self.class.only(self.clone, keys)
+      end
+      # Destructively remove all keys not in *keys
+      def only!(*keys)
+        self.class.only(self, keys)
+      end
+
+      # Return a new hash with only keys not in *keys
+      def except(*keys)
+        self.class.except(self.clone, keys)
+      end
+      # Destructively remove all keys in *keys
+      def except!(*keys)
+        self.class.except(self, keys)
+      end
+
+      # Determines if a value exists for the provided key(s).  Allows searching in nested hashes
+      def check_value?(*keys)
+        val = self[keys.first] || self[keys.first.to_s]
+        val = self[keys.first.to_s.intern] unless val || keys.first.kind_of?(Symbol) 
+        return val.check_value?(*keys[1..-1]) if val.kind_of?(Hash) && keys.length > 1
+        return true if val && !val.empty?
+        false
+      end
+
+      # takes any empty values and makes them nil inline
+      def nillify!
+        self.each { |key,value| self[key] = nil if !value.nil? && value.to_s.empty? }
+      end
+
+      # Returns string formatted for HTTP URL encoded name-value pairs.
+      # For example,
+      #  {:id => 'thomas_hardy'}.to_http_str 
+      #  # => "id=thomas_hardy"
+      #  {:id => 23423, :since => Time.now}.to_http_str
+      #  # => "since=Thu,%2021%20Jun%202007%2012:10:05%20-0500&id=23423"
+      def to_http_str
+        self.empty? ? '' : self.collect{|key, val| "#{key.to_s}=#{CGI.escape(val.to_s)}"}.join('&')
+      end
+
+      def to_html_attrs
+        self.empty? ? '' : self.collect{|key, val| "#{key}=\"#{val}\""}.join(' ')
+      end
+
+    end
+  end
+end
+
+class Hash
+  include Useful::RubyExtensions::Hash
+end

data/lib/useful/ruby_extensions/numeric.rb

@@ -0,0 +1,255 @@
+require File.join(File.dirname(__FILE__), 'object')
+require File.join(File.dirname(__FILE__), 'string')
+require File.join(File.dirname(__FILE__), 'hash')
+
+module Useful
+  module RubyExtensions
+    module Numeric #:nodoc:
+
+      LOCALES = {
+        :en => {
+          :currency => {:format => "%u%n", :unit=> '$'},
+          :storage => {:format => "%n %u", :delimiter => ''},
+          :format => {:delimiter => ',', :separator => '.'},
+          :defaults => {:precision => 2}
+        }
+      }.freeze
+      STORAGE_UNITS = [:bytes, :kb, :mb, :gb, :tb].freeze
+
+      module ClassMethods; end
+      def self.included(klass)
+        klass.extend(ClassMethods) if klass.kind_of?(Class)
+      end
+
+      module ClassMethods
+
+        def pad_precision(num, opts = {})
+          opts[:precision] ||= 2
+          opts[:separator] ||= '.'
+          opts[:pad_number] ||= 0
+          num.to_s.ljust(num.to_s.split(opts[:separator])[0].length + num.to_s.count(opts[:separator]) + opts[:precision].to_i, opts[:pad_number].to_s)
+        end
+
+      end
+
+      # Formats a +number+ with grouped thousands using +delimiter+ (e.g., 12,324). You can
+      # customize the format in the +options+ hash.
+      # => taken and inspired from ActionView::Helpers::NumberHelper (http://api.rubyonrails.org/)
+      #
+      # ==== Options
+      # * <tt>:delimiter</tt>  - Sets the thousands delimiter (defaults to ",").
+      # * <tt>:separator</tt>  - Sets the separator between the units (defaults to ".").
+      #
+      # ==== Examples
+      #  12345678.with_delimiter                        # => 12,345,678
+      #  12345678.05.with_delimiter                     # => 12,345,678.05
+      #  12345678.with_delimiter(:delimiter => ".")     # => 12.345.678
+      #  12345678.with_delimiter(:seperator => ",")     # => 12,345,678
+      #  98765432.98.with_delimiter(:delimiter => " ", :separator => ",")
+      #  # => 98 765 432,98
+      def with_delimiter(opts = {})
+        number = self.to_s.strip
+        opts.symbolize_keys!
+        opts[:locale] ||= :en
+        locale = LOCALES[opts.delete(:locale)]
+        opts = locale[:format].merge(opts) unless locale.nil?
+        opts[:delimiter] ||= ','
+        opts[:separator] ||= '.'
+
+        begin
+          parts = number.to_s.split('.')
+          parts[0].gsub!(/(\d)(?=(\d\d\d)+(?!\d))/, "\\1#{opts[:delimiter]}")
+          parts.join(opts[:separator])
+        rescue
+          number
+        end
+      end
+
+      # Converts a +number+ with the specified level of <tt>:precision</tt> (e.g., 112.32 has a precision of 2).
+      # => taken and inspired from ActionView::Helpers::NumberHelper (http://api.rubyonrails.org/)
+      def to_precision(precision = 2)
+        rounded_number = (Float(self) * (10 ** precision)).round
+        rounded_number = rounded_number.to_f if precision > 0
+        (rounded_number / 10 ** precision) rescue self
+      end
+      
+      # Formats a +number+ with the specified level of <tt>:precision</tt> (e.g., 112.32 has a precision of 2).
+      # You can customize the format in the +options+ hash.
+      # => taken and inspired from ActionView::Helpers::NumberHelper (http://api.rubyonrails.org/)
+      #
+      # ==== Options
+      # * <tt>:precision</tt>  - Sets the level of precision (defaults to 3).
+      # * <tt>:separator</tt>  - Sets the separator between the units (defaults to ".").
+      # * <tt>:delimiter</tt>  - Sets the thousands delimiter (defaults to "").
+      #
+      # ==== Examples (:locale => :en)
+      #  111.2345.with_precision                    # => 111.235
+      #  111.2345.with_precision(:precision => 2)   # => 111.23
+      #  13.with_precision(:precision => 5)         # => 13.00000
+      #  389.32314.with_precision(:precision => 0)  # => 389
+      #  1111.2345.with_precision(:precision => 2, :separator => ',', :delimiter => '.')
+      #  # => 1,111.23
+      def with_precision(opts = {})
+        opts.symbolize_keys!
+        opts[:locale] ||= :en
+        locale = LOCALES[opts.delete(:locale)]
+        opts = locale[:defaults].merge(locale[:format]).merge(opts) unless locale.nil?
+        opts[:precision] ||= 2
+        
+        self.class.pad_precision(self.to_precision(opts[:precision]).with_delimiter(opts.only(:separator, :delimiter)), opts) rescue self
+      end
+
+      # Formats a +number+ as a percentage string (e.g., 65%). You can customize the
+      # format in the +options+ hash.
+      #
+      # ==== Options
+      # * <tt>:precision</tt>  - Sets the level of precision (defaults to 2).
+      # * <tt>:separator</tt>  - Sets the separator between the units (defaults to ".").
+      # * <tt>:delimiter</tt>  - Sets the thousands delimiter (defaults to "").
+      #
+      # ==== Examples
+      #  100.to_percentage                                        # => 100.00%
+      #  100.to_percentage(:precision => 0)                       # => 100%
+      #  1000.to_percentage(:delimiter => '.', :separator => ',') # => 1.000,00%
+      #  302.24398923423.to_percentage(:precision => 5)           # => 302.24399%
+      def to_percentage(opts = {})
+        opts.symbolize_keys!
+        opts[:locale] ||= :en
+        locale = LOCALES[opts.delete(:locale)]
+        opts = locale[:defaults].merge(locale[:format]).merge(opts) unless locale.nil?
+
+        "#{self.with_precision(opts.only(:precision, :separator, :delimiter))}%" rescue self
+      end
+
+      # Formats a +number+ into a currency string (e.g., $13.65). You can customize the format
+      # in the +options+ hash.
+      # => taken and inspired from ActionView::Helpers::NumberHelper (http://api.rubyonrails.org/)
+      #
+      # ==== Options
+      # * <tt>:precision</tt>  -  Sets the level of precision (defaults to 2).
+      # * <tt>:unit</tt>       - Sets the denomination of the currency (defaults to "$").
+      # * <tt>:separator</tt>  - Sets the separator between the units (defaults to ".").
+      # * <tt>:delimiter</tt>  - Sets the thousands delimiter (defaults to ",").
+      # * <tt>:format</tt>     - Sets the format of the output string (defaults to "%u%n"). The field types are:
+      #     %u  The currency unit
+      #     %n  The number
+      #
+      # ==== Examples (:locale => :en)
+      #  1234567890.50.to_currency                    # => $1,234,567,890.50
+      #  1234567890.506.to_currency                   # => $1,234,567,890.51
+      #  1234567890.506.to_currency(:precision => 3)  # => $1,234,567,890.506
+      #
+      #  1234567890.50.to_currency(:unit => "&pound;", :separator => ",", :delimiter => "")
+      #  # => &pound;1234567890,50
+      #  1234567890.50.to_currency(:unit => "&pound;", :separator => ",", :delimiter => "", :format => "%n %u")
+      #  # => 1234567890,50 &pound;
+      def to_currency(opts = {})
+        opts.symbolize_keys!
+        opts[:locale] ||= :en
+        locale = LOCALES[opts.delete(:locale)]
+        opts = locale[:defaults].merge(locale[:format]).merge(locale[:currency]).merge(opts) unless locale.nil?
+
+        opts[:format].gsub(/%n/, self.with_precision(opts.only(:precision, :delimiter, :separator))).gsub(/%u/, opts[:unit]) #rescue self
+      end
+
+      # Formats the bytes in +size+ into a more understandable representation
+      # (e.g., giving it 1500 yields 1.5 KB). This method is useful for
+      # reporting file sizes to users. This method returns nil if
+      # +size+ cannot be converted into a number. You can customize the
+      # format in the +options+ hash.
+      #
+      # ==== Options
+      # * <tt>:precision</tt>  - Sets the level of precision (defaults to 2).
+      # * <tt>:separator</tt>  - Sets the separator between the units (defaults to ".").
+      # * <tt>:delimiter</tt>  - Sets the thousands delimiter (defaults to "").
+      #
+      # ==== Examples
+      #  123.to_storage_size                                          # => 123 Bytes
+      #  1234.to_storage_size                                         # => 1.2 KB
+      #  12345.to_storage_size                                        # => 12.1 KB
+      #  1234567.to_storage_size                                      # => 1.2 MB
+      #  1234567890.to_storage_size                                   # => 1.1 GB
+      #  1234567890123.to_storage_size                                # => 1.1 TB
+      #  1234567.to_storage_size(:precision => 2)                     # => 1.18 MB
+      #  483989.to_storage_size(:precision => 0)                      # => 473 KB
+      #  1234567.to_storage_size(:precision => 2, :separator => ',')  # => 1,18 MB
+      def to_storage_size(opts = {})
+        return nil if self.nil?
+        opts.symbolize_keys!
+        opts[:locale] ||= :en
+        locale = LOCALES[opts.delete(:locale)]
+        opts = locale[:defaults].merge(locale[:format]).merge(locale[:storage]).merge(opts) unless locale.nil?
+        opts[:format] ||= "%n %u"
+
+        value = self.to_f
+        unit = ''
+        STORAGE_UNITS.each do |storage_unit|
+          unit = storage_unit.to_s.capitalize
+          return opts[:format].gsub(/%n/, value.with_precision(opts.only(:precision, :delimiter, :separator))).gsub(/%u/, unit) if value < 1024 || storage_unit == STORAGE_UNITS.last
+          value /= 1024.0
+        end
+      end
+
+      # Returns the string representation of the number's +parity+.
+      #
+      # ==== Examples
+      #  1.to_parity                                          # => "odd"
+      #  2.to_parity                                          # => "even"
+      def to_parity
+        self.to_i.even? ? 'even' : 'odd'
+      end
+
+      # Provides methods for converting numbers into formatted strings.
+      # Methods are provided for phone numbers, currency, percentage,
+      # precision, positional notation, and file size.
+      # => taken and inspired from ActionView::Helpers::NumberHelper (http://api.rubyonrails.org/)
+
+      # Formats a +number+ into a US phone number (e.g., (555) 123-9876). You can customize the format
+      # in the +options+ hash.
+      #
+      # ==== Options
+      # * <tt>:area_code</tt>  - Adds parentheses around the area code.
+      # * <tt>:delimiter</tt>  - Specifies the delimiter to use (defaults to "-").
+      # * <tt>:extension</tt>  - Specifies an extension to add to the end of the
+      #   generated number.
+      # * <tt>:country_code</tt>  - Sets the country code for the phone number.
+      #
+      # ==== Examples
+      #  5551234.to_phone                                           # => 555-1234
+      #  1235551234.to_phone                                        # => 123-555-1234
+      #  1235551234.to_phone(:area_code => true)                    # => (123) 555-1234
+      #  1235551234.to_phone(:delimiter => " ")                     # => 123 555 1234
+      #  1235551234.to_phone(:area_code => true, :extension => 555) # => (123) 555-1234 x 555
+      #  1235551234.to_phone(:country_code => 1)                    # => +1-123-555-1234
+      #  1235551234.to_phone({ :country_code => 1,
+      #    :extension => 1343, :delimiter => "." })                 # => +1.123.555.1234 x 1343
+      def to_phone(opts={})
+        number = self.to_s.strip
+        opts.symbolize_keys!
+        opts[:delimiter] ||= '-'
+        opts[:extension] = opts[:extension].to_s.strip unless opts[:extension].nil?
+
+        begin
+          str = ""
+          str << "+#{opts[:country_code]}#{opts[:delimiter]}" unless opts[:country_code].blank?
+          str << if opts[:area_code]
+            number.gsub!(/([0-9]{1,3})([0-9]{3})([0-9]{4}$)/,"(\\1) \\2#{opts[:delimiter]}\\3")
+          else
+            number.gsub!(/([0-9]{0,3})([0-9]{3})([0-9]{4})$/,"\\1#{opts[:delimiter]}\\2#{opts[:delimiter]}\\3")
+            number.starts_with?('-') ? number.slice!(1..-1) : number
+          end
+          str << " x #{opts[:extension]}" unless opts[:extension].blank?
+          str
+        rescue
+          number
+        end
+      end
+      
+    end
+  end
+end
+
+class Numeric
+  include Useful::RubyExtensions::Numeric
+end
+

data/lib/useful/ruby_extensions/object.rb

@@ -0,0 +1,23 @@
+module Useful
+  module RubyExtensions
+    module Object
+      
+      def false?
+        self == false
+      end
+      
+      def true?
+        self == true
+      end
+      
+      def blank?
+        self.nil? || self.empty? rescue false
+      end
+
+    end
+  end
+end
+
+class Object
+  include Useful::RubyExtensions::Object
+end

data/lib/useful/ruby_extensions/string.rb

@@ -0,0 +1,51 @@
+module Useful
+  module RubyExtensions
+    module String
+      
+      module ClassMethods; end
+      def self.included(klass)
+        klass.extend(ClassMethods) if klass.kind_of?(Class)
+      end
+
+      module ClassMethods
+
+        # adds the contents of a2 to a1, removing duplicates
+        def hsub(string, hash)
+          hash.each {|k,v| string.gsub!(":#{k}",v.to_s)}
+          string
+        end
+        
+      end
+
+      # returns a new string, with hash values sub'd in where hash keys exist in original string
+      def hsub(hash)
+        self.class.hsub(self.clone, hash)
+      end
+      # substitutes the keys in hash that exist in the string, with values of hash
+      def hsub!(hash)
+        self.class.hsub(self, hash)
+      end
+
+      def match?(pattern)
+        !self.match(pattern).nil?
+      end
+      
+      def starts_with?(string)
+        self.match?(Regexp.new("\\A#{string}"))
+      end
+
+      def show_regexp(re)
+        if self =~ re
+          "#{$`}<<#{$&}>>#{$'}"
+        else
+          "no match"
+        end
+      end
+
+    end
+  end
+end
+
+class String
+  include Useful::RubyExtensions::String
+end

data/lib/useful/ruby_extensions.rb

@@ -0,0 +1,7 @@
+$:.unshift File.dirname(__FILE__)
+require 'ruby_extensions/array'
+require 'ruby_extensions/hash'
+require 'ruby_extensions/string'
+require 'ruby_extensions/fixnum'
+require 'ruby_extensions/numeric'
+require 'ruby_extensions/object'

data/lib/useful/sinatra_helpers/environment_tests.rb

@@ -0,0 +1,17 @@
+require 'sinatra/base'
+
+module Sinatra
+  module SinatraHelpers
+    module EnvironmentTests
+      def production? 
+        Sinatra::Application.environment.to_s == 'production'
+      end
+      def development?
+        Sinatra::Application.environment.to_s == 'development'
+      end
+    end
+  end
+  
+  Sinatra::Application.helpers Sinatra::SinatraHelpers::EnvironmentTests
+  Sinatra::Application.register Sinatra::SinatraHelpers::EnvironmentTests
+end

data/lib/useful/sinatra_helpers/erb/error_pages.rb

@@ -0,0 +1,23 @@
+require 'sinatra/base'
+
+module Sinatra
+  module SinatraHelpers
+    module Erb
+      module ErrorPages
+        def self.registered(app)
+          app.configure :production do
+            app.not_found do
+              erb :'404.html'
+            end
+            app.error do
+              @err = request.env['sinatra_error']
+              erb :'500.html'
+            end
+          end
+        end
+      end
+    end
+  end
+  
+  Sinatra::Application.register Sinatra::SinatraHelpers::Erb::ErrorPages
+end

data/lib/useful/sinatra_helpers/erb/partials.rb

@@ -0,0 +1,42 @@
+require 'sinatra/base'
+
+module Sinatra
+  module SinatraHelpers
+    module Erb
+      module Partials
+        
+        # helper to emulate rails 'render :partial' helper, using erb
+        # => taken from the sinatra book, http://sinatra-book.gittr.com/#implemention_of_rails_style_partials
+        # Render the page once:
+        # Usage: partial :foo
+        # 
+        # foo will be rendered once for each element in the array, passing in a local variable named "foo"
+        # Usage: partial :foo, :collection => @my_foos    
+        def partial(template, *args)
+          options = args.extract_options!
+          options.merge!(:layout => false)
+          path = template.to_s.split(File::SEPARATOR)
+          object = path[-1].to_sym
+          path[-1] = "_#{path[-1]}"
+          template = File.join(path).to_sym
+          raise 'partial collection specified but is nil' if options.has_key?(:collection) && options[:collection].nil?
+          if collection = options.delete(:collection)
+            counter = 0
+            collection.inject([]) do |buffer, member|
+              counter += 1
+              buffer << erb(template, options.merge(:locals => {object => member, "#{object}_counter".to_sym => counter}))
+            end.join("\n")
+          else
+            if member = options.delete(:object)
+              options.merge!(:locals => {object => member})
+            end
+            erb(template, options)
+          end
+        end
+
+      end
+    end
+  end
+  
+  Sinatra::Application.helpers Sinatra::SinatraHelpers::Erb::Partials
+end

data/lib/useful/sinatra_helpers/erb.rb

@@ -0,0 +1,3 @@
+$:.unshift File.dirname(__FILE__)
+require 'erb/error_pages'
+require 'erb/partials'

data/lib/useful/sinatra_helpers/tags.rb

@@ -0,0 +1,89 @@
+require 'sinatra/base'
+
+module Sinatra
+  module SinatraHelpers
+    module Tags
+      
+      # helper to emulate action view's 'link_to'
+      # => inspired from vanntastic-sinatra-gen gem, http://github.com/vanntastic/sinatra-gen/tree/master
+      # EX : link_to "google", "http://google.com"
+      # => <a href="http://google.com">google</a>
+      def link_to(content,href,options={})
+        options.update :href => href
+        tag(:a, options) { content }
+      end
+
+      # helper to emulate 'image_tag'
+      # => inspired from vanntastic-sinatra-gen gem, http://github.com/vanntastic/sinatra-gen/tree/master
+      # helper for image_tags
+      # EX : image_tag 'logo.jpg'
+      #  => <img src="images/logo.jpg" />
+      def image_tag(src,options={})
+        options[:src] = ['/'].include?(src.first) ? src : "/images/#{src}"
+        tag(:img, options)
+      end
+
+      def clear_tag(options={})
+        options[:tag] ||= :div
+        options[:style] ||= ''
+        options[:style] = "clear: both;#{options[:style]}"
+        tag(options.delete(:tag), options) { '' }
+      end
+
+      include Rack::Utils
+      alias_method :h, :escape_html
+
+      # helper to emulate 'stylesheet_link_tag'
+      # => inspired from vanntastic-sinatra-gen gem, http://github.com/vanntastic/sinatra-gen/tree/master
+      # EX : stylesheet_link_tag 'default'
+      #  => <link rel="stylesheet" href="/stylesheets/default.css" type="text/css" media="all" title="no title" charset="utf-8">
+      def stylesheet_link_tag(srcs,options={})
+        options[:media] ||=  "screen"
+        options[:type] ||= "text/css"
+        options[:rel] ||= "stylesheet"
+        srcs.to_a.collect do |src|
+          options[:href] = "/stylesheets/#{src}.css#{"?#{Time.now.to_i}" if Sinatra::Application.environment.to_s == 'development'}"
+          tag(:link, options)
+        end.join("\n")
+      end
+
+      # helper to emulate 'javascript_include_tag'
+      # => inspired from vanntastic-sinatra-gen gem, http://github.com/vanntastic/sinatra-gen/tree/master
+      # EX : javascript_include_tag 'app'
+      #  => <script src="/js/app.js" type="text/javascript" />  
+      # EX : javascript_include_tag ['app', 'jquery']
+      #  => <script src="/js/app.js" type="text/javascript" />
+      #  => <script src="/js/jquery.js" type="text/javascript" />
+      def javascript_include_tag(srcs,options={})
+        options[:type] ||= "text/javascript"
+        srcs.to_a.collect do |src|
+          options[:src] = "/javascripts/#{src}.js#{"?#{Time.now.to_i}" if Sinatra::Application.environment.to_s == 'development'}"
+          tag(:script, options) { '' }
+        end.join("\n")
+      end
+
+      # helper to emulate 'javascript_tag'
+      def javascript_tag(options={})
+        options[:type] ||= "text/javascript"
+        tag(:script, options) { yield }
+      end
+
+      # emulator for 'tag'
+      # => inspired from vanntastic-sinatra-gen gem, http://github.com/vanntastic/sinatra-gen/tree/master
+      # EX : tag :h1, "shizam", :title => "shizam"
+      # => <h1 title="shizam">shizam</h1>
+      def tag(name,options={})
+        "<#{name.to_s} #{hash_to_html_attrs(options)} #{block_given? ? ">#{yield}</#{name}" : "/"}>"
+      end
+      
+      private
+      
+      def hash_to_html_attrs(a_hash)
+        a_hash.collect{|key, val| "#{key}=\"#{val}\""}.join(' ')
+      end
+
+    end
+  end
+  
+  Sinatra::Application.helpers Sinatra::SinatraHelpers::Tags
+end

data/lib/useful/sinatra_helpers.rb

@@ -0,0 +1,4 @@
+$:.unshift File.dirname(__FILE__)
+require 'sinatra_helpers/environment_tests'
+require 'sinatra_helpers/erb'
+require 'sinatra_helpers/tags'

data/lib/useful/version.rb

@@ -0,0 +1,13 @@
+module Useful
+  module Version
+    
+    MAJOR = 0
+    MINOR = 1
+    TINY  = 0
+    
+    def self.to_s # :nodoc:
+      [MAJOR, MINOR, TINY].join('.')
+    end
+    
+  end
+end

data/lib/useful.rb

@@ -0,0 +1,2 @@
+$:.unshift File.dirname(__FILE__)
+p "don't require this file, require in sub modules as needed."

data/test/test_helper.rb

@@ -0,0 +1,10 @@
+# http://sneaq.net/textmate-wtf
+$:.reject! { |e| e.include? 'TextMate' }
+
+require 'rubygems'
+require 'test/unit'
+require 'matchy'
+require 'context'
+require 'mocha'
+
+require File.dirname(__FILE__) + '/../lib/useful'

data/test/unit/useful_test.rb

@@ -0,0 +1,13 @@
+require File.dirname(__FILE__) + '/../test_helper'
+
+class UsefulTest < Test::Unit::TestCase
+
+  describe "An instance of the Useful class" do
+
+    it "should flunk" do
+      flunk "Please provide some tests"
+    end
+    
+  end
+
+end

metadata

@@ -0,0 +1,77 @@
+--- !ruby/object:Gem::Specification 
+name: kelredd-useful
+version: !ruby/object:Gem::Version 
+  version: 0.1.0
+platform: ruby
+authors: 
+- Kelredd
+autorequire: 
+bindir: bin
+cert_chain: []
+
+date: 2009-06-02 00:00:00 -07:00
+default_executable: 
+dependencies: []
+
+description: 
+email: ""
+executables: []
+
+extensions: []
+
+extra_rdoc_files: 
+- README.rdoc
+files: 
+- README.rdoc
+- Rakefile
+- lib/useful
+- lib/useful/ruby_extensions
+- lib/useful/ruby_extensions/array.rb
+- lib/useful/ruby_extensions/fixnum.rb
+- lib/useful/ruby_extensions/hash.rb
+- lib/useful/ruby_extensions/numeric.rb
+- lib/useful/ruby_extensions/object.rb
+- lib/useful/ruby_extensions/string.rb
+- lib/useful/ruby_extensions.rb
+- lib/useful/sinatra_helpers
+- lib/useful/sinatra_helpers/environment_tests.rb
+- lib/useful/sinatra_helpers/erb
+- lib/useful/sinatra_helpers/erb/error_pages.rb
+- lib/useful/sinatra_helpers/erb/partials.rb
+- lib/useful/sinatra_helpers/erb.rb
+- lib/useful/sinatra_helpers/tags.rb
+- lib/useful/sinatra_helpers.rb
+- lib/useful/version.rb
+- lib/useful.rb
+- test/test_helper.rb
+- test/unit
+- test/unit/useful_test.rb
+has_rdoc: true
+homepage: ""
+post_install_message: 
+rdoc_options: 
+- --main
+- README.rdoc
+require_paths: 
+- lib
+required_ruby_version: !ruby/object:Gem::Requirement 
+  requirements: 
+  - - ">="
+    - !ruby/object:Gem::Version 
+      version: "0"
+  version: 
+required_rubygems_version: !ruby/object:Gem::Requirement 
+  requirements: 
+  - - ">="
+    - !ruby/object:Gem::Version 
+      version: "0"
+  version: 
+requirements: []
+
+rubyforge_project: 
+rubygems_version: 1.2.0
+signing_key: 
+specification_version: 2
+summary: A collection of useful helpers for various ruby things.
+test_files: []
+