kelredd-useful 0.1.25 → 0.2.0

data/lib/useful/ruby_extensions/string.rb

@@ -1,49 +1,275 @@
-module Useful
-  module RubyExtensions
-    module String
-      
-      module ClassMethods; end
-      def self.included(klass)
-        klass.extend(ClassMethods) if klass.kind_of?(Class)
-      end
+module Useful; end
+module Useful::RubyExtensions; end
 
-      module ClassMethods
+module Useful::RubyExtensions::String
+  
+  EMAIL_REGEXP = /\A([\w\.\-\+]+)@((?:[-a-z0-9]+\.)+[a-z]{2,})\z/i
 
-        # 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
+  module ClassMethods
 
-      # 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)
+    # 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
+    
+    # does some CGI escaping on a string
+    CGI_ESCAPE_MAP = {
+      '+'    => '%20'
+    }.freeze
+    def cgi_escape(string)
+      require 'cgi' unless defined?(::CGI) && defined?(::CGI::escape)
+      ::CGI.escape(string).gsub(/(\+)/) { CGI_ESCAPE_MAP[$1] }
+    end
+    
+    def match?(string, pattern)
+      !string.match(pattern).nil?
+    end
+    
+    def valid_email?(string)
+      match?(string, EMAIL_REGEXP)
+    end
+    
+    def show_regexp(string, re)
+      if string =~ re
+        "#{$`}<<#{$&}>>#{$'}"
+      else
+        "no match"
       end
+    end
 
-      def match?(pattern)
-        !self.match(pattern).nil?
-      end
+  end
+  
+  module InstanceMethods
+
+    # 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
+    
+    # will destructively empty out a string, making its value ""
+    def empty!
+      self.replace("")
+    end
+
+    def cgi_escape
+      self.class.cgi_escape(self)
+    end
+
+    def cgi_escape!
+      self.replace(self.class.cgi_escape(self))
+    end
+
+    def match?(pattern)
+      self.class.match?(self, pattern)
+    end
+
+    def valid_email?
+      self.class.valid_email?(self)
+    end
+
+    def show_regexp(re)
+      self.class.show_regexp(self, re)
+    end
+    
+    def to_boolean
+      self =~ /^(false|0)$/i ? false : true
+    end
+    
+    def from_currency_to_f
+      self.gsub(/[^0-9.-]/,'').to_f
+    end
+    
+  end
+  
+  module FromActivesupport
+    
+    module ClassMethods
       
-      def show_regexp(re)
-        if self =~ re
-          "#{$`}<<#{$&}>>#{$'}"
+      # By default, +camelize+ converts strings to UpperCamelCase. If the argument to +camelize+
+      # is set to <tt>:lower</tt> then +camelize+ produces lowerCamelCase.
+      #
+      # +camelize+ will also convert '/' to '::' which is useful for converting paths to namespaces.
+      #
+      # Examples:
+      #   "active_record".camelize                # => "ActiveRecord"
+      #   "active_record".camelize(:lower)        # => "activeRecord"
+      #   "active_record/errors".camelize         # => "ActiveRecord::Errors"
+      #   "active_record/errors".camelize(:lower) # => "activeRecord::Errors"
+      def camelize(lower_case_and_underscored_word, first_letter_in_uppercase = true)
+        if first_letter_in_uppercase
+          lower_case_and_underscored_word.to_s.gsub(/\/(.?)/) { "::#{$1.upcase}" }.gsub(/(?:^|_)(.)/) { $1.upcase }
         else
-          "no match"
+          lower_case_and_underscored_word[0..0].downcase + camelize(lower_case_and_underscored_word)[1..-1]
         end
+      end unless ::String.respond_to?('camelize')
+
+      # Capitalizes the first word and turns underscores into spaces and strips a
+      # trailing "_id", if any. Like +titleize+, this is meant for creating pretty output.
+      #
+      # Examples:
+      #   "employee_salary" # => "Employee salary"
+      #   "author_id"       # => "Author"
+      def humanize(lower_case_and_underscored_word)
+        result = lower_case_and_underscored_word.to_s.dup
+        result.gsub(/_id$/, "").gsub(/_/, " ").capitalize
       end
