kelredd-useful 0.1.25 → 0.2.0

data/lib/useful/erb_helpers/links.rb

@@ -0,0 +1,156 @@
+require 'useful/erb_helpers/common'
+require 'useful/erb_helpers/tags'
+require 'useful/ruby_extensions/string' unless ::String.new.respond_to?('cgi_escape')
+require 'useful/ruby_extensions/hash' unless ::Hash.new.respond_to?('to_http_query_str')
+
+module Useful; end
+module Useful::ErbHelpers; end
+
+module Useful::ErbHelpers::Links
+  
+  include Useful::ErbHelpers::Common
+  
+  # helper to emulate action view's 'link_to'
+  # EX : link_to "http://google.com"
+  # => <a href="http://google.com">http://google.com</a>
+  # EX : link_to "google", "http://google.com"
+  # => <a href="http://google.com">google</a>
+  # EX : link_to "google", "http://google.com", :class => "awesome"
+  # => <a href="http://google.com" class="awesome">google</a>
+  # EX : link_to "http://google.com", :popup => true
+  # => <a href="http://google.com" onclick="javascript: window.open(this.href); return false;">http://google.com</a>
+  # EX : link_to "http://google.com", :popup => ['new_window_name', 'height=300,width=600']
+  # => <a href="http://google.com" onclick="javascript: window.open(this.href,'new_window_name','height=300,width=600'); return false;">http://google.com</a>
+  # EX : link_to "http://google.com", :confirm => "Are you sure?"
+  # => <a href="http://google.com" onclick="javascript: return confirm('Are you sure?');">http://google.com</a>
+  # EX : link_to "http://google.com", :confirm => "Are you sure?", :popup => true
+  # => <a href="http://google.com" onclick="javascript: if (confirm('Are you sure?')) { window.open(this.href); }; return false;">http://google.com</a>
+  def link_to(*args)
+    content, href, options = link_content_href_opts(args)
+    options.update :href => href
+    erb_helper_convert_options_to_javascript!(options)
+    tag(:a, options) { content }
+  end
+  
+  # helper for generating a mailto:
+  # EX: mail_to "me@domain.com"
+  #   # => <a href="mailto:me@domain.com">me@domain.com</a>
+  # EX: mail_to "me@domain.com", nil, :replace_at => "_at_", :replace_dot => "_dot_", :class => "email"
+  #   # => <a href="mailto:me@domain.com" class="email">me_at_domain_dot_com</a>
+  # EX: mail_to "me@domain.com", nil, :replace_at => " [at]", :replace_dot => " [dot] ", :disabled => true
+  #   # => me [at] domain [dot] com
+  # EX: mail_to "me@domain.com", "My email", :cc => "ccaddress@domain.com", :subject => "This is an example email"
+  #   # => <a href="mailto:me@domain.com?cc=ccaddress@domain.com&subject=This%20is%20an%20example%20email">My email</a>
+  def mail_to(*args)
+    content, email, options = link_content_href_opts(args)
+    email_args = [:cc, :bcc, :subject, :body].inject({}) do |args, arg|
+      args[arg] = options.delete(arg) if options.has_key?(arg)
+      args
+    end
+    content.gsub!(/@/, options.delete(:replace_at)) if options.has_key?(:replace_at)
+    content.gsub!(/\./, options.delete(:replace_dot)) if options.has_key?(:replace_dot)
+    options.delete(:disabled) ? content : link_to(content, "mailto: #{email}#{email_args.to_http_query_str}", options)
+  end
+
+  def link_to_function(content, function, opts={})
+    opts ||= {}
+    opts[:href] ||= 'javascript: void(0);'
+    opts[:onclick] = "javascript: #{function}; return false;"
+    link_to content, opts[:href], opts
+  end
+
+  # helper to emulate 'image_tag'
+  # EX : image_tag 'logo.jpg'
+  #  => <img src="/images/logo.jpg" />
+  # EX : image_tag '/better/logo.jpg'
+  #  => <img src="/better/logo.jpg" />
+  def image_tag(source,options={})
+    options[:src] = ['/'].include?(source[0..0]) ? source : "/images/#{source}"
+    tag(:img, options)
+  end
+
+  # helper to emulate activesupport's 'stylesheet_link_tag'
+  # EX : stylesheet_link_tag 'default'
+  #  => <link rel="stylesheet" type="text/css" media="all" href="/stylesheets/default.css">
+  # EX : stylesheet_link_tag 'default', :environment => 'development'
+  #  => <link rel="stylesheet" type="text/css" media="screen" href="/stylesheets/default.css?12345678">
+  # EX : stylesheet_link_tag 'default', :media => 'screen'
+  #  => <link rel="stylesheet" type="text/css" media="screen" href="/stylesheets/default.css">
+  # EX : stylesheet_link_tag 'default', 'test, :media => 'screen'
+  #  => <link rel="stylesheet" type="text/css" media="screen" href="/stylesheets/default.css">
+  #  => <link rel="stylesheet" type="text/css" media="screen" href="/stylesheets/test.css">
+  # EX : stylesheet_link_tag ['default', 'test], :media => 'screen'
+  #  => <link rel="stylesheet" type="text/css" media="screen" href="/stylesheets/default.css">
+  #  => <link rel="stylesheet" type="text/css" media="screen" href="/stylesheets/test.css">
+  # EX : stylesheet_link_tag 'default', '/other_sheets/other', '/other_sheets/another.css'
+  #  => <link rel="stylesheet" type="text/css" media="screen" href="/stylesheets/default.css">
+  #  => <link rel="stylesheet" type="text/css" media="screen" href="/other_sheets/other.css">
+  #  => <link rel="stylesheet" type="text/css" media="screen" href="/other_sheets/another.css">
+  def stylesheet_link_tag(*args)
+    srcs, options = handle_srcs_options(args)
+    options[:rel] ||= "stylesheet"
+    options[:type] ||= "text/css"
+    options[:media] ||=  "all"
+    Array(srcs).collect do |src|
+      #TODO: write sinatra helper to auto set env with Sinatra::Application.environment.to_s
+      options[:href] = build_src_href(src, :default_path => "stylesheets", :extension => ".css", :environment => options.delete(:environment))
+      tag(:link, options)
+    end.join("\n")
+  end
+
+  # helper to emulate 'javascript_tag'
+  def javascript_tag(options={})
+    options[:type] ||= "text/javascript"
+    tag(:script, options) { yield }
+  end
+  
+  # helper to emulate 'javascript_include_tag'
+  # 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(*args)
+    srcs, options = handle_srcs_options(args)
+    options[:type] ||= "text/javascript"
+    Array(srcs).collect do |src|
+      #TODO: write sinatra helper to auto set env with Sinatra::Application.environment.to_s
+      options[:src] = build_src_href(src, :default_path => "javascripts", :extension => ".js", :environment => options.delete(:environment))
+      tag(:script, options) { '' }
+    end.join("\n")
+  end
+
+  def self.included(receiver)
+    receiver.send :include, Useful::ErbHelpers::Tags
+  end
+  
+  private
+  
+  def link_content_href_opts(args)
+    if args[1] && !args[1].kind_of?(::Hash)
+      [args[0], args[1], (args[2] || {})]
+    else
+      [args[0], args[0].dup, (args[1] || {})]
+    end
+  end
+  
+  def handle_srcs_options(args)
+    the_args = args.flatten
+    if the_args.last && the_args.last.kind_of?(::Hash)
+      [the_args[0..-2], the_args.last]
+    else
+      [the_args, {}]
+    end
+  end
+  
+  def build_src_href(src, options)
+    href = ""
+    src = src.to_s
+    href += ['/'].include?(src[0..0]) ? src : "/#{options[:default_path]}/#{src}"
+    href += options[:extension] unless src.include?(options[:extension])
+    href += "?#{Time.now.to_i}" if options[:environment].to_s == 'development'
+    href
+  end
+
+end
+  

