numrepr 1.0

data/lib/numrepr/format.rb

@@ -0,0 +1,301 @@
+#
+#  numrepr/format.rb  --  Format numbers
+#
+
+require "supplement"
+
+
+module NumRepr
+
+  class Parser
+
+    GRP  = ",.'\u{2019}\u{202f}"
+    DEC  = ".,\u{b7}"
+
+    class <<self
+
+      def into_i str
+        check_string str
+        Integer remove_grp str
+      rescue ArgumentError, NoMethodError
+        raise ArgumentError, "Couldn't parse as an integer: #{str}"
+      end
+
+      def into_f str
+        digs = prepare_float str
+        Float digs
+      rescue ArgumentError, NoMethodError
+        raise ArgumentError, "Couldn't parse as a float: #{str}"
+      end
+
+      def into_d str
+        digs = prepare_float str
+        BigDecimal digs
+      rescue ArgumentError, NoMethodError
+        raise ArgumentError, "Couldn't parse as a decimal: #{str}"
+      end
+
+      private
+
+      def prepare_float str
+        check_string str
+        digs, exp = str.split /e/i
+        ints, frac = decsplit digs
+        digs = remove_grps [ints, frac]
+        digs << "e" << exp if exp
+        digs
+      end
+
+      def check_string str
+        String === str or raise "Not a string: #{str.inspect}"
+      end
+
+      def remove_grp str
+        str = str.dup
+        self::GRP.each_char { |g| str.gsub! g, "_" }
+        str
+      end
+
+      def remove_grps strs
+        strs.map { |s| remove_grp s }.join "."
+      end
+
+      def decsplit digs
+        ps = []
+        self::DEC.each_char { |dec|
+          if (digs.count dec) == 1 then
+            p = digs.rindex dec
+          end
+          ps.push p
+        }
+        m = nil
+        ps.each { |p|
+          p or next
+          if not m or p > m then
+            m = p
+          end
+        }
+        if m then
+          ints = digs.slice! 0, m
+          digs.slice! 0, 1
+        else
+          ints = digs.slice! /.*\d/
+        end
+        [ints, digs]
+      end
+
+    end
+
+  end
+
+
+  class Format
+
+    NUMDIGITS = nil     # minimum number of digits in integer part (builds leading zeroes)
+    POS       = false   # plus sign if positive (still none for 0)
+    GRP       = false   # group three digits
+    CHGRP     = ","     # group character
+    WIDTH     = nil     # minimum length of integer part (builds leading spaces)
+
+    class <<self
+
+      def method_missing sym, *args, **kwargs
+        if sym =~ /\Abuild_/ then
+          (send :"from_#$'", *args, **kwargs).to_s
+        else
+          super
+        end
+      end
+
+      def from_i n
+        ints, = n.make_digits
+        i = new ints
+        i.do_int n.sign, true
+        i
+      end
+
+    end
+
+    def initialize chars
+      @chars = chars
+    end
+
+    def to_s ; @chars ; end
+
+
+    alias cls class
+
+    # Please load the "supplement" gem.
+    def notempty? ; @chars.notempty? rescue @chars.emtpy? ? nil : @chars ; end
+
+    def reverse! ; @chars.reverse! ; end
+
+    def pad0 n ; pad n, "0"      ; end
+    def pad_ n ; pad n, " " if n ; end
+    def pad n, chr
+      p = n - @chars.length
+      @chars << chr * p if p > 0
+    end
+
+    def group
+      if cls::GRP then
+        l, e = 3, ""
+        loop do
+          e << (@chars.slice! 0, l)
+          break if @chars.empty?
+          e << cls::CHGRP
+        end
+        @chars.replace e
+      end
+    end
+
+    def do_sign n
+      if    n.negative? then
+        @chars << "-"
+      elsif n.positive? then
+        @chars << "+" if cls::POS
+      end
+    end
+
+    def do_int nsig, finite
+      if finite then
+        pad0 cls::NUMDIGITS||1
+        group
+      end
+      do_sign nsig
+      pad_ cls::WIDTH
+      reverse!
+    end
+
+
+    def do_decimal frac
+      sep = cls.new ""
+      frc = cls.new frac
+      yield sep, frc
+      @chars << sep.to_s << frc.to_s
+    end
+
+
+    DEC       = false   # force decimal character
+    CHDEC     = "."     # character before decimal places
+    NUMPLACES = nil     # minimum number of places (builds trailing zeroes)
+    ZSIGN     = false   # respect zero sign (determinable only in BigDecimal)
+    RWIDTH    = nil     # minimum width to the right (builds trailing spaces)
+
+    class <<self
+
+      def from_d d
+        ints, frac = d.make_digits
+        i = new ints
+        i.do_bd frac, (self::ZSIGN ? d.sign : d)
+        i
+      end
+      alias from_f from_d
+
+    end
+
+    def sep needs
+      @chars << cls::CHDEC if needs or cls::DEC
+    end
+
+    def do_bd frac, nsig
+      do_int nsig, frac
+      do_decimal frac||"" do |s,f|
+        if frac then
+          f.pad0 cls::NUMPLACES||0
+          f.group
+          s.sep f.notempty?
+        end
+        f.pad_ cls::RWIDTH
+        s.pad_ cls::RWIDTH&&1
+      end
+    end
+
+  end
+
+end
+
+
+
+class Numeric
+
+  def split
+    _, r = (coerce 0.0)
+    r.split
+  end
+
+  def sign ; self ; end
+
+  def make_digits
+    case
+    when nan?      then "NaN".reverse
+    when infinite? then "Inf".reverse
+    when zero?     then [ "", ""]
+    else
+      _, digits, _, exp = *split
+      f = exp - digits.length
+      if f >= 0 then
+        digits << "0" * f
+        digits.reverse!
+        [ digits, ""]
+      else
+        if exp >= 0 then
+          i = digits.slice! 0, exp
+          i.reverse!
+        else
+          i = ""
+          digits.prepend "0" * -exp
+        end
+        [ i, digits]
+      end
+    end
+  end
+
+end
+
+
+class Integer < Numeric
+
+  def make_digits
+    if zero? then
+      ""
+    else
+      abs.to_s.reverse
+    end
+  end or begin  # If written in C, this one would be faster.
+    r = ""
+    n = abs
+    while n.nonzero? do
+      n, d = n.divmod 10
+      r << (d + "0".ord).chr
+    end
+    r
+  end
+
+end
+
+
+class Float < Numeric
+
+  # There seems to be no legal way to retrieve the negative sign of -0.0.
+  # If you really need it, convert the number to BigDecimal.
+  #
+  #   -0.0.to_f.to_d.sign  #=> -1
+  def sign ; super ; end
+
+  # analogous to BigDecimal#split
+  def split
+    m, e = abs.to_s.split /e/i
+    e = e.to_i
+    d, f = m.split "."
+    d.lstrip! "0" rescue d.slice! /\A0+/  # before Ruby 4.0
+    e += d.count "0-9"
+    if f then
+      f.rstrip! "0" rescue f.slice! /0+\z/  # before Ruby 4.0
+      d << f
+    end
+    [ (negative? ? -1 : 1), d, 10, e]
+  end
+
+end
+

