store_as_int 0.0.6

checksums.yaml

@@ -0,0 +1,7 @@
+---
+SHA256:
+  metadata.gz: e3034a4265c20d3df48f06df60764ecece7e27b82e6d8b164d4832a2eedde3a9
+  data.tar.gz: 96f656f4ac06ed8af32d80e746a53e83b50cbe6e097a4aff52d6f7f6d267a270
+SHA512:
+  metadata.gz: 4468dc2c227c41bf027480939ad156be1ee972e3a72edf5cff5bee5918abfcc9c9d812498251acb5f3cf903a8710b62dbd722d34ba890dc40711591a4eb86eae
+  data.tar.gz: '098a626684c9223e4c2c5840d5c201434393f032e82f546415450bac8fa0ddd2118506308e6a866ee57dbdf60d0262b516dbcf50e0da04c24b11fb256bed9142'

data/lib/store_as_int.rb

@@ -0,0 +1,117 @@
+# = StoreAsInt
+#
+#   Seamlessly Store Decimal Values as Integers!
+module StoreAsInt
+
+  if defined?(Rails)
+    require 'store_as_int/engine'
+  else
+    require 'store_as_int/exchange_rate'
+    require 'store_as_int/money'
+  end
+
+  # Create a new ::ExchangRate
+  #
+  # === Args
+  # val:: value to use with the exchange rate
+  #
+  # === Examples
+  #   er = StoreAsInt.exchange_rate(1.234567890)
+  #       OR
+  #   er = StoreAsInt.exchange_rate('1.234567890')
+  #       OR
+  #   er = StoreAsInt.exchange_rate(1234567890)
+  #
+  #   er.to_s => '1.2345'
+  #   er.to_s(true) => '%1.2345'
+  #   er.inspect => '%1.2345'
+  #   er.to_d => 1.234567890
+  #   er.value => 1234567890
+  #
+  def self.exchange_rate(val)
+    ExchangeRate.new(val)
+  end
+
+  # Create a new ::Money
+  #
+  # === Args
+  # val:: value to use with the money
+  #
+  # === Examples
+  #   er = StoreAsInt.money(1001.23)
+  #       OR
+  #   er = StoreAsInt.money("1001.23")
+  #       OR
+  #   er = StoreAsInt.money(100123)
+  #
+  #   er.to_s => '1001.23'
+  #   er.to_s(true) => '$1,001.23'
+  #   er.inspect => '$1,001.23'
+  #   er.to_d => 1001.23
+  #   er.value => 100123
+  #
+  def self.money(val)
+    Money.new(val)
+  end
+
+  # Register a new StoreAsInt type
+  #
+  # === Args
+  # under_scored_class_name:: @string - method name to use when initializing
+  # base_value:: @integer - number to multiply and divide by when doing conversions
+  # number_of_decimals:: @integer - number of decimals to include in to_s method
+  # symbol_to_use:: @string - symbol to use in to_s method
+  # &block::
+  #   @block - override to_s method with a block.
+  #   called with arguments (self, w_sym)
+  #   where w_sym is a boolean for whether to include symbol in the returned string
+  #
+  # === Examples
+  #   StoreAsInt.register 'accurate_money', 10000, 2, '$'
+  #
+  #   am = StoreAsInt::AccurateMoney.new(1.2345)
+  #   am.to_s(true) => $1.23
+  #   am.value => 12345
+  #
+  # ----------
+  #
+  #   StoreAsInt.register 'custom_to_s', 100, 2, '$' do |passed, w_sym|
+  #     "CUSTOM_STR #{passed.negative_sign}#{passed.sym}#{sprintf("%0.0#{passed.decimals}f", passed.to_d.abs)}"
+  #   end
+  #
+  #   cts = StoreAsInt.custom_to_s(-1.23)
+  #   cts.to_s(true) => CUSTOM_STR -$1.23
+  #   cts.to_s => CUSTOM_STR -$1.23
+  #   cts.value => -123
+  #
+  def self.register(under_scored_class_name, base_value = 1, number_of_decimals = 0, symbol_to_use = '', &block)
+    const_name = under_scored_class_name.split('_').map(&:capitalize).join('')
+
+    begin
+      const_get(const_name)
+
+      puts "WARNING - #{const_name} Already Registered. Nothing has been done"
+    rescue NameError
+      puts "  - Registering StoreAsInt::#{const_name}"
+
+      const_set const_name, Class.new(StoreAsInt::Base)
+
+      puts "  - Registering local constants for StoreAsInt::#{const_name}"
+
+      const_get(const_name).const_set 'BASE', (base_value && base_value.to_i) || 1
+      const_get(const_name).const_set 'DECIMALS', number_of_decimals.to_i
+      const_get(const_name).const_set 'SYM', symbol_to_use.to_s
+      const_get(const_name).const_set 'STR_FORMAT', block || nil
+
+      puts "  - Registering shortcut method: StoreAsInt.#{under_scored_class_name}(value)"
+
+      define_singleton_method under_scored_class_name.to_sym do |val|
+        const_get(const_name).new(val)
+      end
+
+      puts "  - StoreAsInt::#{const_name} registered"
+    end
+
+    const_get(const_name)
+  end
+end

data/lib/store_as_int/base.rb

