padrino-helpers 0.10.2 → 0.10.3

data/lib/padrino-helpers/format_helpers.rb

@@ -4,6 +4,16 @@ module Padrino
       ##
       # Returns escaped text to protect against malicious content
       #
+      # @param [String] text
+      #   Unsanitized HTML string that needs to be escaped.
+      #
+      # @return [String] HTML with escaped characters.
+      #
+      # @example
+      #   escape_html("<b>Hey<b>") => "&lt;b&gt;Hey&lt;b;gt;"
+      #   h("Me & Bob") => "Me &amp; Bob"
+      #
+      # @api public
       def escape_html(text)
         Rack::Utils.escape_html(text)
       end
@@ -14,6 +24,18 @@ module Padrino
       # Returns escaped text to protect against malicious content
       # Returns blank if the text is empty
       #
+      # @param [String] text
+      #   Unsanitized HTML string that needs to be escaped.
+      # @param [String] blank_text
+      #   Text to return if escaped text is blank.
+      #
+      # @return [String] HTML with escaped characters or the value specified if blank.
+      #
+      # @example
+      #   h!("Me & Bob") => "Me &amp; Bob"
+      #   h!("", "Whoops") => "Whoops"
+      #
+      # @api public
       def h!(text, blank_text = '&nbsp;')
         return blank_text if text.nil? || text.empty?
         h text
@@ -22,6 +44,15 @@ module Padrino
       ##
       # Strips all HTML tags from the html
       #
+      # @param [String] html
+      #   The HTML for which to strip tags.
+      #
+      # @return [String] HTML with tags stripped.
+      #
+      # @example
+      #   strip_tags("<b>Hey</b>") => "Hey"
+      #
+      # @api public
       def strip_tags(html)
         html.gsub(/<\/?[^>]*>/, "") if html
       end
@@ -31,11 +62,20 @@ module Padrino
       # as a paragraph and wrapped in <p> or your own tags. One newline (\n) is considered as a linebreak and a <br /> tag is appended.
       # This method does not remove the newlines from the text.
       #
-      # ==== Examples
+      # @param [String] text
+      #   The simple text to be formatted.
+      # @param [Hash] options
+      #   Formatting options for the text. Can accept html options for the wrapper tag.
+      # @option options [Symbol] :tag (p)
+      #   The html tag to use for formatting newlines.
+      #
+      # @return [String] The text formatted as simple HTML.
       #
+      # @example
       #   simple_format("hello\nworld") # => "<p>hello<br/>world</p>"
       #   simple_format("hello\nworld", :tag => :div, :class => :foo) # => "<div class="foo">hello<br/>world</div>"
       #
+      # @api public
       def simple_format(text, options={})
         t = options.delete(:tag) || :p
         start_tag = tag(t, options.merge(:open => true))
@@ -51,10 +91,19 @@ module Padrino
       # Attempts to pluralize the singular word unless count is 1. If plural is supplied, it will use that when count is > 1,
       # otherwise it will use the Inflector to determine the plural form
       #
-      # ==== Examples
+      # @param [Fixnum] count
+      #   The count which determines pluralization.
+      # @param [String] singular
+      #   The word to be pluralized if appropriate based on +count+.
+      # @param [String] plural
+      #   Explicit pluralized word to be used; if not specified uses inflector.
       #
+      # @return [String] The properly pluralized word.
+      #
+      # @example
       #   pluralize(2, 'person') => '2 people'
       #
+      # @api public
       def pluralize(count, singular, plural = nil)
         "#{count || 0} " + ((count == 1 || count == '1') ? singular : (plural || singular.pluralize))
       end
@@ -63,10 +112,21 @@ module Padrino
       # Truncates a given text after a given :length if text is longer than :length (defaults to 30).
       # The last characters will be replaced with the :omission (defaults to "…") for a total length not exceeding :length.
       #
-      # ==== Examples
+      # @param [String] text
+      #   The text to be truncated.
+      # @param [Hash] options
+      #   Formatting options for the truncation.
+      # @option options [Fixnum] :length (30)
+      #   The number of characters before truncation occurs.
+      # @option options [String] :omission ("...")
+      #   The characters that are placed after the truncated text.
+      #
+      # @return [String] The text truncated after the given number of characters.
       #