data/lib/useful/erb_helpers/proper.rb

@@ -0,0 +1,109 @@
+# Note: these helpers are designed to be actionpack safe
+# => these helpers are included in the useful/rails_extensions/erb
+# => don't put any actionpack helpers in this module
+
+require 'useful/erb_helpers/common'
+require 'useful/erb_helpers/tags'
+require 'useful/ruby_extensions/string' unless ::String.new.respond_to?('ends_with?')
+unless ::Object.new.respond_to?('blank?') && ::Object.new.respond_to?('is_true?') && ::Object.new.respond_to?('returning')
+  require 'useful/ruby_extensions/object'
+end
+
+module Useful; end
+module Useful::ErbHelpers; end
+
+module Useful::ErbHelpers::Proper
+      
+  include Useful::ErbHelpers::Common
+  
+  # This one's a little different than the corresponding actionpack version:
+  # => ie. you don't pass an options string as the 2nd argument
+  # => you, instead, pass a block that should return the desired options string
+  # => ie, proper_select_tag('user') { '<option>test</option>' }
+  def proper_select_tag(name, options={}, &block) 
+    html_name = (options[:multiple].is_true? && !name.to_s.ends_with?("[]")) ? "#{name}[]" : name
+    options[:multiple] = OPTIONS[:multiple] if options[:multiple] == true
+    options[:tag] = 'select'
+    @_out_buf ||= ''
+    @_out_buf << input_tag(nil, html_name, nil, options, &block)
+  end
+
+  # TODO: write tests
+  def proper_check_box_tag(*args)
+    name, value, checked, options = proper_check_radio_options('1', args)
+    options[:id] ||= erb_helper_common_safe_id(name.to_s)
+    options[:checked] = OPTIONS[:checked] if checked
+    label_text = options.delete(:label)
+    unchecked_value = options.delete(:unchecked_value)
+    unchecked_value = '0' if unchecked_value.nil?
+    disable_unchecked_value = options.delete(:disable_unchecked_value)
+    returning html = '' do
+      html << input_tag(:hidden, name, unchecked_value, :id => "#{options[:id]}_hidden") unless disable_unchecked_value.is_true?
+      html << input_tag(:checkbox, name, value, options)
+      html << tag(:label, :for => options[:id]) { label_text } unless label_text.blank?
+    end
+  end
+  
+  # TODO: write tests
+  def proper_radio_button_tag(*args)
+    name, value, checked, options = proper_check_radio_options(nil, args)
+    options[:id] ||= erb_helper_common_safe_id(name.to_s)
+    options[:checked] = OPTIONS[:checked] if checked
+    label_text = options.delete(:label) || value.to_s.humanize
+    label_container_tag = options.delete(:tag) || :span
+    radio_button_str = input_tag(:radio, name, value, options)
+    returning html = '' do
+      html << if label_text.blank?
+        radio_button_str
+      else
+        tag(:label, :for => options[:id]) do
+          radio_button_str + tag(label_container_tag) { label_text }
+        end
+      end
+    end
+  end
+
+  def self.included(receiver)
+    receiver.send :include, Useful::ErbHelpers::Tags
+  end
+  
+  private
+  
+  def proper_check_radio_options(default_value, args)
+    # args should be passed to proper checkbox and radiobutton tags like this:
+    # => name, value, checked, options={}
+    # this allows user to pass only args they care about,
+    # and default the ones they don't care about
+    if case_arg_options_for_length(4, args)
+      # args: name, value, checked, options --OR-- name, value, checked
+      args[1] ||= default_value # default the value
+      args[2] ||= false         # default whether checked
+      args[3] ||= {}            # default the options
+      [args[0], args[1], args[2], args[3]]
+    elsif case_arg_options_for_length(3, args)
+      # args: name, value, options --OR-- name, value
+      args[1] ||= default_value # default the value
+      args[2] ||= {}            # default the options
+      checked = (args[2].delete(:checked) || false) rescue false
+      [args[0], args[1], checked, args[2]]
+    elsif case_arg_options_for_length(2, args)
+      # args: name, options --OR-- name
+      args[1] ||= {}            # default the options
+      value = (args[1].delete(:value) || default_value) rescue default_value
+      checked = (args[1].delete(:checked) || false)  rescue false
+      [args[0], value, checked, args[1]]
+    elsif case_arg_options_for_length(1, args)
+      # args: name
+      # => default everything
+      [args[0], default_value, false, {}]
+    else
+      # this is invalid
+      raise ArgumentError, "please specify 1 to 4 arguments for name, value, checked, and options"
+    end
+  end
+  
+  def case_arg_options_for_length(length, args)
+    args.length == length || (args.length == (length-1) && !(args[(length-2)].kind_of?(::Hash) || args[(length-2)].nil?))
+  end
+
+end