@@ -0,0 +1,162 @@
+require 'bigdecimal'
+require 'bigdecimal/util'
+
+module StoreAsInt
+  class Base
+
+    # == Constants ============================================================
+    BASE = 1
+    DECIMALS = nil
+    SYM = 1
+    STR_FORMAT = nil
+
+    # == Attributes ============================================================
+    attr_accessor :num
+
+    # == Extensions ===========================================================
+    include Comparable
+
+    # == Class Methods ========================================================
+    def self.===(other)
+      self === other || Integer === other
+    end
+
+    def self.<=>(other)
+      self <=> other || Integer <=> other
+    end
+
+    def self.base
+      self::BASE || 1
+    end
+
+    def self.decimals
+      self::DECIMALS
+    end
+
+    def self.sym
+      self::SYM || ''
+    end
+
+    def self.str_format
+      self::STR_FORMAT
+    end
+
+    # == Instance Methods =====================================================
+    def initialize(new_val = nil)
+      return self.num = 0 unless new_val
+
+      if new_val.is_a?(self.class)
+        self.num = new_val.value
+      elsif new_val.is_a?(Integer)
+        self.num = new_val
+      else
+        self.num = (new_val.to_d * self.class.base).to_i
+      end
+    end
+
+    def base
+      self.class.base
+    end
+
+    def decimals
+      @decimals ||= self.class.decimals
+    end
+
+    def base_float
+      base.to_f
+    end
+
+    def sym
+      @sym ||= self.class.sym
+    end
+
+    def sym=(new_sym)
+      @sym = new_sym
+    end
+
+    def convert(other_val)
+      self.class.new(other_val)
+    end
+
+    def <=>(compare)
+      value <=> convert(compare).value
+    end
+
+    def == (compare)
+      value == convert(compare).value
+    end
+
+    def kind_of?(klass)
+      self.num.kind_of?(klass)
+    end
+
+    def to_i
+      self.num.to_i
+    end
+
+    def to_f
+      to_i/base_float
+    end
+
+    def to_d
+      to_i.to_d/base
+    end
+
+    def cents
+      self
+    end
+
+    def value
+      self.num || 0
+    end
+
+    def as_json(*args)
+      self.num.as_json(*args)
+    end
+
+    def inspect
+      to_s(true)
+    end
+
+    def negative_sign
+      value < 0 ? '-' : ''
+    end
+
+    def coerce(other)
+      [other, value]
+    end
+
+    def to_s(w_sym = false)
+      begin
+        str_format.call(self, w_sym)
+      rescue
+        puts $!.message
+        puts $!.backtrace
+        ""
+      end
+    end
+
+    def present?
+      begin
+        value.present?
+      rescue NoMethodError
+        !value.nil? && !(value.to_s == "")
+      end
+    end
+
+    def method_missing(name, *args, &blk)
+      ret = value.send(name, *args, &blk)
+      ret.is_a?(Numeric) ? self.class.new(ret) : ret
+    end
+
+    private
+      def str_format
+        @str_format ||= self.class.str_format || ->(passed, w_sym) do
+          return nil unless w_sym || passed.present?
+          str = "#{passed.negative_sign}#{w_sym ? passed.sym : ''}#{passed.decimals ? sprintf("%0.0#{passed.decimals.to_i}f", passed.to_d.abs) : passed.to_i.to_s}".reverse.split('.')
+          str[-1] = str[-1].gsub(/(\d{3})(?=\d)/, w_sym ? '\\1,' : '\\1')
+          str.join('.').reverse
+        end
+      end
+  end
+end

data/lib/store_as_int/engine.rb

@@ -0,0 +1,5 @@
+module StoreAsInt
+  class Engine < ::Rails::Engine
+    config.autoload_paths += Dir["#{config.root}/lib/**/"]
+  end
+end

data/lib/store_as_int/exchange_rate.rb

@@ -0,0 +1,7 @@
+require_relative './base'
+
+class StoreAsInt::ExchangeRate < StoreAsInt::Base
+  BASE = 10000000000
+  DECIMALS = 4
+  SYM = '%'
+end

data/lib/store_as_int/money.rb

@@ -0,0 +1,7 @@
+require_relative './base'
+
+class StoreAsInt::Money < StoreAsInt::Base
+  BASE = 100
+  DECIMALS = 2
+  SYM = '$'
+end

metadata

@@ -0,0 +1,48 @@
+--- !ruby/object:Gem::Specification
+name: store_as_int
+version: !ruby/object:Gem::Version
+  version: 0.0.6
+platform: ruby
+authors:
+- Sampson Crowley
+autorequire: 
+bindir: bin
+cert_chain: []
+date: 2018-06-09 00:00:00.000000000 Z
+dependencies: []
+description: Seamlessly store different types of values (such as dollars) as integers
+email: sampsonsprojects@gmail.com
+executables: []
+extensions: []
+extra_rdoc_files: []
+files:
+- lib/store_as_int.rb
+- lib/store_as_int/base.rb
+- lib/store_as_int/engine.rb
+- lib/store_as_int/exchange_rate.rb
+- lib/store_as_int/money.rb
+homepage: http://rubygems.org/gems/store_as_int
+licenses:
+- MIT
+metadata: {}
+post_install_message: 
+rdoc_options: []
+require_paths:
+- lib
+required_ruby_version: !ruby/object:Gem::Requirement
+  requirements:
+  - - ">="
+    - !ruby/object:Gem::Version
+      version: '0'
+required_rubygems_version: !ruby/object:Gem::Requirement
+  requirements:
+  - - ">="
+    - !ruby/object:Gem::Version
+      version: '0'
+requirements: []
+rubyforge_project: 
+rubygems_version: 2.7.6
+signing_key: 
+specification_version: 4
+summary: Store values as integers for lossless calculations
+test_files: []