-      
-      def to_boolean
-        self =~ /^(true|1)$/i ? true : false
+
+      # Capitalizes all the words and replaces some characters in the string to create
+      # a nicer looking title. +titleize+ is meant for creating pretty output. It is not
+      # used in the Rails internals.
+      #
+      # Examples:
+      #   "man from the boondocks".titleize # => "Man From The Boondocks"
+      #   "x-men: the last stand".titleize  # => "X Men: The Last Stand"
+      def titleize(word)
+        humanize(underscore(word)).gsub(/\b('?[a-z])/) { $1.capitalize }
+      end
+
+      # The reverse of +camelize+. Makes an underscored, lowercase form from the expression in the string.
+      #
+      # Changes '::' to '/' to convert namespaces to paths.
+      #
+      # Examples:
+      #   "ActiveRecord".underscore         # => "active_record"
+      #   "ActiveRecord::Errors".underscore # => active_record/errors
+      def underscore(camel_cased_word)
+        camel_cased_word.to_s.gsub(/::/, '/').
+          gsub(/([A-Z]+)([A-Z][a-z])/,'\1_\2').
+          gsub(/([a-z\d])([A-Z])/,'\1_\2').
+          tr("-", "_").
+          downcase
+      end unless ::String.respond_to?('underscore')
+
+      # Replaces underscores with dashes in the string.
+      #
+      # Example:
+      #   "puni_puni" # => "puni-puni"
+      def dasherize(underscored_word)
+        underscored_word.gsub(/_/, '-')
+      end unless ::String.respond_to?('dasherize')
+
+      # Removes the module part from the expression in the string.
+      #
+      # Examples:
+      #   "ActiveRecord::CoreExtensions::String::Inflections".demodulize # => "Inflections"
+      #   "Inflections".demodulize                                       # => "Inflections"
+      def demodulize(class_name_in_module)
+        class_name_in_module.to_s.gsub(/^.*::/, '')
+      end unless ::String.respond_to?('demodulize')
+
+      # Ruby 1.9 introduces an inherit argument for Module#const_get and
+      # #const_defined? and changes their default behavior.
+      if Module.method(:const_get).arity == 1
+        # Tries to find a constant with the name specified in the argument string:
+        #
+        #   "Module".constantize     # => Module
+        #   "Test::Unit".constantize # => Test::Unit
+        #
+        # The name is assumed to be the one of a top-level constant, no matter whether
+        # it starts with "::" or not. No lexical context is taken into account:
+        #
+        #   C = 'outside'
+        #   module M
+        #     C = 'inside'
+        #     C               # => 'inside'
+        #     "C".constantize # => 'outside', same as ::C
+        #   end
+        #
+        # NameError is raised when the name is not in CamelCase or the constant is
+        # unknown.
+        def constantize(camel_cased_word)
+          names = camel_cased_word.split('::')
+          names.shift if names.empty? || names.first.empty?
+
+          constant = ::Object
+          names.each do |name|
+            constant = constant.const_defined?(name) ? constant.const_get(name) : constant.const_missing(name)
+          end
+          constant
+        end unless ::String.respond_to?('constantize')
+      else
+        def constantize(camel_cased_word) #:nodoc:
+          names = camel_cased_word.split('::')
+          names.shift if names.empty? || names.first.empty?
+
+          constant = ::Object
+          names.each do |name|
+            constant = constant.const_get(name, false) || constant.const_missing(name)
+          end
+          constant
+        end unless ::String.respond_to?('constantize')
       end
+
+    end
+    
+    module InstanceMethods
       
+      def camelize(first_letter = :upper)
+        case first_letter
+          when :upper then ::String.camelize(self, true)
+          when :lower then ::String.camelize(self, false)
+        end
+      end unless "".respond_to?('camelize')
+      alias_method :camelcase, :camelize unless "".respond_to?('camelcase')
+
+      def humanize
+        self.class.humanize(self)
+      end unless "".respond_to?('humanize')
+
+      def titleize
+        self.class.titleize(self)
+      end unless "".respond_to?('titleize')
+
+      def underscore
+        self.class.underscore(self)
+      end unless "".respond_to?('underscore')
+
+      def dasherize
+        self.class.dasherize(self)
+      end unless "".respond_to?('dasherize')
+
+      def demodulize
+        self.class.demodulize(self)
+      end unless "".respond_to?('demodulize')
+
+      def constantize
+        self.class.constantize(self)
+      end unless "".respond_to?('constantize')
+
+      def ends_with?(suffix)
+        suffix = suffix.to_s
+        self[-suffix.length, suffix.length] == suffix      
+      end unless "".respond_to?('ends_with?')
+
+      def starts_with?(prefix)
+        prefix = prefix.to_s
+        self[0, prefix.length] == prefix
+      end unless "".respond_to?('starts_with?')
+
+      def to_datetime
+        ::DateTime.civil(*::Date._parse(self, false).values_at(:year, :mon, :mday, :hour, :min, :sec).map { |arg| arg || 0 }) rescue nil
+      end unless "".respond_to?('to_datetime')
+
+      def to_date
+        ::Date.civil(*::Date._parse(self, false).values_at(:year, :mon, :mday).map { |arg| arg || 0 }) rescue nil
+      end unless "".respond_to?('to_date')
+
     end
+    
+  end
+  
+  def self.included(receiver)
+    receiver.extend         ClassMethods
+    receiver.extend         FromActivesupport::ClassMethods
+    receiver.send :include, InstanceMethods
+    receiver.send :include, FromActivesupport::InstanceMethods
   end
+  
 end
 
 class String

data/lib/useful/ruby_extensions/true_class.rb

@@ -1,18 +1,21 @@
-module Useful
-  module RubyExtensions
-    module TrueClass
-      
-      def to_affirmative
-        "Yes"
-      end
-      alias :to_casual_s :to_affirmative
+module Useful; end
+module Useful::RubyExtensions; end
 
-      def to_i
-        1
-      end
-    
-    end
+module Useful::RubyExtensions::TrueClass
+  
+  def to_affirmative(abbreviate=false)
+    abbreviate ? "Y" : "Yes"
   end
+  alias :to_casual_s :to_affirmative
+
+  def to_i
+    1
+  end
+  
+  def to_boolean
+    true
+  end
+
 end
 
 class TrueClass

data/lib/useful/ruby_extensions.rb

@@ -1,3 +1,3 @@
 Dir[File.join(File.dirname(__FILE__), "ruby_extensions" ,"*.rb")].each do |file|
-  require file
+  require "useful/ruby_extensions/#{File.basename(file, ".rb")}"
 end

data/lib/useful/ruby_extensions_with_activesupport.rb

@@ -0,0 +1,2 @@
+require 'activesupport'
+require 'useful/ruby_extensions'

data/lib/useful/shoulda_macros/test_unit.rb

@@ -0,0 +1,58 @@
+require 'useful/ruby_extensions/string' unless String.new.respond_to?(:constantize)
+
+module Useful; end
+module Useful::ShouldaMacros; end
+
+module Useful::ShouldaMacros::TestUnit
+  
+  protected
+  
+  # Ripped from Shoulda::ActiveRecord::Macros
+  def should_have_instance_methods(*methods)
+    get_options!(methods)
+    klass = described_type
+    methods.each do |method|
+      should "respond to instance method ##{method}" do
+        assert_respond_to((klass.new rescue subject), method, "#{klass.name} does not have instance method #{method}")
+      end
+    end
+  end unless Test::Unit::TestCase.method_defined? :should_have_instance_methods
+  
+  # Ripped from Shoulda::ActiveRecord::Macros
+  def should_have_class_methods(*methods)
+    get_options!(methods)
+    klass = described_type
+    methods.each do |method|
+      should "respond to class method ##{method}" do
+        assert_respond_to klass, method, "#{klass.name} does not have class method #{method}"
+      end
+    end
+  end unless Test::Unit::TestCase.method_defined? :should_have_class_methods
+  
+  def should_have_readers(*readers)
+    get_options!(readers)
+    klass = described_type
+    readers.each do |reader|
+      should_have_instance_methods reader
+    end
+  end unless Test::Unit::TestCase.method_defined? :should_have_readers
+  
+  def should_have_writers(*writers)
+    get_options!(writers)
+    klass = described_type
+    writers.each do |writer|
+      should_have_instance_methods "#{writer}="
+    end
+  end unless Test::Unit::TestCase.method_defined? :should_have_writers
+  
+  def should_have_accessors(*accessors)
+    get_options!(accessors)
+    klass = described_type
+    accessors.each do |accessor|
+      should_have_instance_methods accessor, "#{accessor}="
+    end
+  end unless Test::Unit::TestCase.method_defined? :should_have_accessors
+  
+end
+
+Test::Unit::TestCase.extend(Useful::ShouldaMacros::TestUnit) if defined? Test::Unit::TestCase

data/lib/useful/version.rb

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

data/lib/useful.rb

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

metadata

@@ -1,7 +1,7 @@
 --- !ruby/object:Gem::Specification 
 name: kelredd-useful
 version: !ruby/object:Gem::Version 
-  version: 0.1.25
+  version: 0.2.0
 platform: ruby
 authors: 
 - Kelly Redding
@@ -9,7 +9,7 @@ autorequire:
 bindir: bin
 cert_chain: []
 
-date: 2009-10-06 00:00:00 -05:00
+date: 2009-11-06 00:00:00 -06:00
 default_executable: 
 dependencies: 
 - !ruby/object:Gem::Dependency 
@@ -22,16 +22,6 @@ dependencies:
       - !ruby/object:Gem::Version 
         version: "0"
     version: 
-- !ruby/object:Gem::Dependency 
-  name: tmail
-  type: :runtime
-  version_requirement: 
-  version_requirements: !ruby/object:Gem::Requirement 
-    requirements: 
-    - - ">="
-      - !ruby/object:Gem::Version 
-        version: "0"
-    version: 
 description: 
 email: kelly@kelredd.com
 executables: []
@@ -45,44 +35,35 @@ files:
 - Rakefile
 - lib/useful/active_record_helpers/mysql_migration_helpers.rb
 - lib/useful/active_record_helpers.rb
-- lib/useful/cap_tasks/cache.rb
-- lib/useful/cap_tasks/gemsconfig.rb
+- lib/useful/cap_tasks/app_role_migrations.rb
+- lib/useful/cap_tasks/disable_migrate.rb
+- lib/useful/cap_tasks/git_query_revision_remote.rb
 - lib/useful/cap_tasks/globals.rb
+- lib/useful/cap_tasks/passenger_deploy.rb
+- lib/useful/cap_tasks/rack_cache.rb
 - lib/useful/cap_tasks.rb
-- lib/useful/rails_extensions/environment_tests.rb
-- lib/useful/rails_extensions.rb
+- lib/useful/erb_helpers/common.rb
+- lib/useful/erb_helpers/forms.rb
+- lib/useful/erb_helpers/links.rb
+- lib/useful/erb_helpers/proper.rb
+- lib/useful/erb_helpers/tags.rb
+- lib/useful/erb_helpers.rb
+- lib/useful/rails_helpers/environment_tests.rb
+- lib/useful/rails_helpers/erb.rb
+- lib/useful/rails_helpers.rb
 - lib/useful/ruby_extensions/array.rb
 - lib/useful/ruby_extensions/date.rb
 - lib/useful/ruby_extensions/false_class.rb
 - lib/useful/ruby_extensions/fixnum.rb
 - lib/useful/ruby_extensions/hash.rb
+- lib/useful/ruby_extensions/nil_class.rb
 - lib/useful/ruby_extensions/numeric.rb
 - lib/useful/ruby_extensions/object.rb
 - lib/useful/ruby_extensions/string.rb
 - lib/useful/ruby_extensions/true_class.rb
 - lib/useful/ruby_extensions.rb
-- lib/useful/ruby_extensions_from_rails/date.rb
-- lib/useful/ruby_extensions_from_rails/duration.rb
-- lib/useful/ruby_extensions_from_rails/fixnum.rb
-- lib/useful/ruby_extensions_from_rails/hash.rb
-- lib/useful/ruby_extensions_from_rails/numeric.rb
-- lib/useful/ruby_extensions_from_rails/object.rb
-- lib/useful/ruby_extensions_from_rails/string.rb
-- lib/useful/ruby_extensions_from_rails/time.rb
-- lib/useful/ruby_extensions_from_rails.rb
-- lib/useful/sinatra_helpers/environment_tests.rb
-- lib/useful/sinatra_helpers/erb/error_pages.rb
-- lib/useful/sinatra_helpers/erb/forms.rb
-- lib/useful/sinatra_helpers/erb/helpers.rb
-- lib/useful/sinatra_helpers/erb/links.rb
-- lib/useful/sinatra_helpers/erb/partials.rb
-- lib/useful/sinatra_helpers/erb/tags.rb
-- lib/useful/sinatra_helpers/erb.rb
-- lib/useful/sinatra_helpers/mailer/base.rb
-- lib/useful/sinatra_helpers/mailer/exceptions.rb
-- lib/useful/sinatra_helpers/mailer/tls.rb
-- lib/useful/sinatra_helpers/mailer.rb
-- lib/useful/sinatra_helpers.rb
+- lib/useful/ruby_extensions_with_activesupport.rb
+- lib/useful/shoulda_macros/test_unit.rb
 - lib/useful/version.rb
 - lib/useful.rb
 has_rdoc: true

data/lib/useful/cap_tasks/cache.rb

@@ -1,5 +0,0 @@
-Capistrano::Configuration.instance.load do
-  namespace :cache do
-  
-  end  
-end

data/lib/useful/cap_tasks/gemsconfig.rb

@@ -1,14 +0,0 @@
-Capistrano::Configuration.instance.load do
-  namespace :gemsconfig do
-
-    desc "Update code, run 'rake gemsconfig:install'"
-    task :install, :roles => fetch(:install_roles, :app) do
-      deploy.update_code
-      run_with_password("sudo #{fetch(:rake, "rake")} -f #{current_release}/Rakefile #{"RAILS_ENV=#{rails_env}" if rails_env} #{fetch(:gemsconfig, "gemsconfig")}:install", {
-        :prompt => "Enter sudo pw: ",
-        :pty => false
-      })
-    end
-
-  end
-end

data/lib/useful/rails_extensions/environment_tests.rb

@@ -1,60 +0,0 @@
-module Useful
-  module RailsExtensions
-    module EnvironmentTests
-      
-      module ClassMethods
-        
-        def production? 
-          RAILS_ENV == 'production'
-        end
-        
-        def development? 
-          RAILS_ENV == 'development'
-        end
-        
-      end
-      
-      module InstanceMethods
-        
-        def production? 
-          self.class.production?
-        end
-        
-        def development? 
-          self.class.development?
-        end
-        
-      end
-      
-      def self.included(receiver)
-        receiver.extend         ClassMethods
-        receiver.send :include, InstanceMethods
-      end
-
-    end
-  end
-end
-
-module ActiveRecord
-  class Base
-    include Useful::RailsExtensions::EnvironmentTests
-  end
-  class Observer
-    include Useful::RailsExtensions::EnvironmentTests
-  end
-end
-module ActionController
-  class Base
-    include Useful::RailsExtensions::EnvironmentTests
-  end
-end
-module ActionView
-  class Base
-    include Useful::RailsExtensions::EnvironmentTests
-  end
-end
-module ActionMailer
-  class Base
-    include Useful::RailsExtensions::EnvironmentTests
-  end
-end

data/lib/useful/rails_extensions.rb

@@ -1,3 +0,0 @@
-Dir[File.join(File.dirname(__FILE__), "rails_extensions" ,"*.rb")].each do |file|
-  require file
-end