data/lib/useful/erb_helpers/tags.rb

@@ -0,0 +1,64 @@
+# Note: these helpers are designed to be actionpack safe
+# => these helpers are included in the useful/rails_extensions/erb
+# => don't put any actionpack helpers in this module
+
+require 'useful/erb_helpers/common'
+require 'useful/ruby_extensions/object' unless ::Object.new.respond_to?('blank?')
+require 'useful/ruby_extensions/hash' unless ::Hash.new.respond_to?('to_html_attrs')
+
+module Useful; end
+module Useful::ErbHelpers; end
+
+module Useful::ErbHelpers::Tags
+  
+  include Useful::ErbHelpers::Common
+  
+  def clear_tag(options={})
+    options[:tag] ||= :div
+    options[:style] ||= ''
+    options[:style] = "clear:both;#{" #{options[:style]}" unless options[:style].blank?}"
+    tag(options.delete(:tag), options) { '' }
+  end
+
+  # helpers to escape text for html
+  if defined?(::Rack::Utils)
+    include ::Rack::Utils
+    alias_method(:h, :escape_html)
+  end
+  if defined?(:h)
+    # escape tag text content and format for text-like display
+    def h_text(text, opts={})
+      h(text.to_s).
+        gsub(/\r\n?/, "\n").  # \r\n and \r -> \n
+        split("\n").collect do |line|
+          line.nil? ? '': line.sub(/(\s+)?\S*/) {|lead| lead.gsub(/\s/,' ')}
+        end.join("\n"). # change any leading white spaces on a line to ' '
+        gsub(/\n/,'\1<br />') # newlines -> br added
+    end
+  end
+
+  def input_tag(type, name, value=nil, options={}, &block)
+    options[:tag] ||= :input
+    options[:type] = type unless type.nil?
+    unless name.nil?
+      options[:name] = name 
+      options[:id] ||= erb_helper_common_safe_id(name)
+    end
+    options[:value] = value unless value.nil?
+    options[:disabled] = OPTIONS[:disabled] if options[:disabled]
+    if block_given?
+      tag(options.delete(:tag), options) { erb_helper_common_capture(&block) }
+    else
+      tag(options.delete(:tag), options)
+    end
+  end
+
+  # emulator for rails' 'content_tag'
+  # EX : tag(:h1, :title => "shizam") { "shizam" }
+  # => <h1 title="shizam">shizam</h1>
+  def tag(name, options={})
+    "<#{name.to_s}#{" #{options.to_html_attrs}" unless options.empty?}#{block_given? ? ">#{yield}</#{name}" : " /"}>"
+  end
+  
+end      
+

