middleman 2.0.4 → 2.0.5

data/lib/middleman/vendor/padrino-helpers-0.10.0/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: "."
+      # 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: 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/middleman/vendor/padrino-helpers-0.10.0/lib/padrino-helpers/number_helpers.rb

@@ -0,0 +1,273 @@
+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.
+    #
+    # Verbatim copy of 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:
+      #
+      #     %u  The currency unit
+      #     %n  The number
+      #
+      # ==== Examples
+      #
+      #   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.
+      #
+      # ==== 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
+      #
+      #   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.
+      #
+      # ==== Options
+      #
+      # :delimiter:: Sets the thousands delimiter (defaults to ",").
+      # :separator:: Sets the separator between the units (defaults to ".").
+      #
+      # ==== Examples
+      #
+      #   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
+      #
+      # 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
+      #
+      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.
+      #
+      # ==== 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
+      #
+      #   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
+      #
+      # 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
+      #
+      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
+
+      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.
+      #
+      # ==== 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 "").
+      #
+      # ==== Examples
+      #
+      #   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
+      #
+      # 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
+      #
+      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 # NumberHelpers
+  end # Helpers
+end # Padrino

data/lib/middleman/vendor/padrino-helpers-0.10.0/lib/padrino-helpers/output_helpers.rb

@@ -0,0 +1,128 @@
+module Padrino
+  module Helpers
+    module OutputHelpers
+
+      def self.included(base) #:nodoc:
+        base.send(:include, SinatraCurrentEngine) unless base.method_defined?(:current_engine)
+      end
+
+      ##
+      # Module used to detect in vanilla sinatra apps the current engine
+      #
+      module SinatraCurrentEngine
+        attr_reader :current_engine
+
+        def render(engine, *) #:nodoc:
+          @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
+      #
+      # ==== Examples
+      #
+      #   capture_html(&block) => "...html..."
+      #
+      def capture_html(*args, &block)
+        handler = find_proper_handler
+        captured_html = ""
+        if handler && handler.is_type? && handler.block_is_type?(block)
+          captured_html = handler.capture_from_template(*args, &block)
+        end
+        # invoking the block directly if there was no template
+        captured_html = block_given? && block.call(*args) if captured_html.blank?
+        captured_html
+      end
+      alias :capture :capture_html
+
+      ##
+      # Outputs the given text to the templates buffer directly
+      #
+      # ==== Examples
+      #
+      #   concat_content("This will be output to the template buffer")
+      #
+      def concat_content(text="")
+        handler = find_proper_handler
+        if handler && handler.is_type?
+          handler.concat_to_template(text)
+        else # theres no template to concat, return the text directly
+          text
+        end
+      end
+      alias :concat :concat_content
+
+      ##
+      # 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
+      #
+      # ==== Examples
+      #
+      #   block_is_template?(block)
+      #
+      def block_is_template?(block)
+        handler = find_proper_handler
+        block && handler && handler.block_is_type?(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>
+      #
+      # ==== Examples
+      #
+      #   content_for(:name) { ...content... }
+      #   content_for(:name) { |name| ...content... }
+      #   content_for(:name, "I'm Jeff")
+      #
+      def content_for(key, content = nil, &block)
+        content_blocks[key.to_sym] << (block_given? ? block : Proc.new { content })
+      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.
+      #
+      # ==== Examples
+      #
+      #   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.map { |content| capture_html(*args, &content) }.join
+      end
+
+      protected
+        ##
+        # Retrieves content_blocks stored by content_for or within yield_content
+        #
+        # ==== Examples
+        #
+        #   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 concating in a given template.
+        #
+        # ==== Examples
+        #
+        #   find_proper_handler => <OutputHelpers::HamlHandler>
+        #
+        def find_proper_handler
+          OutputHelpers.handlers.map { |h| h.new(self) }.find { |h| h.engines.include?(current_engine) && h.is_type? }
+        end
+    end # OutputHelpers
+  end # Helpers
+end # Padrino