data/lib/numrepr/money.rb

@@ -0,0 +1,337 @@
+#
+#  numrepr/money.rb  --  Money amount values
+#
+
+require "numrepr/format"
+
+
+module NumRepr
+
+  class Money
+
+    attr_reader :cents
+    alias cent cents
+
+    PLACES = 2
+    CENTS = 10 ** PLACES
+
+    class <<self
+
+      alias parse new
+
+      def zero ; new nil ; end
+
+      def as obj
+        case obj
+        when self then obj
+        else           new obj
+        end
+      end
+
+      def norm cents
+        case cents
+          when Integer then cents
+          else              cents.round.to_i
+        end
+      end
+
+    end
+
+
+    def initialize val = nil
+      @cents =
+        case val
+        when String then parse_str val
+        when Money  then val.cents
+        when nil    then 0
+        else             Money.norm CENTS * val
+        end
+    rescue ArgumentError, TypeError
+      raise ArgumentError, "Not a Money value: \"#{val}\"."
+    end
+
+    private
+
+    def parse_str val
+      v = val.dup
+      v.slice! /(?:\b[A-Z]{3}\b|[$\u{a2}-\u{a5}\u{20a0}-\u{20cf}])/  # unit
+      v.strip!
+      n = v.slice! /\A\s*-/
+      f = v.slice! /\..*/
+      v.gsub! ",", "_"        # PostgreSQL's money type actually returns this.
+      r = v.empty? ? 0 : (Integer v) * CENTS
+      r += ((Float "0#{f}0") * CENTS).round if f
+      r *= -1 if n
+      r
+    end
+
+    public
+
+    def eql? oth ; oth.class == self.class and oth.cents == @cents ; end
+
+    def hash ; @cents.hash ; end
+
+    public
+
+    def to_money ; self ; end
+
+    def to_f ; @cents/CENTS.to_f           ; end
+    def to_i ; to_f.round                  ; end
+    def to_r ; Rational @cents, CENTS      ; end
+    def to_d ; (BigDecimal @cents) / CENTS ; end
+
+    def succ! ; @cents = @cents.succ ; self ; end
+    def pred! ; @cents = @cents.pred ; self ; end
+    def succ ; dup.succ! ; end
+    def pred ; dup.pred! ; end
+
+    def zero?    ; @cents.zero?             ; end
+    def nonzero? ; @cents.nonzero? and self ; end
+
+    def sign ; @cents ; end
+    def positive? ; @cents.positive? ; end
+    def negative? ; @cents.negative? ; end
+    alias pos? positive?
+    alias neg? negative?
+
+    def add! oth ; @cents += (self.class.as oth).cents ; self ; end
+    def sub! oth ; @cents -= (self.class.as oth).cents ; self ; end
+    def add oth ; dup.add! oth ; end
+    def sub oth ; dup.sub! oth ; end
+
+    def mul! oth
+      c = case oth
+        when Money   then
+          raise ArgumentError, "Currencies cannot be multiplied together"
+        when Integer then
+          Rational @cents * oth
+        else
+          @cents * oth
+      end
+      @cents = Money.norm c
+      self
+    end
+
+    def mul oth ; dup.mul! oth ; end
+
+    def div! oth
+      c = case oth
+        when Money             then
+          raise ArgumentError, "Currency cannot be reduced by another one"
+        when Integer, Rational then
+          Rational @cents, oth
+        else
+          @cents / oth
+      end
+      @cents = Money.norm c
+      self
+    end
+
+    def div oth
+      case oth
+        when Money then Rational @cents, oth.cents
+        else            dup.div! oth
+      end
+    end
+
+    alias + add
+    alias - sub
+    alias * mul
+    alias / div
+
+    def neg! ; @cents = -@cents ; self ; end
+    def neg ; dup.neg! ; end
+    def +@ ; self ; end
+    def -@ ; neg  ; end
+
+    def abs ; @cents >= 0 ? self : neg ; end
+
+    def <=> oth
+      case oth
+        when Money   then @cents <=> oth.cents
+        when Numeric then @cents <=> oth*CENTS
+        when nil     then @cents.zero? ? 0 : 1
+        else              to_r <=> oth
+      end
+    end
+    include Comparable
+
+    def coerce oth ; [ oth, to_r] ; end
+
+
+    def make_digits
+      r = @cents.make_digits
+      l = 2 - r.length
+      r << "0" * l if l > 0
+      f = r.slice! 0, 2
+      f.reverse!
+      [r, f]
+    end
+
+    # :call-seq:
+    #   cur.raw     -> str
+    #
+    # Build a simple string representation without spaces, group characters,
+    # parentheses etc. that can be understood by the classes ::parse method
+    # and, hopefully, by other programming languages (Some SQL, for example).
+    #
+    #   c = Money.parse "$1,234.00"
+    #   c.raw       #=>  "$1234.00"
+    #
+
+    def raw
+      b, c = make_digits
+      b << "0" if b.empty?
+      b.reverse!
+      r = "$"
+      r << "-" if negative?
+      r << b << "." << c
+    end
+    alias to_s    raw
+    alias inspect raw
+
+  end
+
+  class Parser
+
+    DASH         = "-\u{2013}"
+    IDASH        = DASH
+    NEG_TRAILING = true
+    NEG_PAREN    = true
+
+    class <<self
+
+      def into_money str
+        check_string str
+        ints, frac = decsplit str.dup
+        unless ints =~ /\d/ then
+          self::IDASH.each_char { |d|
+            if ints.end_with? d then
+              ints.slice! ints.length-1
+              break
+            end
+          }
+        end
+        unless frac =~ /\d/ then
+          self::DASH.each_char { |d|
+            if frac.start_with? d then
+              frac.slice! 0
+              break
+            end
+          }
+        end
+        digs = remove_grps [ints, frac]
+        if self::NEG_TRAILING then
+          digs.sub! /(\d.*)-/ do "-#$1" end
+        end
+        if self::NEG_PAREN then
+          digs.sub! /\((\d.*?)\)/ do "-#$1" end
+        end
+        Money.new digs
+      rescue ArgumentError, NoMethodError
+        raise ArgumentError, "Couldn't parse as a monetary: #{str}"
+      end
+
+    end
+
+  end
+
+  class Format
+
+    DASH      = false   # dash for zero in decimal part
+    IDASH     = false   # dash for zero in integer part
+    CHDASH    = "-"     # dash character (default '-')
+    NEG       = :l      # negative values: :p, :par = parentheses; :r, :right = right minus
+    CURSYM    = "$"     # currency symbol
+    SYMPOS    = :l      # symbol position: :l/:left (default), :r/:right, :n/:none
+    SYMSPC    = false   # space before/after currency symbol
+
+    class <<self
+
+      def from_money m
+        ints, frac = m.make_digits
+        i = new ints
+        i.do_curr frac, m.sign
+        i
+      end
+
+    end
+
+    def dash need
+      need or return
+      if @chars =~ /\A0+\z/ then
+        l = @chars.length
+        @chars.clear
+        @chars << cls::CHDASH
+        pad l, " "
+      end
+    end
+
+    def cursym rev
+      if rev then
+        case cls::SYMPOS
+        when :n, :none        then return
+        when :r, :right       then return
+        else                       nil
+        end
+      else
+        case cls::SYMPOS
+        when :n, :none        then return
+        when :r, :right       then nil
+        else                       return
+        end
+      end
+      cs = cls::CURSYM
+      cs = cs.reverse if rev
+      @chars << " " if cls::SYMSPC
+      @chars << cs
+    end
+
+    def curpresign n
+      if n.negative? then
+        case cls::NEG
+          when :p, :paren then @chars << "("
+          when :r, :right then nil
+          else                 @chars << "-"
+        end
+      end
+    end
+
+    def curpostsign n
+      if n.negative? then
+        case cls::NEG
+          when :p, :paren then @chars << ")"
+          when :r, :right then @chars << "-"
+        end
+      end
+    end
+
+    def do_curr frac, nsig
+      pad0 cls::NUMDIGITS||1
+      dash cls::IDASH
+      group
+      curpresign nsig
+      cursym true
+      pad_ cls::WIDTH
+      reverse!
+      do_decimal frac do |s,f|
+        f.dash cls::DASH
+        f.curpostsign nsig
+        f.cursym false
+        f.pad_ cls::RWIDTH
+        s.sep true
+      end
+    end
+
+  end
+
+
+  def Money v ; Money.new v ; end
+
+end
+
+
+class NilClass ; def to_money ; NumRepr::Money.new self ; end ; end
+class Numeric  ; def to_money ; NumRepr::Money.new self ; end ; end
+class String   ; def to_money ; NumRepr::Money.new self ; end ; end
+