numerals 0.1.0 → 0.2.0

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA1:
-  metadata.gz: 0e7931e88c73e54a2d95c47f45d222562dc03a02
-  data.tar.gz: 0179555b287f177e458d854708929838c9619bcc
+  metadata.gz: 0e87d9faabf0392f12d84d026d85d480aa67d32c
+  data.tar.gz: 67b89570a8c97ae4abe727c730bdc77099ca70d0
 SHA512:
-  metadata.gz: fbdfea7324a61b2d25888c0553acefac0911e97ed9ddd5e9217064694f1f66fefea0ba968941cead3634e0b9c5a4bfa55e12cfcb16896c42407f057724446580
-  data.tar.gz: ea99d01ee36c91692c926d64f022e08274f89b0a3f4f4eb96f0a4dcaaac1c4340c1c6484d9a1b29f235ae370a2fce903624b1e5656f3297ee1026728cf4d6b87
+  metadata.gz: 3c3b97ef87dcda6dec5dce9a8d8449da8b8da3c5faab0664ab4563dfb32f4770b9295271454c6e9c2efbec2be3b72843cf12c6f2d48395e36c7474b8d6be886c
+  data.tar.gz: 6ff01ddb162578b80b30596adfd38be3fb992509b8ff7aa32018b98815dae4e2449770313728647e9b8af0110e6a0cd4078edc1f4d01754a91a3205ceb7cd93a

data/README.md

@@ -161,8 +161,10 @@ Done:
 * Handling of 'unsignificant' digits: show them either as special
   symbol, as zeros or omit them (comfigured in Symbols)
 
-Pending:
-
 * Padding aspect of formatting on output
 
 * Show base indicators on output
+
+Pending:
+
+* HTML & Latex Input/Output

data/lib/numerals/format/format.rb

@@ -60,6 +60,14 @@ module Numerals
       @rounding.base
     end
 
+    def padding
+      @symbols.padding
+    end
+
+    def padded?
+      padding.padded?
+    end
+
     # Presentation base for the significand
     def significand_base
       base**@mode.base_scale
@@ -94,6 +102,7 @@ module Numerals
       @rounding.set! places: options[:places] if options[:places]
       @symbols.set! repeating: options[:repeating] if options.has_key?(:repeating)
       @symbols.set! case_sensitive: options[:case_sensitive] if options.has_key?(:case_sensitive)
+      @symbols.set! padding: options[:padding] if options[:padding]
     end
 
     def parameters
@@ -130,6 +139,10 @@ module Numerals
       set! rounding: args
     end
 
+    aspect :padding do |*args|
+      set! padding: args
+    end
+
     aspect :base do |base|
       set! base: base
     end
@@ -200,6 +213,10 @@ module Numerals
       @symbols.set_minus!(minus)
     end
 
+    aspect :leading_zeros do |width|
+      @symbols.set_leading_zeros! width
+    end
+
     private
 
     def extract_options(*args)
@@ -217,6 +234,8 @@ module Numerals
           options[:symbols] = arg
         when Symbols::Digits
           options[:digits] = arg
+        when Symbols::Padding
+          options[:padding] = arg
         when Format
           options.merge! arg.parameters
         when :exact_input
@@ -230,7 +249,7 @@ module Numerals
               sci_int_digits: 1
             },
             symbols: {
-              exponent: 'p'
+              exponent: 'p', base_prefix: '0x'
             }
           )
         when :gen, :general, :sci, :scientific, :fix; :fixed

data/lib/numerals/format/notations/html.rb

@@ -12,20 +12,31 @@ module Numerals
         # <span class=”numerals-num”>1.23<span class="numerals-rep">456</span> &times;10<span class="numerals-sup">9</span></span>
         # .numerals-rep { text-decoration: overline; }
         # .numerals-sup { vertical-align: super; }
+        # TODO: padding
         if text_parts.special?
           output << escape(text_parts.special)
         else
           output << escape(text_parts.sign)
+          if format.symbols.base_prefix
+            output << format.symbols.base_prefix
+          end
           output << escape(text_parts.integer) # or decide here if empty integer part is show as 0?