+      # @example
       #   truncate("Once upon a time in a world far far away", :length => 8) => "Once upon..."
       #
+      # @api public
       def truncate(text, options={})
         options.reverse_merge!(:length => 30, :omission => "...")
         if text
@@ -75,15 +135,26 @@ module Padrino
           (chars.length > options[:length] ? chars[0...len] + options[:omission] : text).to_s
         end
       end
-      
+
       ##
       # Truncates words of a given text after a given :length if number of words in text is more than :length (defaults to 30).
       # The last words will be replaced with the :omission (defaults to "…") for a total number of words not exceeding :length.
       #
-      # ==== Examples
+      # @param [String] text
+      #   The text to be truncated.
+      # @param [Hash] options
+      #   Formatting options for the truncation.
+      # @option options [Fixnum] :length (30)
+      #   The number of words before truncation occurs.
+      # @option options [String] :omission ("...")
+      #   The characters that are placed after the truncated text.
       #
+      # @return [String] The text truncated after the given number of words.
+      #
+      # @example
       #   truncate_words("Once upon a time in a world far far away", :length => 8) => "Once upon a time in a world far..."
       #
+      # @api public
       def truncate_words(text, options={})
         options.reverse_merge!(:length => 30, :omission => "...")
         if text
@@ -96,10 +167,20 @@ module Padrino
       # Wraps the text into lines no longer than line_width width.
       # This method breaks on the first whitespace character that does not exceed line_width (which is 80 by default).
       #
-      # ==== Examples
+      # @overload word_wrap(text, options={})
+      #   @param [String] text
+      #     The text to be wrapped.
+      #   @param [Hash] options
+      #     Formatting options for the wrapping.
+      #   @option options [Fixnum] :line_width (80)
+      #     The line width before a wrap should occur.
+      #
+      # @return [String] The text with line wraps for lines longer then +line_width+
       #
+      # @example
       #   word_wrap('Once upon a time', :line_width => 8) => "Once upon\na time"
       #
+      # @api public
       def word_wrap(text, *args)
         options = args.extract_options!
         unless args.blank?
@@ -116,16 +197,28 @@ module Padrino
       # Highlights one or more words everywhere in text by inserting it into a :highlighter string.
       #
       # The highlighter can be customized by passing :+highlighter+ as a single-quoted string
-      # with \1 where the phrase is to be inserted (defaults to ’<strong class="highlight">\1</strong>’)
+      # with \1 where the phrase is to be inserted.
       #
-      # ==== Examples
+      # @overload highlight(text, words, options={})
+      #   @param [String] text
+      #     The text that will be searched.
+      #   @param [String] words
+      #     The words to be highlighted in the +text+.
+      #   @param [Hash] options
+      #     Formatting options for the highlight.
+      #   @option options [String] :highlighter (’<strong class="highlight">\1</strong>’)
+      #     The html pattern for wrapping the highlighted words.
       #
-      #   # => Lorem ipsum <strong class="highlight">dolor</strong> sit amet
+      # @return [String] The text with the words specified wrapped with highlighted spans.
+      #
+      # @example
       #   highlight('Lorem ipsum dolor sit amet', 'dolor')
+      #   # => Lorem ipsum <strong class="highlight">dolor</strong> sit amet
       #
-      #   # => Lorem ipsum <span class="custom">dolor</span> sit amet
       #   highlight('Lorem ipsum dolor sit amet', 'dolor', :highlighter => '<span class="custom">\1</span>')
+      #   # => Lorem ipsum <strong class="custom">dolor</strong> sit amet
       #
+      # @api public
       def highlight(text, words, *args)
         options = args.extract_options!
         options.reverse_merge!(:highlighter => '<strong class="highlight">\1</strong>')
@@ -140,7 +233,7 @@ module Padrino
 
       ##
       # Reports the approximate distance in time between two Time or Date objects or integers as seconds.
-      # Set <tt>include_seconds</tt> to true if you want more detailed approximations when distance < 1 min, 29 secs
+      # Set +include_seconds+ to true if you want more detailed approximations when distance < 1 min, 29 secs
       # Distances are reported based on the following table:
       #
       #   0 <-> 29 secs                                                             # => less than a minute
