middleman 2.0.7 → 2.0.8

data/lib/middleman/vendor/padrino-helpers-0.10.0/lib/padrino-helpers/locale/zh_tw.yml

@@ -1,103 +0,0 @@
-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

@@ -1,273 +0,0 @@
-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

@@ -1,128 +0,0 @@
-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