padrino-helpers-cj 0.12.2

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

@@ -0,0 +1,103 @@
+zh_tw:
+  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: "."
+      # Delimits 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: 3
+
+    # 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: "NT$"
+        # 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:   "Byte"
+            other: "Bytes"
+          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: "半分鐘"
+      less_than_x_seconds:
+        one:   "不到一秒"
+        other: "不到 %{count} 秒"
+      x_seconds:
+        one:   "一秒"
+        other: "%{count} 秒"
+      less_than_x_minutes:
+        one:   "不到一分鐘"
+        other: "不到 %{count} 分鐘"
+      x_minutes:
+        one:   "一分鐘"
+        other: "%{count} 分鐘"
+      about_x_hours:
+        one:   "大約一小時"
+        other: "大約 %{count} 小時"
+      x_days:
+        one:   "一天"
+        other: "%{count} 天"
+      about_x_months:
+        one:   "大約一個月"
+        other: "大約 %{count} 個月"
+      x_months:
+        one:   "一個月"
+        other: "%{count} 個月"
+      about_x_years:
+        one:   "大約一年"
+        other: "大約 %{count} 年"
+      over_x_years:
+        one:   "一年多"
+        other: "%{count} 年多"
+      almost_x_years:
+        one:   "接近一年"
+        other: "接近 %{count} 年"
+  models:
+    errors:
+      template:
+        header:
+          one:    "發生了 1 個錯誤使得「%{model}」無法被儲存。"
+          other:  "發生了 %{count} 個錯誤使得「%{model}」無法被儲存。"
+        body: "以下欄位發生問題："

data/lib/padrino-helpers/number_helpers.rb