@@ -157,7 +250,7 @@ module Padrino
       #   1 yr, 9 months <-> 2 yr minus 1 sec                                       # => almost 2 years
       #   2 yrs <-> max time or date                                                # => (same rules as 1 yr)
       #
-      # With <tt>include_seconds</tt> = true and the difference < 1 minute 29 seconds:
+      # With +include_seconds+ = true and the difference < 1 minute 29 seconds:
       #   0-4   secs      # => less than 5 seconds
       #   5-9   secs      # => less than 10 seconds
       #   10-19 secs      # => less than 20 seconds
@@ -165,8 +258,20 @@ module Padrino
       #   40-59 secs      # => less than a minute
       #   60-89 secs      # => 1 minute
       #
-      # ==== Examples
+      # @param [Time] from_time
+      #   The time to be compared against +to_time+ in order to approximate the distance.
+      # @param [Time] to_time
+      #   The time to be compared against +from_time+ in order to approximate the distance.
+      # @param [Boolean] include_seconds
+      #   Set true for more detailed approximations.
+      # @param [Hash] options
+      #   Flags for the approximation.
+      # @option options [String] :locale
+      #   The translation locale to be used for approximating the time.
+      #
+      # @return [String] The time formatted as a relative string.
       #
+      # @example
       #   from_time = Time.now
       #   distance_of_time_in_words(from_time, from_time + 50.minutes)        # => about 1 hour
       #   distance_of_time_in_words(from_time, 50.minutes.from_now)           # => about 1 hour
@@ -180,12 +285,12 @@ module Padrino
       #   distance_of_time_in_words(from_time, from_time + 1.year + 3.days)   # => about 1 year
       #   distance_of_time_in_words(from_time, from_time + 3.years + 6.months) # => over 3 years
       #   distance_of_time_in_words(from_time, from_time + 4.years + 9.days + 30.minutes + 5.seconds) # => about 4 years
-      #
       #   to_time = Time.now + 6.years + 19.days
       #   distance_of_time_in_words(from_time, to_time, true)     # => about 6 years
       #   distance_of_time_in_words(to_time, from_time, true)     # => about 6 years
       #   distance_of_time_in_words(Time.now, Time.now)           # => less than a minute
       #
+      # @api public
       def distance_of_time_in_words(from_time, to_time = 0, include_seconds = false, options = {})
         from_time = from_time.to_time if from_time.respond_to?(:to_time)
         to_time = to_time.to_time if to_time.respond_to?(:to_time)
@@ -233,14 +338,19 @@ module Padrino
       ##
       # Like distance_of_time_in_words, but where <tt>to_time</tt> is fixed to <tt>Time.now</tt>.
       #
-      # ==== Examples
+      # @param [Time] from_time
+      #   The time to be compared against now in order to approximate the distance.
+      # @param [Boolean] include_seconds
+      #   Set true for more detailed approximations.
+      #
+      # @return [String] The time formatted as a relative string.
       #
+      # @example
       #   time_ago_in_words(3.minutes.from_now)       # => 3 minutes
       #   time_ago_in_words(Time.now - 15.hours)      # => 15 hours
       #   time_ago_in_words(Time.now)                 # => less than a minute
       #
-      #   from_time = Time.now - 3.days - 14.minutes - 25.seconds     # => 3 days
-      #
+      # @api public
       def time_ago_in_words(from_time, include_seconds = false)
         distance_of_time_in_words(from_time, Time.now, include_seconds)
       end
@@ -248,13 +358,21 @@ module Padrino
       ##
       # Used in xxxx.js.erb files to escape html so that it can be passed to javascript from Padrino
       #
+      # @param [String] html
+      #   The html content to be escaped into javascript compatible format.
+      #
+      # @return [String] The html escaped for javascript passing.
+      #
+      # @example
       #   js_escape_html("<h1>Hey</h1>")
       #
