numerals 0.0.0

data/lib/numerals/digits.rb

@@ -0,0 +1,99 @@
+require 'forwardable'
+
+module Numerals
+
+  # Sequence of digit values type, with an Array-compatible interface
+  # Having this encapsulated here allow to change the implementation
+  # e.g. to an Integer or packed in a String, ...
+  class Digits
+    def initialize(*args)
+      if Hash === args.last
+        options = args.pop
+      else
+        options = {}
+      end
+      @radix = options[:base] || options[:radix] || 10
+      if args.size == 1 && Array === args.first
+        @digits_array = args.first
+      else
+        @digits_array = args
+      end
+      if options[:value]
+        self.value = options[:value]
+      end
+    end
+
+    include ModalSupport::BracketConstructor
+
+    attr_reader :digits_array, :radix
+
+    extend Forwardable
+    def_delegators :@digits_array,
+                   :size, :map, :pop, :push, :shift, :unshift,
+                   :empty?, :first, :last, :any?, :all?, :[]=
+
+    # The [] with a Range argument or two arguments (index, length)
+    # returns a Regular Array.
+    def_delegators :@digits_array, :[], :replace
+    include ModalSupport::StateEquivalent # maybe == with Arrays too?
+
+    # This could be changed to have [] return a Digits object (except when a single index is passed).
+    # In that case we would have to define replace, ==, != to accept either Array or Digits arguments
+    # (and also possibly the constructor)
+
+    # Integral coefficient
+    def value
+      if @radix == 10
+        @digits_array.join.to_i
+      else
+        @digits_array.inject(0){|x,y| x*@radix + y}
+      end
+    end
+
+    def value=(v)
+      raise "Invalid digits value" if v < 0
+      if @radix < 37
+        replace v.to_s(@radix).each_char.map{|c| c.to_i(@radix)}
+      else
+        if v == 0
+          replace [0]
+        else
+          while v > 0
+            v, r = v.divmod(@radix)
+            unshift r
+          end
+        end
+      end
+    end
+
+    def zero?
+      # value == 0
+      @digits && @digits.all?{|d| d==0 }
+    end
+
+    # Deep copy
+    def dup
+      Digits[@digits_array.dup, base: @radix]
+    end
+
+    def to_s
+      args = ""
+      if @digits_array.size > 0
+        args << @digits_array.to_s.unwrap('[]')
+        args << ', '
+      end
+      args << "base: #{radix}"
+      "Digits[#{args}]"
+    end
+
+    def inspect
+      to_s
+    end
+
+    def truncate!(n)
+      @digits_array.slice! n..-1
+    end
+  end
+
+end
+

data/lib/numerals/formatting/digits_definition.rb

@@ -0,0 +1,75 @@
+module Numerals
+
+  # Digits definition (symbols used as digits)
+  class DigitsDefinition
+    include ModalSupport::StateEquivalent
+    include ModalSupport::BracketConstructor
+
+    DEFAULT_DIGITS = "0123456789ABCDEFGHIJKLMNOPQRSTUVWXYZ"
+    DEFAULT_BASE   = 10
+
+    def initialize(*args)
+      if String === args.first
+        digits = args.shift
+      end
+      options = args.shift || {}
+      raise NumeralError, "Invalid DigitsDefinition" unless args.empty? && Hash === options
+      digits ||= options[:digits]
+      base = options[:base]
+      if base
+        if digits
+          raise NumeralError, "Inconsistent DigitsDefinition" unless digits.size == base
+        end
+      elsif digits
+        base = digits.size
+      else
+        base = DEFAULT_BASE
+      end
+      digits ||= DEFAULT_DIGITS[0, base]
+
+      @radix = base
+      @digits = digits
+      @case_sensitive = options[:case_sensitive]
+      @downcase = options[:downcase] || (@digits.downcase == @digits)
+      @digits = @digits.downcase if @downcase
+    end
+
+    def is_digit?(digit)
+      digit = set_case(digit)
+      @digits.include?(digit)
+    end
+
+    def digit_value(digit)
+      digit = set_case(digit)
+      @digits.index(digit)
+    end
+
+    def digit_char(v)
+      v >= 0 && v < @radix ? @digits[v] : nil
+    end
+
+    def radix
+      @radix
+    end
+
+    def valid?
+      @digits.none?{|x| x.nil? || x<0 || x>=@radix}
+    end
+
+    private
+
+    def set_case(digit_char)
+      if digit_char
+        unless @case_sensitive
+          if @downcase
+            digit_char = digit_char.downcase
+          else
+            digit_char = digit_char.upcase
+          end
+        end
+      end
+      digit_char
+    end
+  end
+
+end

data/lib/numerals/formatting/options.rb

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