@@ -0,0 +1,283 @@
+module Padrino
+  module Helpers
+    ##
+    # Provides methods for converting numbers into formatted strings.
+    # Methods are provided for phone numbers, currency, percentage,
+    # precision, positional notation, and file size.
+    #
+    # 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.
+      #
+      # @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
+      #
+      # @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 £
+      #
+      def number_to_currency(number, options = {})
+        options.symbolize_keys!
+
+        defaults  = I18n.translate(:'number.format', :locale => options[:locale], :raise => true) rescue {}
+        currency  = I18n.translate(:'number.currency.format', :locale => options[:locale], :raise => true) rescue {}
+        defaults  = defaults.merge(currency)
+
+        precision = options[:precision] || defaults[:precision]
+        unit      = options[:unit]      || defaults[:unit]
+        separator = options[:separator] || defaults[:separator]
+        delimiter = options[:delimiter] || defaults[:delimiter]
+        format    = options[:format]    || defaults[:format]
+        separator = '' if precision == 0
+
+        begin
+          format.gsub(/%n/, number_with_precision(number,
+            :precision => precision,
+            :delimiter => delimiter,
+            :separator => separator)
+          ).gsub(/%u/, unit)
+        rescue
+          number
+        end
+      end
+
+      ##
+      # Formats a +number+ as a percentage string (e.g., 65%). You can customize the
+      # format in the +options+ hash.
+      #
+      # @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.
+      #
+      # @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%
+      #
+      def number_to_percentage(number, options = {})
+        options.symbolize_keys!
+
+        defaults   = I18n.translate(:'number.format', :locale => options[:locale], :raise => true) rescue {}
+        percentage = I18n.translate(:'number.percentage.format', :locale => options[:locale], :raise => true) rescue {}
+        defaults  = defaults.merge(percentage)
+
+        precision = options[:precision] || defaults[:precision]
+        separator = options[:separator] || defaults[:separator]
+        delimiter = options[:delimiter] || defaults[:delimiter]
+
+        begin
+          number_with_precision(number,
+            :precision => precision,
+            :separator => separator,
+            :delimiter => delimiter) + "%"
+        rescue
+          number
+        end
+      end
+
+      ##
+      # Formats a +number+ with grouped thousands using +delimiter+ (e.g., 12,324). You can
+      # customize the format in the +options+ hash.
+      #
+      # @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.
+      #
+      # @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
+      #   number_with_delimiter(12345678, :separator => ",")     # => 12,345,678
+      #   number_with_delimiter(98765432.98, :delimiter => " ", :separator => ",")
+      #   # => 98 765 432,98
+      #
+      def number_with_delimiter(number, *args)
+        options = args.extract_options!
+        options.symbolize_keys!
+
+        defaults = I18n.translate(:'number.format', :locale => options[:locale], :raise => true) rescue {}
+
+        delimiter ||= (options[:delimiter] || defaults[:delimiter])
+        separator ||= (options[:separator] || defaults[:separator])
+
+        begin
+          parts = number.to_s.split('.')
+          parts[0].gsub!(/(\d)(?=(\d\d\d)+(?!\d))/, "\\1#{delimiter}")
+          parts.join(separator)
+        rescue
+          number
+        end
+      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.
+      #
+      # @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
+      #   number_with_precision(389.32314, :precision => 0)  # => 389
+      #   number_with_precision(1111.2345, :precision => 2, :separator => ',', :delimiter => '.')
+      #   # => 1.111,23
+      #
+      def number_with_precision(number, *args)
+        options = args.extract_options!
+        options.symbolize_keys!
+
+        defaults           = I18n.translate(:'number.format', :locale => options[:locale], :raise => true) rescue {}
+        precision_defaults = I18n.translate(:'number.precision.format', :locale => options[:locale],
+                                                                        :raise => true) rescue {}
+        defaults           = defaults.merge(precision_defaults)
+
+        precision ||= (options[:precision] || defaults[:precision])
+        separator ||= (options[:separator] || defaults[:separator])
+        delimiter ||= (options[:delimiter] || defaults[:delimiter])
+
+        begin
+          rounded_number = (Float(number) * (10 ** precision)).round.to_f / 10 ** precision
+          number_with_delimiter("%01.#{precision}f" % rounded_number,
+            :separator => separator,
+            :delimiter => delimiter)
+        rescue
+          number
+        end
+      end
+
+      # The units available for storage formatting.
+      STORAGE_UNITS = [:byte, :kb, :mb, :gb, :tb].freeze
+
+      ##
+      # 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.
+      #
+      #
+      # @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.
+      #
+      # @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
+      #   number_to_human_size(1234567)                                      # => 1.2 MB
+      #   number_to_human_size(1234567890)                                   # => 1.1 GB
+      #   number_to_human_size(1234567890123)                                # => 1.1 TB
+      #   number_to_human_size(1234567, :precision => 2)                     # => 1.18 MB
+      #   number_to_human_size(483989, :precision => 0)                      # => 473 KB
+      #   number_to_human_size(1234567, :precision => 2, :separator => ',')  # => 1,18 MB
+      #
+      def number_to_human_size(number, *args)
+        return nil if number.nil?
+
+        options = args.extract_options!
+        options.symbolize_keys!
+
+        defaults = I18n.translate(:'number.format', :locale => options[:locale], :raise => true) rescue {}
+        human    = I18n.translate(:'number.human.format', :locale => options[:locale], :raise => true) rescue {}
+        defaults = defaults.merge(human)
+
+        precision ||= (options[:precision] || defaults[:precision])
+        separator ||= (options[:separator] || defaults[:separator])
+        delimiter ||= (options[:delimiter] || defaults[:delimiter])
+
+        storage_units_format = I18n.translate(:'number.human.storage_units.format', :locale => options[:locale], :raise => true)
+
+        if number.to_i < 1024
+          unit = I18n.translate(:'number.human.storage_units.units.byte', :locale => options[:locale], :count => number.to_i, :raise => true)
+          storage_units_format.gsub(/%n/, number.to_i.to_s).gsub(/%u/, unit)
+        else
+          max_exp  = STORAGE_UNITS.size - 1
+          number   = Float(number)
+          exponent = (Math.log(number) / Math.log(1024)).to_i # Convert to base 1024
+          exponent = max_exp if exponent > max_exp # we need this to avoid overflow for the highest unit
+          number  /= 1024 ** exponent
+
+          unit_key = STORAGE_UNITS[exponent]
+          unit = I18n.translate(:"number.human.storage_units.units.#{unit_key}", :locale => options[:locale], :count => number, :raise => true)
+
+          begin
+            escaped_separator = Regexp.escape(separator)
+            formatted_number = number_with_precision(number,
+              :precision => precision,
+              :separator => separator,
+              :delimiter => delimiter
+            ).sub(/(#{escaped_separator})(\d*[1-9])?0+\z/, '\1\2').sub(/#{escaped_separator}\z/, '')
+            storage_units_format.gsub(/%n/, formatted_number).gsub(/%u/, unit)
+          rescue
+            number
+          end
+        end
+      end
+    end
+  end
+end

data/lib/padrino-helpers/output_helpers.rb

@@ -0,0 +1,226 @@
+module Padrino
+  module Helpers
+    ##
+    # Helpers related to buffer output for various template engines.
+    #
+    module OutputHelpers
+      def self.included(base)
+        base.send(:include, SinatraCurrentEngine) unless base.method_defined?(:current_engine)
+      end
+
+      ##
+      # Returns the list of all available template handlers.
+      #
+      def self.handlers
+        @_template_handlers ||= {}
+      end
+
+      ##
+      # Registers a new handler as available to the output helpers.
+      #
+      def self.register(engine, handler)
+        handlers[engine] = handler
+      end
+
+      ##
+      # Module used to detect the current engine in vanilla Sinatra apps.
+      #
+      module SinatraCurrentEngine
+        attr_reader :current_engine
+
+        def render(engine, *)
+          @current_engine, engine_was = engine, @current_engine
+          output = super
+          @current_engine = engine_was
+          output
+        end
+      end
+
+      ##
+      # Captures the html from a block of template code for any available handler.
+      #
+      # Be aware that trusting the html is up to the caller.
+      #
+      # @param [Object] *args
+      #   Objects yield to the captured block.
+      # @param [Proc] &block
+      #   Template code to capture as HTML.
+      #
+      # @return [String] Captured HTML resulting from the block.
+      #
+      # @example
+      #   capture_html(&block) => "...html..."
+      #   capture_html(object_for_block, &block) => "...html..."
+      #
+      # @example
+      #   ActiveSupport::SafeBuffer.new + capture_html { "<foo>" }
+      #   # => "&lt;foo&gt;"
+      #   ActiveSupport::SafeBuffer.new.safe_concat(capture_html { "<foo>" })
+      #   # => "<foo>"
+      #
+      def capture_html(*args, &block)
+        if handler = find_proper_handler
+          handler.capture_from_template(*args, &block)
+        else
+          block.call(*args)
+        end
+      end
+      alias :capture :capture_html
+
+      ##
+      # Outputs the given text to the templates buffer directly.
+      #
+      # The output might be subject to escaping, if it is not marked as safe.
+      #
+      # @param [String, SafeBuffer] text
+      #   Text to concatenate to the buffer.
+      #
+      # @example
+      #   concat_content("This will be output to the template buffer")
+      #
+      def concat_content(text="")
+        if handler = find_proper_handler
+          handler.concat_to_template(text)
+        else
+          text
+        end
+      end
+      alias :concat :concat_content
+
+      ##
+      # Outputs the given text to the templates buffer directly,
+      # assuming that it is safe.
+      #
+      # @param [String] text
+      #   Text to concatenate to the buffer.
+      #
+      # @example
+      #   concat_safe_content("This will be output to the template buffer")
+      #
+      def concat_safe_content(text="")
+        concat_content text.html_safe
+      end
+
+      ##
+      # Returns true if the block is from a supported template type; false otherwise.
+      # Used to determine if html should be returned or concatenated to the view.
+      #
+      # @param [Block] block
+      #   Determine if this block is a view template.
+      #
+      # @example
+      #   block_is_template?(block) => true
+      #
+      # @return [Boolean] True if the block is a template; false otherwise.
+      #
+      def block_is_template?(block)
+        handler = find_proper_handler
+        block && handler && handler.engine_matches?(block)
+      end
+
+      ##
+      # Capture a block or text of content to be rendered at a later time.
+      # Your blocks can also receive values, which are passed to them by <tt>yield_content</tt>.
+      #
+      # @overload content_for(key, content)
+      #   @param [Symbol] key      Name of your key for the content yield.
+      #   @param [String] content  Text to be stored for this key.
+      #   @param [Hash]   options  Options associated with this method.
+      # @overload content_for(key, &block)
+      #   @param [Symbol] key      Name of your key for the content yield.
+      #   @param [Proc]   block    Block to be stored as content for this key.
+      #   @param [Hash]   options  Options associated with this method.
+      #
+      # @option options [Boolean] :flush
+      #   Specifies whether to replace the content.
+      #
+      # @example
+      #   content_for(:name) { ...content... }
+      #   content_for(:name) { |name| ...content... }
+      #   content_for(:name, "I'm Jeff")
+      #   content_for(:name, :flush => true) { ...new content... }
+      #
+      def content_for(key, content = nil, options = {}, &block)
+        options = content if content.is_a?(Hash)
+        content_blocks[key.to_sym].clear if options[:flush]
+        content_blocks[key.to_sym] << (block_given? ? block : Proc.new { content })
+      end
+
+      ##
+      # Is there a content block for a given key?
+      #
+      # @param [Symbol] key
+      #   Name of content to yield.
+      #
+      # @return [TrueClass,FalseClass] Result html for the given +key+
+      #
+      # @example
+      #   content_for? :header => true
+      #
+      def content_for?(key)
+        !content_blocks[key.to_sym].empty?
+      end
+
+      ##
+      # Render the captured content blocks for a given key.
+      # You can also pass values to the content blocks by passing them
+      # as arguments after the key.
+      #
+      # @param [Symbol] key
+      #   Name of content to yield.
+      # @param *args
+      #   Values to pass to the content block.
+      #
+      # @return [String] Result HTML for the given +key+.
+      #
+      # @example
+      #   yield_content :include
+      #   yield_content :head, "param1", "param2"
+      #   yield_content(:title) || "My page title"
+      #
+      def yield_content(key, *args)
+        blocks = content_blocks[key.to_sym]
+        return nil if blocks.empty?
+        blocks.inject(ActiveSupport::SafeBuffer.new){ |all,content| all << capture_html(*args, &content) }
+      end
+
+      protected
+      ##
+      # Retrieves content_blocks stored by content_for or within yield_content.
+      #
+      # @example
+      #   content_blocks[:name] => ['...', '...']
+      #
+      def content_blocks
+        @content_blocks ||= Hash.new { |h,k| h[k] = [] }
+      end
+
+      ##
+      # Retrieves the template handler for the given output context.
+      # Can handle any output related to capturing or concatenating in a given template.
+      #
+      # @example
+      #   find_proper_handler => <OutputHelpers::HamlHandler>
+      #
+      def find_proper_handler
+        handler_class = OutputHelpers.handlers[current_engine]
+        handler_class && handler_class.new(self)
+      end
+
+      ##
+      # Marks a String or a collection of Strings as safe. `nil` is accepted
+      # but ignored.
+      #
+      # @param [String, Array<String>] the values to be marked safe.
+      #
+      # @return [ActiveSupport::SafeBuffer, Array<ActiveSupport::SafeBuffer>]
+      def mark_safe(value)
+        if value.respond_to? :map!
+          value.map!{|v| v.html_safe if v }
+        else
+          value.html_safe if value
+        end
+      end
+    end
+  end
+end