+      # @api public
       def js_escape_html(html_content)
         return '' unless html_content
         javascript_mapping = { '\\' => '\\\\', '</' => '<\/', "\r\n" => '\n', "\n" => '\n', "\r" => '\n', '"' => '\\"', "'" => "\\'" }
         html_content.gsub(/(\\|<\/|\r\n|[\n\r"'])/) { javascript_mapping[$1] }
       end
+
     end # FormatHelpers
   end # Helpers
 end # Padrino

data/lib/padrino-helpers/locale/lv.yml

@@ -0,0 +1,103 @@
+lv:
+  number:
+    # Used in number_with_delimiter()
+    # These are also the defaults for 'currency', 'percentage', 'precision', and 'human'
+    format:
+      # Sets the separator between the units, for more precision (e.g. 1.0 / 2.0 == 0.5)
+      separator: ","
+      # Delimets thousands (e.g. 1,000,000 is a million) (always in groups of three)
+      delimiter: "."
+      # Number of decimals, behind the separator (the number 1 with a precision of 2 gives: 1.00)
+      precision: 2
+
+    # Used in number_to_currency()
+    currency:
+      format:
+        # Where is the currency sign? %u is the currency unit, %n the number (default: $5.00)
+        format: "%u %n"
+        unit: "LVL"
+        # These three are to override number.format and are optional
+        separator: ","
+        delimiter: "."
+        precision: 2
+
+    # Used in number_to_percentage()
+    percentage:
+      format:
+        # These three are to override number.format and are optional
+        # separator:
+        delimiter: ""
+        # precision:
+
+    # Used in number_to_precision()
+    precision:
+      format:
+        # These three are to override number.format and are optional
+        # separator:
+        delimiter: ""
+        # precision:
+
+    # Used in number_to_human_size()
+    human:
+      format:
+        # These three are to override number.format and are optional
+        # separator:
+        delimiter: ""
+        precision: 1
+      storage_units:
+        # Storage units output formatting.
+        # %u is the storage unit, %n is the number (default: 2 MB)
+        format: "%n %u"
+        units:
+          byte:
+            one:   "Baits"
+            other: "Baiti"
+          kb: "KB"
+          mb: "MB"
+          gb: "GB"
+          tb: "TB"
+
+  # Used in distance_of_time_in_words(), distance_of_time_in_words_to_now(), time_ago_in_words()
+  datetime:
+    distance_in_words:
+      half_a_minute: "pusminūte"
+      less_than_x_seconds:
+        one: "mazāk par vienu sekundi"
+        other: "mazāk par %{count} sekundēm"
+      x_seconds:
+        one: "1 sekunde"
+        other: "%{count} sekundes"
+      less_than_x_minutes:
+        one: "mazāk par vienu minūti"
+        other: "mazāk par %{count} minūtēm"
+      x_minutes:
+        one: "1 minūte"
+        other: "%{count} minūtes"
+      about_x_hours:
+        one: "apmēram 1 stunda"
+        other: "apmēram %{count} stundas"
+      x_days:
+        one: "1 diena"
+        other: "%{count} dienas"
+      about_x_months:
+        one: "apmēram 1 mēnesis"
+        other: "apmēram %{count} mēneši"
+      x_months:
+        one: "1 mēnesis"
+        other: "%{count} mēneši"
+      about_x_years:
+        one: "apmēram 1 gads"
+        other: "apmēram %{count} gadi"
+      over_x_years:
+        one: "vairāk kā gads"
+        other: "vairāk kā %{count} gadi"
+      almost_x_years:
+        one:   "gandrīz 1 gads"
+        other: "gandrīz %{count} gadi"
+  models:
+    errors:
+      template:
+        header:
+          one:    "Dēļ 1 kļūdas šis %{model} netika saglabāts"
+          other:  "Dēļ %{count} kļūdām šis %{model} netika saglabāts"
+        body: "Problēmas ir šajos ievades laukos:"

data/lib/padrino-helpers/locale/zh_cn.yml

@@ -57,7 +57,7 @@ zh_cn:
           gb: "GB"
           tb: "TB"
 
-  # Used in distance_of_time_in_words(), distance_of_time_in_words_to_now(), time_ago_in_words() 
+  # Used in distance_of_time_in_words(), distance_of_time_in_words_to_now(), time_ago_in_words()
   datetime:
     distance_in_words:
       half_a_minute: "半分钟"

data/lib/padrino-helpers/number_helpers.rb

@@ -5,35 +5,42 @@ module Padrino
     # Methods are provided for phone numbers, currency, percentage,
     # precision, positional notation, and file size.
     #
-    # Verbatim copy of Rails Number Helpers
+    # Adapted from Rails Number Helpers.
     #
     module NumberHelpers
       ##
       # Formats a +number+ into a currency string (e.g., $13.65). You can customize the format
       # in the +options+ hash.
       #
-      # ==== Options
-      #
-      # :precision:: Sets the level of precision (defaults to 2).
-      # :unit::      Sets the denomination of the currency (defaults to "$").
-      # :separator:: Sets the separator between the units (defaults to ".").
-      # :delimiter:: Sets the thousands delimiter (defaults to ",").
-      # :format::    Sets the format of the output string (defaults to "%u%n"). The field types are:
-      #
+      # @param [Float] number
+      #   Currency value to format.
+      # @param [Hash] options
+      #   Options for currency conversion.
+      # @option options [Fixnum] :precision (2)
+      #   Sets the level of precision.
+      # @option options [String] :unit ("$")
+      #   Sets the denomination of the currency.
+      # @option options [String] :separator (".")
+      #   Sets the separator between the units.
+      # @option options [String] :delimiter (",")
+      #   Sets the thousands delimiter.
+      # @option options [String] :format ("%u%n")
+      #   Sets the format of the output string. The field types are:
       #     %u  The currency unit
       #     %n  The number
       #
-      # ==== Examples
+      # @return [String] The formatted representation of the currency
       #
+      # @example
       #   number_to_currency(1234567890.50)                    # => $1,234,567,890.50
       #   number_to_currency(1234567890.506)                   # => $1,234,567,890.51
       #   number_to_currency(1234567890.506, :precision => 3)  # => $1,234,567,890.506
-      #
       #   number_to_currency(1234567890.50, :unit => "£", :separator => ",", :delimiter => "")
       #   # => £1234567890,50
       #   number_to_currency(1234567890.50, :unit => "£", :separator => ",", :delimiter => "", :format => "%n %u")
       #   # => 1234567890,50 £
       #
+      # @api public
       def number_to_currency(number, options = {})
         options.symbolize_keys!
 
@@ -63,19 +70,26 @@ module Padrino
       # Formats a +number+ as a percentage string (e.g., 65%). You can customize the
       # format in the +options+ hash.
       #
-      # ==== Options
-      #
-      # :precision:: Sets the level of precision (defaults to 3).
-      # :separator:: Sets the separator between the units (defaults to ".").
-      # :delimiter:: Sets the thousands delimiter (defaults to "").
+      # @param [Fixnum, Float] number
+      #   Percentage value to format.
+      # @param [Hash] options
+      #   Options for percentage conversion.
+      # @option options [Fixnum] :precision (3)
+      #   Sets the level of precision.
+      # @option options [String] :separator (".")
+      #   Sets the separator between the units.
+      # @option options [String] :delimiter ("")
+      #   Sets the thousands delimiter
       #
-      # ==== Examples
+      # @return [String] The formatted representation of the percentage
       #
+      # @example
       #   number_to_percentage(100)                                        # => 100.000%
       #   number_to_percentage(100, :precision => 0)                       # => 100%
       #   number_to_percentage(1000, :delimiter => '.', :separator => ',') # => 1.000,000%
       #   number_to_percentage(302.24398923423, :precision => 5)           # => 302.24399%
       #
+      # @api public
       def number_to_percentage(number, options = {})
         options.symbolize_keys!
 
@@ -101,13 +115,19 @@ module Padrino
       # Formats a +number+ with grouped thousands using +delimiter+ (e.g., 12,324). You can
       # customize the format in the +options+ hash.
       #
-      # ==== Options
+      # @overload number_with_delimiter(number, options={})
+      #   @param [Fixnum, Float] number
+      #     Number value to format.
+      #   @param [Hash] options
+      #     Options for formatter.
+      #   @option options [String] :delimiter (", ")
+      #     Sets the thousands delimiter
+      #   @option options [String] :separator (".")
+      #     Sets the separator between the units.
       #
-      # :delimiter:: Sets the thousands delimiter (defaults to ",").
-      # :separator:: Sets the separator between the units (defaults to ".").
-      #
-      # ==== Examples
+      # @return [String] The formatted representation of the number
       #
+      # @example
       #   number_with_delimiter(12345678)                        # => 12,345,678
       #   number_with_delimiter(12345678.05)                     # => 12,345,678.05
       #   number_with_delimiter(12345678, :delimiter => ".")     # => 12.345.678
@@ -115,13 +135,7 @@ module Padrino
       #   number_with_delimiter(98765432.98, :delimiter => " ", :separator => ",")
       #   # => 98 765 432,98
       #
-      # You can still use <tt>number_with_delimiter</tt> with the old API that accepts the
-      # +delimiter+ as its optional second and the +separator+ as its
-      # optional third parameter:
-      #
-      #   number_with_delimiter(12345678, " ")                     # => 12 345.678
-      #   number_with_delimiter(12345678.05, ".", ",")             # => 12.345.678,05
-      #
+      # @api public
       def number_with_delimiter(number, *args)
         options = args.extract_options!
         options.symbolize_keys!
@@ -144,14 +158,21 @@ module Padrino
       # 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.
       #
-      # ==== Options
-      #
-      # :precision:: Sets the level of precision (defaults to 3).
-      # :separator:: Sets the separator between the units (defaults to ".").
-      # :delimiter:: Sets the thousands delimiter (defaults to "").
-      #
-      # ==== Examples
-      #
+      # @overload number_with_precision(number, options={})
+      #   @param [Fixnum, Float] number
+      #     Number value to format.
+      #   @param [Hash] options
+      #     Options for formatter.
+      #   @option options [Fixnum] :precision (3)
+      #     Sets the level of precision.
+      #   @option options [String] :separator (".")
+      #     Sets the separator between the units.
+      #   @option options [String] :delimiter ("")
+      #     Sets the thousands delimiter
+      #
+      # @return [String] The formatted representation of the number
+      #
+      # @example
       #   number_with_precision(111.2345)                    # => 111.235
       #   number_with_precision(111.2345, :precision => 2)   # => 111.23
       #   number_with_precision(13, :precision => 5)         # => 13.00000
@@ -159,11 +180,7 @@ module Padrino
       #   number_with_precision(1111.2345, :precision => 2, :separator => ',', :delimiter => '.')
       #   # => 1.111,23
       #
-      # You can still use <tt>number_with_precision</tt> with the old API that accepts the
-      # +precision+ as its optional second parameter:
-      #
-      #   number_with_precision(number_with_precision(111.2345, 2)   # => 111.23
-      #
+      # @api public
       def number_with_precision(number, *args)
         options = args.extract_options!
         options.symbolize_keys!
@@ -196,14 +213,22 @@ module Padrino
       # +size+ cannot be converted into a number. You can customize the
       # format in the +options+ hash.
       #
-      # ==== Options
       #
-      # :precision:: Sets the level of precision (defaults to 1).
-      # :separator:: Sets the separator between the units (defaults to ".").
-      # :delimiter:: Sets the thousands delimiter (defaults to "").
+      # @overload number_to_human_size(number, options={})
+      #   @param [Fixnum] number
+      #     Number value to format.
+      #   @param [Hash] options
+      #     Options for formatter.
+      #   @option options [Fixnum] :precision (1)
+      #     Sets the level of precision.
+      #   @option options [String] :separator (".")
+      #     Sets the separator between the units.
+      #   @option options [String] :delimiter ("")
+      #     Sets the thousands delimiter
       #
-      # ==== Examples
+      # @return [String] The formatted representation of bytes
       #
+      # @example
       #   number_to_human_size(123)                                          # => 123 Bytes
       #   number_to_human_size(1234)                                         # => 1.2 KB
       #   number_to_human_size(12345)                                        # => 12.1 KB
@@ -214,18 +239,7 @@ module Padrino
       #   number_to_human_size(483989, :precision => 0)                      # => 473 KB
       #   number_to_human_size(1234567, :precision => 2, :separator => ',')  # => 1,18 MB
       #
-      # Zeros after the decimal point are always stripped out, regardless of the
-      # specified precision:
-      #
-      #   helper.number_to_human_size(1234567890123, :precision => 5)        # => "1.12283 TB"
-      #   helper.number_to_human_size(524288000, :precision=>5)              # => "500 MB"
-      #
-      # You can still use <tt>number_to_human_size</tt> with the old API that accepts the
-      # +precision+ as its optional second parameter:
-      #
-      #   number_to_human_size(1234567, 2)    # => 1.18 MB
-      #   number_to_human_size(483989, 0)     # => 473 KB
-      #
+      # @api public
       def number_to_human_size(number, *args)
         return nil if number.nil?