data/lib/useful/erb_helpers.rb

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

data/lib/useful/rails_helpers/environment_tests.rb

@@ -0,0 +1,59 @@
+module Useful; end
+module Useful::RailsExtensions; end
+
+module Useful::RailsExtensions::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
+
+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_helpers/erb.rb

@@ -0,0 +1,3 @@
+require "useful/erb_helpers/tags"
+require "useful/erb_helpers/proper"
+# TODO: do what you have to get them into action view / controller

data/lib/useful/rails_helpers.rb

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

data/lib/useful/ruby_extensions/array.rb

@@ -1,43 +1,42 @@
-module Useful
-  module RubyExtensions
-    module Array
-      
-      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::Array
+  
+  module ClassMethods; end
+  def self.included(klass)
+    klass.extend(ClassMethods) if klass.kind_of?(Class)
+  end
 
-        # 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
+  module ClassMethods
 
-      # 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
+    # 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
 
-      # 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
+  # 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
 
-    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
 
 class Array

data/lib/useful/ruby_extensions/date.rb

@@ -1,16 +1,16 @@
-module Useful
-  module RubyExtensions
-    module Date
-      
-      def week_days_until(end_date)
-        week_days = (1..5)
-        raise ::ArgumentError, "End date cannot be nil." if end_date.nil?
-        raise ::ArgumentError, "End date cannot come before questioned date." if end_date < self
-        (self..end_date).to_a.select{|date| week_days.include?(date.wday)}.length
-      end
+module Useful; end
+module Useful::RubyExtensions; end
 