-          unless !text_parts.fractional? &&
-                 !text_parts.repeat? &&
-                 !format.symbols.show_point
+          if text_parts.show_point?(format)
             output << escape(format.symbols.point)
           end
           output << escape(text_parts.fractional)
           if text_parts.repeat
             output << %(<span style="text-decoration: overline">#{escape(text_parts.repeat)}</span>)
           end
+          if format.symbols.base_suffix || format.base != 10
+            if format.symbols.base_prefix
+              output << format.symbols.base_suffix
+            else
+              # show base suffix as a subscript
+              subscript = format.symbols.base_suffix || base.to_s
+º             output << "<sub>#{subscript}</sub>"
+            end
+          end
           if text_parts.exponent_value != 0 || format.mode.mode == :scientific
             output << "&times;"
             output << escape(text_parts.exponent_base)

data/lib/numerals/format/notations/latex.rb

@@ -6,20 +6,31 @@ module Numerals
 
       def assemble(output, text_parts)
         # 1.23\overline{456}\times10^{9}
+        # TODO: padding
         if text_parts.special?
           output << text_parts.special
         else
           output << text_parts.sign
+          if format.symbols.base_prefix
+            output << format.symbols.base_prefix
+          end
           output << text_parts.integer # or decide here if empty integer part is shown as 0?
-          unless !text_parts.fractional? &&
-                 !text_parts.repeat? &&
-                 !format.symbols.show_point
+          if text_parts.show_point?(format)
             output << format.symbols.point
           end
           output << text_parts.fractional
           if text_parts.repeat?
             output << "\\overline{#{text_parts.repeat}}"
           end
+          if format.symbols.base_suffix || format.base != 10
+            if format.symbols.base_prefix
+              output << format.symbols.base_suffix
+            else
+              # show base suffix as a subscript
+              subscript = format.symbols.base_suffix || base.to_s
+              output << "_{#{subscript}}"
+            end
+          end
           if text_parts.exponent_value != 0 || format.mode.mode == :scientific
             output << "\\times"
             output << text_parts.exponent_base

data/lib/numerals/format/notations/text.rb

@@ -8,35 +8,12 @@ module Numerals
         if text_parts.special?
           output << text_parts.special
         else
-          output << text_parts.sign
-          output << text_parts.integer # or decide here if empty integer part is show as 0?
-          unless !text_parts.fractional? &&
-                 !text_parts.repeat? &&
-                 !format.symbols.show_point
-            output << format.symbols.point
-          end
-          output << text_parts.fractional
-          if text_parts.repeat?
-            if format.symbols.repeat_delimited
-              output << format.symbols.repeat_begin
-              output << text_parts.repeat
-              output << format.symbols.repeat_end
-            else
-              n = RepeatDetector.min_repeat_count(
-                    text_parts.numeral.digits.digits_array,
-                    text_parts.numeral.repeat,
-                    format.symbols.repeat_count - 1
-                  )
-              n.times do
-                output << text_parts.repeat
-              end
-              output << format.symbols.repeat_suffix
-            end
-          end
-          if text_parts.exponent_value != 0 || format.mode.mode == :scientific
-            output << format.symbols.exponent
-            output << text_parts.exponent
+          if format.symbols.padding.padded?
+            output_size = OutputSize.new
+            assemble_parts(output_size, text_parts)
+            left_padding, internal_padding, right_padding = format.symbols.paddings(output_size.size)
           end
+          assemble_parts(output, text_parts, left_padding, internal_padding, right_padding)
         end
       end
 
@@ -57,11 +34,13 @@ module Numerals
           valid = true
           base = format.significand_base
           # TODO: replace numbered groups by named variables ?<var>
-          # TODO: ignore padding, admit base indicators
           regular = /
             \A
+            #{s.regexp(:fill, no_capture: true, optional: true, multiple: true)}
             #{s.regexp(:plus, :minus)}?
             \s*
+            #{s.regexp(:fill, no_capture: true, optional: true, multiple: true)}
+            #{s.regexp(:base_prefix, no_capture: true, optional: true)}
             (?:
               (?:(#{s.regexp(:grouped_digits, base: base, no_capture: true)}+)#{s.regexp(:point)}?)
               |
@@ -70,7 +49,9 @@ module Numerals
             (#{s.regexp(:digits, base: base, no_capture: true)}*)
             (?:#{s.regexp(:repeat_begin)}(#{s.regexp(:digits, base: base, no_capture: true)}+)#{s.regexp(:repeat_end)})?
             #{s.regexp(:repeat_suffix)}?
+            #{s.regexp(:base_suffix, no_capture: true, optional: true)}
             (?:#{s.regexp(:exponent)}#{s.regexp(:plus, :minus)}?(\d+))?
+            #{s.regexp(:fill, no_capture: true, optional: true, multiple: true)}
             \Z
           /x
           unless s.case_sensitive?
@@ -132,6 +113,57 @@ module Numerals
         text_parts
       end
 
+      private
+
+      class OutputSize
+        def initialize
+          @size = 0
+        end
+        def <<(text)
+          @size += text.size
+        end
+        attr_reader :size
+      end
+
+      def assemble_parts(output, text_parts, left_padding='', internal_padding='', right_padding='')
+        output << left_padding
+        output << text_parts.sign
+        if format.symbols.base_prefix
+          output << format.symbols.base_prefix
+        end
+        output << internal_padding
+        output << text_parts.integer # or decide here if empty integer part is show as 0?
+        if text_parts.show_point?(format)
+          output << format.symbols.point
+        end
+        output << text_parts.fractional
+        if text_parts.repeat?
+          if format.symbols.repeat_delimited
+            output << format.symbols.repeat_begin
+            output << text_parts.repeat
+            output << format.symbols.repeat_end
+          else
+            n = RepeatDetector.min_repeat_count(
+                  text_parts.numeral.digits.digits_array,
+                  text_parts.numeral.repeat,
+                  format.symbols.repeat_count - 1
+                )
+            n.times do
+              output << text_parts.repeat
+            end
+            output << format.symbols.repeat_suffix
+          end
+        end
+        if format.symbols.base_suffix
+          output << format.symbols.base_suffix
+        end
+        if text_parts.exponent_value != 0 || format.mode.mode == :scientific
+          output << format.symbols.exponent
+          output << text_parts.exponent
+        end
+        output << right_padding
+      end
+
     end
 
     define_notation :text, TextNotation

data/lib/numerals/format/output.rb

@@ -153,8 +153,6 @@ module Numerals
         text_parts.exponent_base = num_parts.exponent_base.to_s(10) # use digits_definition ?
         text_parts.exponent_base_value = num_parts.exponent_base
       end
-      # TODO: justification
-      # TODO: base indicator for significand? significand_bas?
       text_parts
     end
 

data/lib/numerals/format/symbols.rb

@@ -11,158 +11,6 @@ module Numerals
   #
   class Format::Symbols < FormattingAspect
 
-    class Digits < FormattingAspect
-
-      DEFAULT_DIGITS = %w(0 1 2 3 4 5 6 7 8 9 A B C D E F G H I J K L M N O P Q R S T U V W X Y Z)
-
-      def initialize(*args)
-        @digits = DEFAULT_DIGITS
-        @downcase_digits = @digits.map(&:downcase)
-        @max_base = @digits.size
-        @case_sensitive = false
-        @uppercase = false
-        @lowercase = false
-        set! *args
-      end
-
-      include ModalSupport::StateEquivalent
-
-      set do |*args|
-        options = extract_options(*args)
-        options.each do |option, value|
-          send :"#{option}=", value
-        end
-      end
-
-      attr_reader :digits_string, :max_base, :case_sensitive, :uppercase, :lowercase
-      attr_writer :case_sensitive
-
-      def digits(options = {})
-        base = options[:base] || @max_base
-        if base >= @max_base
-          @digits
-        else
-          @digits[0, base]
-        end
-      end
-
-      def digits=(digits)
-        if digits.is_a?(String)
-          @digits = digits.each_char.to_a
-        else
-          @digits = digits
-        end
-        @max_base = @digits.size
-        @lowercase = @digits.all? { |d| d.downcase == d }
-        @uppercase = @digits.all? { |d| d.upcase == d }
-        @downcase_digits = @digits.map(&:downcase)
-        if @digits.uniq.size != @max_base
-          raise "Inconsistent digits"
-        end
-      end
-
-      def uppercase=(v)
-        @uppercase = v
-        self.digits = @digits.map(&:upcase) if v
-      end
-
-      def lowercase=(v)
-        @lowercase = v
-        self.digits = @digits.map(&:downcase) if v
-      end
-
-      def case_sensitive?
-        case_sensitive
-      end
-
-      def is_digit?(digit_symbol, options={})
-        base = options[:base] || @max_base
-        raise "Invalid base" if base > @max_base
-        v = digit_value(digit_symbol)
-        v && v < base
-      end
-
-      def digit_value(digit)
-        if @case_sensitive
-          @digits.index(digit)
-        else
-          @downcase_digits.index(digit.downcase)
-        end
-      end
-
-      def digit_symbol(v, options={})
-        base = options[:base] || @max_base
-        raise "Invalid base" if base > @max_base
-        v >= 0 && v < base ? @digits[v] : nil
-      end
-
-      # Convert sequence of digits to its text representation.
-      # The nil value can be used in the digits sequence to
-      # represent the group separator.
-      def digits_text(digit_values, options={})
-        insignificant_digits = options[:insignificant_digits] || 0
-        num_digits = digit_values.reduce(0) { |num, digit|
-          digit.nil? ? num : num + 1
-        }
-        num_digits -= insignificant_digits
-        digit_values.map { |d|
-          if d.nil?
-            options[:separator]
-          else
-            num_digits -= 1
-            if num_digits >= 0
-              digit_symbol(d, options)
-            else
-              options[:insignificant_symbol]
-            end
-          end
-        }.join
-      end
-
-      def parameters
-        params = {}
-        params[:digits] = @digits
-        params[:case_sensitive] = @case_sensitive
-        params[:uppercase] = @uppercase
-        params[:lowercase] = @lowercase
-        params
-      end
-
-      def to_s
-        # TODO: show only non-defaults
-        "Digits[#{parameters.inspect.unwrap('{}')}]"
-      end
-
-      def inspect
-        "Format::Symbols::#{self}"
-      end
-
-      def dup
-        Digits[parameters]
-      end
-
-      private
-
-      def extract_options(*args)
-        options = {}
-        args = args.first if args.size == 1 && args.first.kind_of?(Array)
-        args.each do |arg|
-          case arg
-          when Hash
-            options.merge! arg
-          when String, Array
-            options[:digits] = arg
-          when Format::Symbols::Digits
-            options.merge! arg.parameters
-          else
-            raise "Invalid Symbols::Digits definition"
-          end
-        end
-        options
-      end
-
-    end
-
     DEFAULTS = {
       nan: 'NaN',
       infinity: 'Infinity',
@@ -175,7 +23,6 @@ module Numerals
       repeat_begin: '<',
       repeat_end: '>',
       repeat_suffix: '...',
-      #repeat_detect: false,
       show_plus: false,
       show_exponent_plus: false,
       uppercase: false,
@@ -186,7 +33,9 @@ module Numerals
       repeat_count: 3,
       grouping: [],
       insignificant_digit: nil,
-      repeating: true
+      repeating: true,
+      base_prefix: nil,
+      base_suffix: nil
     }
 
     def initialize(*args)
@@ -199,29 +48,27 @@ module Numerals
       # default Digits among all Symbols)
       @digits = Format::Symbols::Digits[]
 
-      # TODO: justification/padding
-      # width, adjust_mode (left, right, internal), fill_symbol
-
-      # TODO: base_suffixes, base_preffixes, show_base
+      # same with @padding
+      @padding = Format::Symbols::Padding[]
 
       set! *args
     end
 
-    # TODO: transmit uppercase/lowercase to digits
-
     attr_reader :digits, :nan, :infinity, :plus, :minus, :exponent, :point,
-                :group_separator, :zero, :insignificant_digit
-    attr_reader :repeat_begin, :repeat_end, :repeat_suffix, :repeat_delimited
-    attr_reader :show_plus, :show_exponent_plus, :uppercase, :lowercase,
-                :show_zero, :show_point
-    attr_reader :grouping, :repeat_count, :repeating
-
-    attr_writer :uppercase, :lowercase, :nan, :infinity, :plus,
+                :group_separator, :zero, :insignificant_digit, :padding,
+                :repeat_begin, :repeat_end, :repeat_suffix, :repeat_delimited,
+                :show_plus, :show_exponent_plus, :uppercase, :lowercase,
+                :show_zero, :show_point,
+                :grouping, :repeat_count, :repeating,
+                :base_prefix, :base_suffix
+
+    attr_writer :digits, :uppercase, :lowercase, :nan, :infinity, :plus,
                 :minus, :exponent, :point, :group_separator, :zero,
                 :repeat_begin, :repeat_end, :repeat_suffix,
                 :show_plus, :show_exponent_plus, :show_zero, :show_point,
                 :repeat_delimited, :repeat_count, :grouping,
-                :insignificant_digit, :repeating
+                :insignificant_digit, :repeating,
+                :base_prefix, :base_suffix
 
     include ModalSupport::StateEquivalent
 
@@ -251,11 +98,26 @@ module Numerals
       !@grouping.empty? && @group_separator && !@group_separator.empty?
     end
 
+    def padded?
+      @padding.padded?
+    end
+
+    def fill
+      fill = @padding.fill
+      if fill.is_a?(Integer)
+        @digits.digit_symbol(fill)
+      else
+        fill
+      end
+    end
+
     set do |*args|
       options = extract_options(*args)
       options.each do |option, value|
         if option == :digits
           @digits.set! value
+        elsif option == :padding
+          @padding.set! value
         else
           send :"#{option}=", value
         end
@@ -263,14 +125,38 @@ module Numerals
       apply_case!
     end
 
-    attr_writer :digits, :nan, :infinity,
-                :plus, :minus, :exponent, :point, :group_separator, :zero,
-                :repeat_begin, :repeat_end, :repeat_suffix, :show_plus,
-                :show_exponent_plus, :uppercase, :show_zero, :show_point,
-                :grouping, :repeat_count
-
     aspect :repeat do |*args|
-      # TODO accept hash :begin, :end, :suffix, ...
+      args.each do |arg|
+        case arg
+        when true, false
+          @repeating = arg
+        when Integer
+          @repeat_count = arg
+        when :delimited
+          @repeat_delimited = true
+        when :suffixed
+          @repeat_delimited = false
+        when Hash
+          arg.each do |key, value|
+            case key
+            when :delimiters
+              @repeat_begin, @repeat_end = Array(value)
+            when :begin
+              @repeat_begin = value
+            when :end
+              @repeat_end = value
+            when :suffix
+              @repeat_suffix = value
+            when :delimited
+              @repeat_delimited = value
+            when :count
+              @repeat_count = value
+            else
+              send "#{key}=", value
+            end
+          end
+        end
+      end
     end
 
     aspect :grouping do |*args|
@@ -278,12 +164,14 @@ module Numerals
         case arg
         when Symbol
           if arg == :thousands
-            @groups = [3]
+            @grouping = [3]
           end
         when String
           @group_separator = arg
         when Array
-          @groups = groups
+          @grouping = arg
+        when false
+          @grouping = []
         end
       end
     end
@@ -351,6 +239,14 @@ module Numerals
       @minus = minus
     end
 
+    aspect :padding do |*args|
+      @padding.set! *args
+    end
+
+    aspect :leading_zeros do |width|
+      @padding.leading_zeros = width
+    end
+
     def parameters(abbreviated=false)
       params = {}
       DEFAULTS.each do |param, default|
@@ -362,6 +258,9 @@ module Numerals
       if !abbreviated || @digits != Format::Symbols::Digits[]
         params[:digits] = @digits
       end
+      if !abbreviated || @padding != Format::Symbols::Padding[]
+        params[:padding] = @padding
+      end
       params
     end
 
@@ -447,7 +346,9 @@ module Numerals
       symbols = args
       digits = symbols.delete(:digits)
       grouped_digits = symbols.delete(:grouped_digits)
-      symbols = symbols.map { |s| send(s.to_sym) }
+      symbols = symbols.map { |s|
+        s.is_a?(Symbol) ? send(s)  : s
+      }
       if grouped_digits
         symbols += [group_separator, insignificant_digit]
       elsif digits
@@ -479,6 +380,23 @@ module Numerals
       }.compact
     end
 
+    # Returns left, internal and right padding for a number
+    # of given size (number of characters)
+    def paddings(number_size)
+      left_padding = internal_padding = right_padding = ''
+      if padded?
+        left_padding_size, internal_padding_size, right_padding_size = padding.padding_sizes(number_size)
+        right_padding_size = right_padding_size/fill.size
+        right_padding = fill*right_padding_size
+        d = right_padding_size - right_padding.size
+        left_padding_size = (left_padding_size + d)/fill.size
+        left_padding = fill*left_padding_size
+        internal_padding_size = internal_padding_size/fill.size
+        internal_padding = fill*internal_padding_size
+      end
+      [left_padding, internal_padding, right_padding ]
+    end
+
     private
 
     def regexp_char(c, options = {})
@@ -500,10 +418,22 @@ module Numerals
       symbols = Array(symbols).compact.select { |s| !s.empty? }
                               .map{ |d| regexp_symbol(d, options) }.join('|')
       if capture
-        "(#{symbols})"
+        symbols = "(#{symbols})"
       else
-        "(?:#{symbols})"
+        if symbols != ''
+          symbols = "(?:#{symbols})"
+          if options[:optional]
+            if options[:multiple]
+              symbols = "#{symbols}*"
+            else
+              symbols = "#{symbols}?"
+            end
+          elsif options[:multiple]
+            symbols = "#{symbols}+"
+          end
+        end
       end
+      symbols
     end
 
     def extract_options(*args)
@@ -540,7 +470,8 @@ module Numerals
         @repeat_begin = @repeat_begin.upcase
         @repeat_end   = @repeat_end.upcase
         @repeat_suffix = @repeat_suffix.upcase
-        @digits = @digits[uppercase: true]
+        @digits.set! uppercase: true
+        @padding.fill = @padding.fill.upcase if @padding.fill.is_a?(String)
       elsif @lowercase
         @nan = @nan.downcase
         @infinity = @infinity.downcase
@@ -552,7 +483,8 @@ module Numerals
         @repeat_begin = @repeat_begin.downcase
         @repeat_end   = @repeat_end.downcase
         @repeat_suffix = @repeat_suffix.downcase
-        @digits = @digits[lowercase: true]
+        @digits.set! lowercase: true
+        @padding.fill = @padding.fill.downcase if @padding.filll.is_a?(String)
       end
     end
 
@@ -563,3 +495,6 @@ module Numerals
   end
 
 end
+
+require 'numerals/format/symbols/digits'
+require 'numerals/format/symbols/padding'

data/lib/numerals/format/symbols/digits.rb

@@ -0,0 +1,173 @@
+module Numerals
+
+  class Format::Symbols::Digits < FormattingAspect
+
+    DEFAULT_DIGITS = %w(0 1 2 3 4 5 6 7 8 9 A B C D E F G H I J K L M N O P Q R S T U V W X Y Z)
+
+    def initialize(*args)
+      @digits = DEFAULT_DIGITS
+      @downcase_digits = @digits.map(&:downcase)
+      @max_base = @digits.size
+      @case_sensitive = false
+      @uppercase = false
+      @lowercase = false
+      set! *args
+    end
+
+    include ModalSupport::StateEquivalent
+
+    set do |*args|
+      options = extract_options(*args)
+      options.each do |option, value|
+        send :"#{option}=", value
+      end
+    end
+
+    attr_reader :digits_string, :max_base, :case_sensitive, :uppercase, :lowercase
+    attr_writer :case_sensitive
+
+    def digits(options = {})
+      base = options[:base] || @max_base
+      if base >= @max_base
+        @digits
+      else
+        @digits[0, base]
+      end
+    end
+
+    def digits=(digits)
+      if digits.is_a?(String)
+        @digits = digits.each_char.to_a
+      else
+        @digits = digits
+      end
+      @max_base = @digits.size
+      @lowercase = @digits.all? { |d| d.downcase == d }
+      @uppercase = @digits.all? { |d| d.upcase == d }
+      @downcase_digits = @digits.map(&:downcase)
+      if @digits.uniq.size != @max_base
+        raise "Inconsistent digits"
+      end
+    end
+
+    def uppercase=(v)
+      @uppercase = v
+      self.digits = @digits.map(&:upcase) if v
+    end
+
+    def lowercase=(v)
+      @lowercase = v
+      self.digits = @digits.map(&:downcase) if v
+    end
+
+    def case_sensitive?
+      case_sensitive
+    end
+
+    def is_digit?(digit_symbol, options={})
+      base = options[:base] || @max_base
+      raise "Invalid base" if base > @max_base
+      v = digit_value(digit_symbol)
+      v && v < base
+    end
+
+    def digit_value(digit)
+      if @case_sensitive
+        @digits.index(digit)
+      else
+        @downcase_digits.index(digit.downcase)
+      end
+    end
+
+    def digit_symbol(v, options={})
+      base = options[:base] || @max_base
+      raise "Invalid base" if base > @max_base
+      v >= 0 && v < base ? @digits[v] : nil
+    end
+
+    # Convert sequence of digits to its text representation.
+    # The nil value can be used in the digits sequence to
+    # represent the group separator.
+    def digits_text(digit_values, options={})
+      insignificant_digits = options[:insignificant_digits] || 0
+      num_digits = digit_values.reduce(0) { |num, digit|
+        digit.nil? ? num : num + 1
+      }
+      num_digits -= insignificant_digits
+      digit_values.map { |d|
+        if d.nil?
+          options[:separator]
+        else
+          num_digits -= 1
+          if num_digits >= 0
+            digit_symbol(d, options)
+          else
+            options[:insignificant_symbol]
+          end
+        end
+      }.join
+    end
+
+    def parameters
+      params = {}
+      params[:digits] = @digits
+      params[:case_sensitive] = @case_sensitive
+      params[:uppercase] = @uppercase
+      params[:lowercase] = @lowercase
+      params
+    end
+
+    def to_s
+      # TODO: show only non-defaults
+      args = []
+      if @digits != DEFAULT_DIGITS
+        args << @digits.to_s
+      end
+      if @max_base != @digits.size
+        args << "max_base: #{@max_base}"
+      end
+      if @case_sensitive
+        args << "case_sensitive: #{case_sensitive.inspect}"
+      end
+      if @uppercase
+        args << "uppercase: #{uppercase.inspect}"
+      end
+      if @lowercase
+        args << "lowercase: #{lowercase.inspect}"
+      end
+      "Digits[#{args.join(', ')}]"
+    end
+
+    def inspect
+      "Format::Symbols::#{self}"
+    end
+
+    def dup
+      Format::Symbols::Digits[parameters]
+    end
+
+    private
+
+    def extract_options(*args)
+      options = {}
+      args = args.first if args.size == 1 && args.first.kind_of?(Array)
+      args.each do |arg|
+        case arg
+        when Hash
+          options.merge! arg
+        when String, Array
+          options[:digits] = arg
+        when Format::Symbols::Digits
+          options.merge! arg.parameters
+        when :uppercase, :downcase
+          send :"#{arg}=", true
+        else
+          raise "Invalid Symbols::Digits definition"
+        end
+      end
+      options
+    end
+
+  end
+
+end

data/lib/numerals/format/symbols/padding.rb

@@ -0,0 +1,112 @@
+module Numerals
+
+  # Padding a number to a given width
+  class Format::Symbols::Padding < FormattingAspect
+
+    # Parameters:
+    #
+    # * :width field width (0 for no padding)
+    # * :fill filling symbol; nil for no padding;
+    #   0 to use the digit zero; otherwise should be a String
+    # * :adjust adjust mode: :left, :right, :integer, :center
+    #
+    def initialize(*args)
+      @width = 0
+      @fill = nil
+      @adjust = :right
+      set! *args
+    end
+
+    include ModalSupport::StateEquivalent
+
+    set do |*args|
+      options = extract_options(*args)
+      options.each do |option, value|
+        send :"#{option}=", value
+      end
+    end
+
+    attr_accessor :width, :fill, :adjust
+
+    def leading_zeros=(width)
+      @width = width
+      @fill = 0
+      @adjust = :internal
+    end
+
+    def padded?
+      @width > 0 && @fill && @fill != ''
+    end
+
+    def parameters
+      { width: width, fill: fill, adjust: adjust }
+    end
+
+    def to_s
+      params = []
+      if fill == 0 && adjust == :internal
+        params << "leading_zeros: #{width}"
+      else
+        if width != 0
+          params << "width: #{width}"
+        end
+        if fill
+          params << "fill: #{fill.inspect}"
+        end
+        if adjust != :right || !params.empty?
+          params << "adjust: #{adjust.inspect}"
+        end
+      end
+      "Padding[#{params.join(', ')}]"
+    end
+
+    def inspect
+      "Format::Symbols::#{to_s}"
+    end
+
+    # Returns size (characters of left, internal and right padding)
+    # for a number of given width (without padding)
+    def padding_sizes(number_size)
+      left_padding_size = internal_padding_size = right_padding_size = 0
+      padding_size = width - number_size
+      if padding_size > 0 && padded?
+        case adjust
+        when :left
+          left_padding_size = padding_size
+        when :right
+          right_padding_size = padding_size
+        when :internal
+          internal_padding_size = padding_size
+        when :center
+          left_padding_size = (padding_size + 1) / 2
+          right_padding_size = padding_size - left_padding_size
+        end
+      end
+      [left_padding_size, internal_padding_size, right_padding_size]
+    end
+
+    private
+
+    def extract_options(*args)
+      options = {}
+      args = args.first if args.size == 1 && args.first.kind_of?(Array)
+      args.each do |arg|
+        case arg
+        when Integer
+          options.merge! width: arg
+        when String
+          options.merge! fill: arg
+        when :left, :right, :internal, :center
+          options.merge! adjust: arg
+        when Hash
+          options.merge! arg
+        when Format::Symbols::Padding
+          options.merge! arg.parameters
+        end
+      end
+      options
+    end
+
+  end
+
+end

data/lib/numerals/format/text_parts.rb

@@ -32,4 +32,8 @@ class TextParts
    @detect_repeat
  end
 
+ def show_point?(format)
+   format.symbols.show_point || fractional? || repeat?
+ end
+
 end

data/lib/numerals/version.rb

@@ -1,3 +1,3 @@
 module Numerals
-  VERSION = "0.1.0"
+  VERSION = "0.2.0"
 end

data/test/test_format.rb

@@ -121,4 +121,51 @@ class TestFormat <  Test::Unit::TestCase # < Minitest::Test
     assert_equal 'PLUS', f2.symbols.plus
   end
 
+  def test_repeat_aspect
+    s = Format::Symbols[]
+    assert_equal '<', s.repeat_begin
+    assert_equal '>', s.repeat_end
+    assert_equal '...', s.repeat_suffix
+    refute s.repeat_delimited
+    assert_equal 3, s.repeat_count
+    assert s.repeating
+
+    s.set_repeat! false
+    refute s.repeating
+
+    s.set_repeat! true, delimiters: '[', count: 2, suffix: '****'
+    assert_equal '[', s.repeat_begin
+    assert_nil s.repeat_end
+    assert_equal '****', s.repeat_suffix
+    refute s.repeat_delimited
+    assert_equal 2, s.repeat_count
+    assert s.repeating
+
+    s.set_repeat! true, delimiters: ['>', '<'], delimited: true
+    assert_equal '>', s.repeat_begin
+    assert_equal '<', s.repeat_end
+    assert s.repeat_delimited
+  end
+
+  def test_padding_aspect
+    f = Format[]
+    refute f.padded?
+    assert_equal :right, f.padding.adjust
+    f = f[padding:[10, ' ', :left]]
+    assert f.padded?
+    assert_equal :left, f.padding.adjust
+    assert_equal ' ', f.padding.fill
+  end
+
+  def tst_grouping
+    f = Format[]
+    refute f.grouping?
+    f.set_grouping! :thousands
+    assert f.grouping?
+    assert_equal [3], f.grouping
+    f.set_grouping! false
+    refute f.grouping?
+    assert_equal [], f.grouping
+  end
+
 end

data/test/test_format_input.rb

@@ -223,4 +223,29 @@ class TestFormatInput <  Test::Unit::TestCase # < Minitest::Test
 
   end
 
+  def test_padding
+    f = Format[padding: '*']
+    assert_equal 643454333.32,  f.read("******643,454,333.32", type: Float)
+    assert_equal -643454333.32, f.read("*****-643,454,333.32", type: Float)
+    assert_equal -643454333.32, f.read("-*****643,454,333.32", type: Float)
+    assert_equal 643454333.32,  f.read("+*****643,454,333.32", type: Float)
+    assert_equal 643454333.32,  f.read("643,454,333.32******", type: Float)
+    assert_equal -643454333.32, f.read("-643,454,333.32*****", type: Float)
+    assert_equal 643454333.32,  f.read("***643,454,333.32***", type: Float)
+    assert_equal 643454333.32,  f.read("***643,454,333.32***", type: Float)
+    f.set_leading_zeros! 10
+    assert_equal 123, f.read("0000000123", type: Integer)
+    assert_equal -123, f.read("-000000123", type: Integer)
+    assert_equal 123.5, f.read("00000123.5", type: Float)
+    assert_equal -123.5, f.read("-00000123.5000", type: Float)
+    assert_equal 123.5, f.read("00000123.5000", type: Float)
+    assert_equal 100.5, f.read("00000100.5", type: Float)
+    assert_equal -100.5, f.read("-0000100.5", type: Float)
+    assert_equal Rational(1,3), f.read("000000.<3>", type: Rational)
+    assert_equal Rational(-1,3), f.read("-00000.<3>", type: Rational)
+    f.set_padding! '*'
+    assert_equal Flt::DecNum('0.667'), f.read("********0.667*******", type: Flt::DecNum)
+    assert_equal Flt::DecNum('-0.667'), f.read("*******-0.667*******", type: Flt::DecNum)
+  end
+
 end

data/test/test_format_output.rb

@@ -229,7 +229,7 @@ class TestFormatOutput <  Test::Unit::TestCase # < Minitest::Test
   def test_write_binnum_hex
     context = Flt::BinNum::IEEEDoubleContext
     x = Flt::BinNum('0.1', :fixed, context: context)
-    assert_equal "1.999999999999Ap-4", Format[:hexbin].write(x)
+    assert_equal "0x1.999999999999Ap-4", Format[:hexbin].write(x)
   end
 
   def test_write_to_file
@@ -786,4 +786,63 @@ class TestFormatOutput <  Test::Unit::TestCase # < Minitest::Test
       Format[:short, repeating: false].write(Rational(2469,200))
     end
   end
+
+  def test_padding
+    f = Format[padding: [:right, 20, fill: 0]]
+
+    f = Format[padding: [:left, 20, fill: '*']]
+    f = f[symbols: [group_separator: ',', grouping: [3]]]
+    assert_equal "******643,454,333.32", f.write(643454333.32)
+    assert_equal "*****-643,454,333.32", f.write(-643454333.32)
+    assert_equal "-*****643,454,333.32", f[padding: :internal].write(-643454333.32)
+    f = f[padding: :right]
+    assert_equal "643,454,333.32******", f.write(643454333.32)
+    assert_equal "-643,454,333.32*****", f.write(-643454333.32)
+    f = f[padding: :center]
+    assert_equal "***643,454,333.32***", f.write(643454333.32)
+    assert_equal "***-643,454,333.32**", f.write(-643454333.32)
+    f.set_leading_zeros! 10
+    assert_equal "0000000123", f.write(123)
+    assert_equal "-000000123", f.write(-123)
+    assert_equal "00000123.5", f.write(123.5)
+    assert_equal "-0000123.5", f.write(-123.5)
+    f.set_grouping! false
+    assert_equal "0123456789", f.write(123456789)
+    assert_equal "1234567891", f.write(1234567891)
+    assert_equal "12345678912", f.write(12345678912)
+    assert_equal "-123456789", f.write(-123456789)
+    assert_equal "-1234567891", f.write(-1234567891)
+    assert_equal "-12345678912", f.write(-12345678912)
+    f.set! symbols: [repeat_delimited: true]
+    assert_equal "000000.<3>", f.write(Rational(1,3))
+    assert_equal "-00000.<3>", f.write(Rational(-1,3))
+    assert_equal "000000.<6>", f.write(Rational(2,3))
+    assert_equal "-00000.<6>", f.write(Rational(-2,3))
+    f.set! rounding: [places: 3]
+    assert_equal "000000.333", f.write(Rational(1,3))
+    assert_equal "-00000.333", f.write(Rational(-1,3))
+    assert_equal "000000.667", f.write(Rational(2,3))
+    assert_equal "-00000.667", f.write(Rational(-2,3))
+    f.set! rounding: [places: 4]
+    assert_equal "00000.3333", f.write(Rational(1,3))
+    assert_equal "-0000.3333", f.write(Rational(-1,3))
+    assert_equal "00000.6667", f.write(Rational(2,3))
+    assert_equal "-0000.6667", f.write(Rational(-2,3))
+    f.set! padding: [:center, width: 20, fill: '*']
+    f.set! rounding: [places: 3]
+    assert_equal "********0.667*******", f.write(Rational(2,3))
+    assert_equal "*******-0.667*******", f.write(Rational(-2,3))
+    f.set! rounding: [places: 4]
+    assert_equal "*******0.5555*******", f.write(Flt::DecNum('0.5555'))
+    f.set! padding: 8
+    assert_equal "*0.5555*", f.write(Flt::DecNum('0.5555'))
+    f.set! padding: 7
+    assert_equal "*0.5555", f.write(Flt::DecNum('0.5555'))
+    f.set! padding: 6
+    assert_equal "0.5555", f.write(Flt::DecNum('0.5555'))
+    f.set! padding: 5
+    assert_equal "0.5555", f.write(Flt::DecNum('0.5555'))
+    f.set! padding: 4
+    assert_equal "0.5555", f.write(Flt::DecNum('0.5555'))
+  end
 end

metadata

@@ -1,14 +1,14 @@
 --- !ruby/object:Gem::Specification
 name: numerals
 version: !ruby/object:Gem::Version
-  version: 0.1.0
+  version: 0.2.0
 platform: ruby
 authors:
 - Javier Goizueta
 autorequire: 
 bindir: bin
 cert_chain: []
-date: 2015-03-31 00:00:00.000000000 Z
+date: 2015-04-02 00:00:00.000000000 Z
 dependencies:
 - !ruby/object:Gem::Dependency
   name: flt
@@ -99,8 +99,9 @@ files:
 - lib/numerals/format/notations/text.rb
 - lib/numerals/format/output.rb
 - lib/numerals/format/symbols.rb
+- lib/numerals/format/symbols/digits.rb
+- lib/numerals/format/symbols/padding.rb
 - lib/numerals/format/text_parts.rb
-- lib/numerals/formatting/options.rb
 - lib/numerals/formatting_aspect.rb
 - lib/numerals/numeral.rb
 - lib/numerals/repeat_detector.rb

data/lib/numerals/formatting/options.rb

@@ -1,84 +0,0 @@
-
-module Numerals
-
-    # Repeating decimal configuration options
-    class Options
-      include ModalSupport::StateEquivalent
-      include ModalSupport::BracketConstructor
-
-      def initialize(options={})
-        options = {
-          #  default options
-            delim: ['<', '>'],
-            suffix:  '...',
-            sep:   '.',
-            grouping:   [',', []], # [...,[3]] for thousands separators
-            special:   ['NaN', 'Infinity'],
-            digits:    nil,
-            signs: ['+', '-'],
-            maximum_number_of_digits: Numeral.maximum_number_of_digits
-          }.merge(options)
-
-        set_delim *Array(options[:delim])
-        set_suffix options[:suffix]
-        set_sep options[:sep]
-        set_grouping *Array(options[:grouping])
-        set_special *Array(options[:special])
-        set_digits *Array(options[:digits])
-        set_signs *Array(options[:signs])
-        @maximum_number_of_digits = options[:maximum_number_of_digits]
-      end
-
-      attr_accessor :begin_rep, :end_rep, :auto_rep, :dec_sep, :grp_sep, :grp, :maximum_number_of_digits
-      attr_accessor :nan_txt, :inf_txt, :plus_sign, :minus_sign
-
-      def set_delim(begin_d, end_d='')
-        @begin_rep = begin_d
-        @end_rep = end_d
-        return self
-      end
-
-      def set_suffix(a)
-        @auto_rep = a
-        return self
-      end
-
-      def set_sep(d)
-        @dec_sep = d
-        return self
-      end
-
-      def set_grouping(sep, g=[])
-        @grp_sep = sep
-        @grp = g
-        return self
-      end
-
-      def set_special(nan_txt, inf_txt)
-        @nan_txt = nan_txt
-        @inf_txt = inf_txt
-        return self
-      end
-
-      def set_digits(*args)
-        @digits_defined = !args.empty?
-        @digits = DigitsDefinition[*args]
-        self
-      end
-
-      def set_signs(plus, minus)
-        @plus_sign = plus
-        @minus_sign = minus
-      end
-
-      attr_accessor :digits
-
-      def digits_defined?
-        @digits_defined
-      end
-
-    end
-
-    DEFAULT_OPTIONS = Options[]
-
-end