-    end
+module Useful::RubyExtensions::Date
+  
+  WEEK_DAYS = (1..5)
+  
+  def week_days_between(end_date)
+    raise ::ArgumentError, "End date cannot be nil." if end_date.nil?
+    raise ::ArgumentError, "End date cannot come before questioned date." if end_date < self
+    (self..end_date).to_a.select{|date| WEEK_DAYS.include?(date.wday)}.length
   end
+
 end
 
 class Date

data/lib/useful/ruby_extensions/false_class.rb

@@ -1,18 +1,21 @@
-module Useful
-  module RubyExtensions
-    module FalseClass
-      
-      def to_affirmative
-        "No"
-      end
-      alias :to_casual_s :to_affirmative
+module Useful; end
+module Useful::RubyExtensions; end
 
-      def to_i
-        0
-      end
-    
-    end
+module Useful::RubyExtensions::FalseClass
+  
+  def to_affirmative(abbreviate=false)
+    abbreviate ? "N" : "No"
   end
+  alias :to_casual_s :to_affirmative
+
+  def to_i
+    0
+  end
+  
+  def to_boolean
+    false
+  end
+
 end
 
 class FalseClass

data/lib/useful/ruby_extensions/fixnum.rb

@@ -1,28 +1,59 @@
-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
+module Useful; end
+module Useful::RubyExtensions; end
+
+module Useful::RubyExtensions::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
+  # 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
+  
+  module FromActivesupport
+    # All methods here will yield to their Activesupport versions, if defined
+    
+    # Turns a number into an ordinal string used to denote the position in an
+    # ordered sequence such as 1st, 2nd, 3rd, 4th.
+    #
+    # Examples:
+    #   1.ordinalize     # => "1st"
+    #   2.ordinalize     # => "2nd"
+    #   1003.ordinalize  # => "1003rd"
+    #   1004.ordinalize  # => "1004th"
+    unless 1.respond_to?('ordinalize')
+      def ordinalize
+        if (11..13).include?(self.to_i % 100)
+          "#{self}th"
+        else
+          case self.to_i % 10
+            when 1; "#{self}st"
+            when 2; "#{self}nd"
+            when 3; "#{self}rd"
+            else    "#{self}th"
           end
         end
-        value
       end
-      
     end
+
+  end
+  
+  def self.included(receiver)
+    receiver.send :include, FromActivesupport
   end
+  
 end
 
 class Fixnum