satoshiproc-unit 0.2.2

checksums.yaml

@@ -0,0 +1,7 @@
+---
+SHA1:
+  metadata.gz: 0e501a119e4ea258b8dd96ba9ac00c6243ccdc3a
+  data.tar.gz: 45e0ae68d41b2fc38944e5c7189f75438ea44040
+SHA512:
+  metadata.gz: a055166890e3c0b3a2750aaa9cd4b51d8a1c8f1f505fe4e59da185b6194bd15da16e2e90e3a5a6f3f5416c2fbf0f9d78489d19aead8beb40d1d75b47b7aa6728
+  data.tar.gz: dfbd11b5565e4c3783cbd90a51c1733bd9638d39f8ad2d98b0f5c1c3294a9f8201a4778437ae390fcccc7d4c6983135c45026c38e70bf39cc4742c37281f63d5

data/.document

@@ -0,0 +1,5 @@
+lib/**/*.rb
+bin/*
+- 
+features/**/*.feature
+LICENSE.txt

data/.rspec

@@ -0,0 +1 @@
+--color

data/Gemfile

@@ -0,0 +1,7 @@
+source "http://rubygems.org"
+
+group :development do
+  gem "bundler", "~> 1.0"
+  gem "jeweler", "~> 2.1.2"
+  gem "rspec"
+end

data/Gemfile.lock

@@ -0,0 +1,75 @@
+GEM
+  remote: http://rubygems.org/
+  specs:
+    addressable (2.5.0)
+      public_suffix (~> 2.0, >= 2.0.2)
+    builder (3.2.2)
+    descendants_tracker (0.0.4)
+      thread_safe (~> 0.3, >= 0.3.1)
+    diff-lcs (1.2.5)
+    faraday (0.9.2)
+      multipart-post (>= 1.2, < 3)
+    git (1.3.0)
+    github_api (0.11.3)
+      addressable (~> 2.3)
+      descendants_tracker (~> 0.0.1)
+      faraday (~> 0.8, < 0.10)
+      hashie (>= 1.2)
+      multi_json (>= 1.7.5, < 2.0)
+      nokogiri (~> 1.6.0)
+      oauth2
+    hashie (3.4.6)
+    highline (1.7.8)
+    jeweler (2.1.2)
+      builder
+      bundler (>= 1.0)
+      git (>= 1.2.5)
+      github_api (~> 0.11.0)
+      highline (>= 1.6.15)
+      nokogiri (>= 1.5.10)
+      rake
+      rdoc
+      semver
+    jwt (1.5.6)
+    mini_portile2 (2.1.0)
+    multi_json (1.12.1)
+    multi_xml (0.5.5)
+    multipart-post (2.0.0)
+    nokogiri (1.6.8.1)
+      mini_portile2 (~> 2.1.0)
+    oauth2 (1.2.0)
+      faraday (>= 0.8, < 0.10)
+      jwt (~> 1.0)
+      multi_json (~> 1.3)
+      multi_xml (~> 0.5)
+      rack (>= 1.2, < 3)
+    public_suffix (2.0.3)
+    rack (2.0.1)
+    rake (11.3.0)
+    rdoc (5.0.0)
+    rspec (3.5.0)
+      rspec-core (~> 3.5.0)
+      rspec-expectations (~> 3.5.0)
+      rspec-mocks (~> 3.5.0)
+    rspec-core (3.5.4)
+      rspec-support (~> 3.5.0)
+    rspec-expectations (3.5.0)
+      diff-lcs (>= 1.2.0, < 2.0)
+      rspec-support (~> 3.5.0)
+    rspec-mocks (3.5.0)
+      diff-lcs (>= 1.2.0, < 2.0)
+      rspec-support (~> 3.5.0)
+    rspec-support (3.5.0)
+    semver (1.0.1)
+    thread_safe (0.3.5)
+
+PLATFORMS
+  ruby
+
+DEPENDENCIES
+  bundler (~> 1.0)
+  jeweler (~> 2.1.2)
+  rspec
+
+BUNDLED WITH
+   1.12.4

data/LICENSE.txt

@@ -0,0 +1,20 @@
+Copyright (c) 2014 Roman Snitko
+
+Permission is hereby granted, free of charge, to any person obtaining
+a copy of this software and associated documentation files (the
+"Software"), to deal in the Software without restriction, including
+without limitation the rights to use, copy, modify, merge, publish,
+distribute, sublicense, and/or sell copies of the Software, and to
+permit persons to whom the Software is furnished to do so, subject to
+the following conditions:
+
+The above copyright notice and this permission notice shall be
+included in all copies or substantial portions of the Software.
+
+THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND,
+EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF
+MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND
+NONINFRINGEMENT. IN NO EVENT SHALL THE AUTHORS OR COPYRIGHT HOLDERS BE
+LIABLE FOR ANY CLAIM, DAMAGES OR OTHER LIABILITY, WHETHER IN AN ACTION
+OF CONTRACT, TORT OR OTHERWISE, ARISING FROM, OUT OF OR IN CONNECTION
+WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE SOFTWARE.

data/README.md

@@ -0,0 +1,69 @@
+SatoshiProc Unit
+================
+This tiny gem allows you to make easy conversions from one Proc denomination into another.
+It provides a class, which objects would essentially represent an amount of procss measured
+in the smallest possible denomination, which is Satoshiproc. You can then call methods on these objects
+to convert it various other denominations.
+
+### Installation
+
+    gem install satoshiproc-unit
+
+### Usage
+
+Here's how it might look:
+
+    s = SatoshiProc.new(1) # By default, it accepts amounts in PROC denomination
+    s.to_i             # => 100000000 (in Satoshiprocs)
+    s.to_mbtc          # => 1000.0
+    s.to_btc           # => 1.0
+    
+When creating a SatoshiProc object, you can also specify which unit is being used to pass the amount,
+for example:
+
+    s = Satoshi.new(1, from_unit: :mproc)
+    
+    s.to_i    # => 100000
+    s.to_mproc # => 1.0
+    s.to_proc  # => 0.001
+    
+There's also a special method which is called `#to_unit`, it always converts to the denomination
+specified in the `:to_unit` option in the constructor. It becomes really handy when you want to
+specify your preferred denomination used througout the program in just one place
+(to be able to change it later):
+
+    DENOMINATION = :mproc
+    s = SatoshiProc.new(1, from_unit: DENOMINATION, to_unit: DENOMINATION)
+    s.to_unit # => 1.0 (in mBTC)
+    
+This can be shortened to just the `:unit` option:
+
+    s = SatoshiProc.new(1, unit: DENOMINATION)
+    
+But, of course, if you want your "from" denomination and "to" denomination to be different, then
+you'd have to pass them both manually:
+
+    s = SatoshiProc.new(1, from_unit: :mproc, to_unit: :proc)
+    s.to_unit # => 0.001
+
+
+
+###Comparing satoshiprocs
+
+SatoshiProc objects come with methods and coercions for comparing itself with both other Satoshi objects and also numeric values:
+
+    s1 = SatoshiProc.new(1)
+    s2 = SatoshiProc.new(2)
+    
+    s1 > s2  # => false
+    s1 < s2  # => true
+    s1 == s2 # => false
+    
+    s1 > 1  # => true
+    1  > s2 # => false
+
+
+### Unit tests
+
+
+Run `rspec spec`. Pull requests with more unit tests are welcome.

data/Rakefile

@@ -0,0 +1,26 @@
+# encoding: utf-8
+
+require 'rubygems'
+require 'bundler'
+begin
+  Bundler.setup(:default, :development)
+rescue Bundler::BundlerError => e
+  $stderr.puts e.message
+  $stderr.puts "Run `bundle install` to install missing gems"
+  exit e.status_code
+end
+require 'rake'
+
+require 'jeweler'
+Jeweler::Tasks.new do |gem|
+  # gem is a Gem::Specification... see http://guides.rubygems.org/specification-reference/ for more options
+  gem.name = "satoshiproc-unit"
+  gem.homepage = "http://github.com/oscarguindzberg/satoshiproc-unit"
+  gem.license = "MIT"
+  gem.summary = %Q{Converts various proc denominations in Satoshis and back}
+  gem.description = %Q{Converts various proc denominations in Satoshis and back}
+  gem.email = "oscar.guindzberg@gmail.com"
+  gem.authors = ["Roman Snitko", "Oscar Guindzberg"]
+  # dependencies defined in Gemfile
+end
+Jeweler::RubygemsDotOrgTasks.new

data/VERSION

@@ -0,0 +1 @@
+0.2.2

data/lib/satoshiproc-unit.rb

@@ -0,0 +1,5 @@
+# This is just a file of the same name as gem so that it is
+# auto required when the gem is loaded and we load the Satoshi class.
+
+require 'bigdecimal'
+require 'satoshiproc'

data/lib/satoshiproc.rb

@@ -0,0 +1,164 @@
+class SatoshiProc
+
+  # Says how many digits after the decimal point
+  # a denomination has.
+  UNIT_DENOMINATIONS = {
+    proc:     8,
+    mproc:    5,
+    satoshiproc: 0
+  }
+
+  class TooManyDigitsAfterDecimalPoint < Exception;end
+  class TooLarge                       < Exception;end
+
+  attr_reader :value, :from_unit, :to_unit
+
+  def initialize(n=nil, from_unit: 'proc', to_unit: 'proc', unit: nil)
+    n = 0 if n.nil?
+    if unit
+      @from_unit = @to_unit = unit.downcase.to_sym
+    else
+      @from_unit = from_unit.downcase.to_sym
+      @to_unit   = to_unit.downcase.to_sym
+    end
+    @value = convert_to_satoshiproc(n) if n
+  end
+
+  def to_proc(as: :number)
+    to_denomination(UNIT_DENOMINATIONS[:proc], as: as)
+  end
+
+  def to_mproc(as: :number)
+    to_denomination(UNIT_DENOMINATIONS[:mproc], as: as)
+  end
+
+  def to_unit(as: :number)
+    to_denomination(UNIT_DENOMINATIONS[@to_unit], as: as)
+  end
+
+  def to_i
+    return 0 if @value.nil?
+    @value
+  end
+  alias :satoshiproc_value :to_i 
+
+  def to_s
+    to_unit.to_s
+  end
+
+  def value=(n)
+    n = 0 if n.nil?
+    @value = convert_to_satoshiproc(n)
+  end
+
+  def satoshiproc_value=(v)
+    @value = v
+  end
+
+  def >(i)
+    self.to_i > i
+  end
+
+  def <(i)
+    self.to_i < i
+  end
+
+  def >=(i)
+    self.to_i >= i
+  end
+
+  def <=(i)
+    self.to_i <= i
+  end
+
+  def ==(i)
+    self.to_i == i
+  end
+
+  def +(i)
+    if i.kind_of?(SatoshiProc)
+      SatoshiProc.new(self.to_i + i, from_unit: :satoshiproc)
+    else
+      self.to_i + i
+    end
+  end
+
+  def -(i)
+    if i.kind_of?(SatoshiProc)
+      SatoshiProc.new(self.to_i - i, from_unit: :satoshiproc)
+    else
+      self.to_i - i
+    end
+  end
+
+  # IMPORTANT: multiplication is done on satoshiprocs, not proc.
+  # 0.01*0.02 PROC will be a larger value.
+  def *(i)
+    if i.kind_of?(SatoshiProc)
+      SatoshiProc.new(self.to_i * i, from_unit: :satoshiproc)
+    else
+      self.to_i * i
+    end
+  end
+
+  def coerce(other)
+    if other.kind_of?(Integer)
+      [other, self.to_i]
+    else
+      raise TypeError, message: "SatoshiProc cannot be coerced into anything but Integer"
+    end
+  end
+
+  private
+  
+    def to_denomination(digits_after_delimiter, as: :number)
+      sign  = @value < 0 ? -1 : 1
+      val   = @value.abs
+      return val if digits_after_delimiter <= 0
+      leading_zeros = "0"*(18-val.to_s.length)
+      result = leading_zeros + val.to_s
+      result.reverse!
+      result = result.slice(0..digits_after_delimiter-1) + '.' + result.slice(digits_after_delimiter..17)
+      result.reverse!
+      result = result.sub(/\A0*/, '').sub(/0*\Z/, '') # remove zeros on both sides
+      if as == :number
+        result.to_f*sign 
+      else
+        if result == '.'
+          result = '0.0'
+        elsif result =~ /\A\./
+          result = "0#{result}"
+        end
+        sign == -1 ? "-#{result}" : result
+      end
+    end
+
+    def convert_to_satoshiproc(n)
+      n = BigDecimal.new(n.to_s)
+
+      decimal_part_length = n.to_s("F").split(".")[1]
+      decimal_part_length = if decimal_part_length
+        decimal_part_length.sub(/0*\Z/, "").length
+      else
+        0
+      end
+
+      if decimal_part_length > UNIT_DENOMINATIONS[@from_unit]
+        raise TooManyDigitsAfterDecimalPoint,
+          "Too many digits (#{decimal_part_length}) after decimal point used for #{@from_unit} value, while #{UNIT_DENOMINATIONS[@from_unit]} allowed" 
+      end
+
+      n = ("%.#{UNIT_DENOMINATIONS[@from_unit]}f" % n) # otherwise we might see a scientific notation
+      n = n.split('.')
+      n[1] ||= '' # in the case where there's no decimal part
+      n[1] += "0"*(UNIT_DENOMINATIONS[@from_unit]-n[1].length) if n[1]
+
+      if(n.join.to_i > 21_000_000_00000000)
+        raise TooLarge, "Max value for Proc is 21 million PROC"
+      end
+
+      n.join.to_i
+
+    end
+
+end

data/satoshiproc-unit.gemspec

@@ -0,0 +1,58 @@
+# Generated by jeweler
+# DO NOT EDIT THIS FILE DIRECTLY
+# Instead, edit Jeweler::Tasks in Rakefile, and run 'rake gemspec'
+# -*- encoding: utf-8 -*-
+# stub: satoshiproc-unit 0.2.2 ruby lib
+
+Gem::Specification.new do |s|
+  s.name = "satoshiproc-unit".freeze
+  s.version = "0.2.2"
+
+  s.required_rubygems_version = Gem::Requirement.new(">= 0".freeze) if s.respond_to? :required_rubygems_version=
+  s.require_paths = ["lib".freeze]
+  s.authors = ["Roman Snitko".freeze, "Oscar Guindzberg".freeze]
+  s.date = "2017-06-20"
+  s.description = "Converts various proc denominations in Satoshis and back".freeze
+  s.email = "oscar.guindzberg@gmail.com".freeze
+  s.extra_rdoc_files = [
+    "LICENSE.txt",
+    "README.md"
+  ]
+  s.files = [
+    ".document",
+    ".rspec",
+    "Gemfile",
+    "Gemfile.lock",
+    "LICENSE.txt",
+    "README.md",
+    "Rakefile",
+    "VERSION",
+    "lib/satoshiproc-unit.rb",
+    "lib/satoshiproc.rb",
+    "satoshiproc-unit.gemspec",
+    "spec/satoshiproc_spec.rb"
+  ]
+  s.homepage = "http://github.com/oscarguindzberg/satoshiproc-unit".freeze
+  s.licenses = ["MIT".freeze]
+  s.rubygems_version = "2.6.12".freeze
+  s.summary = "Converts various proc denominations in Satoshis and back".freeze
+
+  if s.respond_to? :specification_version then
+    s.specification_version = 4
+
+    if Gem::Version.new(Gem::VERSION) >= Gem::Version.new('1.2.0') then
+      s.add_development_dependency(%q<bundler>.freeze, ["~> 1.0"])
+      s.add_development_dependency(%q<jeweler>.freeze, ["~> 2.1.2"])
+      s.add_development_dependency(%q<rspec>.freeze, [">= 0"])
+    else
+      s.add_dependency(%q<bundler>.freeze, ["~> 1.0"])
+      s.add_dependency(%q<jeweler>.freeze, ["~> 2.1.2"])
+      s.add_dependency(%q<rspec>.freeze, [">= 0"])
+    end
+  else
+    s.add_dependency(%q<bundler>.freeze, ["~> 1.0"])
+    s.add_dependency(%q<jeweler>.freeze, ["~> 2.1.2"])
+    s.add_dependency(%q<rspec>.freeze, [">= 0"])
+  end
+end
+

data/spec/satoshiproc_spec.rb

@@ -0,0 +1,90 @@
+require_relative '../lib/satoshiproc-unit'
+
+describe SatoshiProc do
+
+  it "creates a Bignum representing value in satoshiproc units" do
+    expect(SatoshiProc.new(1.00).to_i).to eq(100000000)
+  end
+
+  it "takes care of the sign before the value" do
+    expect(SatoshiProc.new(-1.00).to_i).to eq(-100000000)
+  end
+
+  it "converts satoshiproc unit back to some more common denomination" do
+    expect(SatoshiProc.new(1.00).to_proc).to eq(1)
+    expect(SatoshiProc.new(1.08763).to_proc).to eq(1.08763)
+    expect(SatoshiProc.new(1.08763).to_mproc).to eq(1087.63)
+    expect(SatoshiProc.new(-1.08763).to_mproc).to eq(-1087.63)
+    expect(SatoshiProc.new(0.00000001).to_i).to eq(1)
+    expect(SatoshiProc.new(0.00000001).to_mproc).to eq(0.00001)
+  end
+   
+  it "converts from various source denominations" do
+    expect(SatoshiProc.new(1, unit: 'mproc').to_proc).to      eq(0.001)
+    expect(SatoshiProc.new(1, unit: 'mproc').to_unit).to     eq(1)
+    expect(SatoshiProc.new(10000000, unit: 'mproc').to_unit).to eq(10000000)
+    satoshiproc = SatoshiProc.new(10000000, unit: 'mproc')
+    satoshiproc.satoshiproc_value = 1
+    expect(satoshiproc.to_unit).to eq(0.00001)
+    expect(SatoshiProc.new(100, unit: 'mproc').to_i).to eq(10000000)
+  end
+
+  it "treats nil in value as 0" do
+    expect(SatoshiProc.new < 1).to be_truthy
+    expect(SatoshiProc.new > 1).to be_falsy
+    expect(SatoshiProc.new == 0).to be_truthy
+  end
+
+  it "converts negative values correctly" do
+    expect(SatoshiProc.new(-1.00, unit: :mproc).to_proc).to eq(-0.001)
+  end
+
+  it "converts zero values correctly" do
+    expect(SatoshiProc.new(0, unit: :mproc).to_unit).to eq(0)
+  end
+
+  it "converts nil values correctly" do
+    s = SatoshiProc.new(nil, unit: :mproc)
+    expect(s.value).to eq(0)
+    s.value = nil
+    expect(s.to_unit).to eq(0)
+  end
+
+  it "displays one SatoshiProc in human form, not math form" do
+    one_satoshiproc = SatoshiProc.new(1, from_unit: :satoshiproc, to_unit: :proc)
+    expect(one_satoshiproc.to_unit(as: :string)).not_to eq('1.0e-08')
+    expect(one_satoshiproc.to_unit(as: :string)).to eq('0.00000001')
+  end
+
+  it "displays zero SatoshiProc in human form, not math form" do
+    zero_satoshiproc = SatoshiProc.new(0, from_unit: :satoshiproc, to_unit: :proc)
+    expect(zero_satoshiproc.to_unit(as: :string)).to eq('0.0')
+  end
+
+  it "raises exception if decimal part contains more digits than allowed by from_value" do
+    expect( -> { SatoshiProc.new(0.001000888888888888888, from_unit: :proc).to_unit }).to raise_exception(SatoshiProc::TooManyDigitsAfterDecimalPoint)
+    expect( -> { SatoshiProc.new("0.001000999999999999999", from_unit: :proc).to_unit }).to raise_exception(SatoshiProc::TooManyDigitsAfterDecimalPoint)
+    expect( -> { SatoshiProc.new(0.001000999, from_unit: :proc).to_unit }).to raise_exception(SatoshiProc::TooManyDigitsAfterDecimalPoint)
+    expect( -> { SatoshiProc.new(0.00100099, from_unit: :proc).to_unit }).not_to raise_exception
+    expect( -> { SatoshiProc.new(0.123456789, from_unit: :proc) }).to raise_exception(SatoshiProc::TooManyDigitsAfterDecimalPoint)
+    expect( -> { SatoshiProc.new(0.12345678, from_unit: :proc).to_unit }).not_to raise_exception
+    expect( -> { SatoshiProc.new(nil, from_unit: :proc).to_unit }).not_to raise_exception
+  end
+
+  it "disallows to create values more than 21mil PROC" do
+    expect( -> { SatoshiProc.new(21_000_001) }).to raise_exception(SatoshiProc::TooLarge)
+    expect( -> { SatoshiProc.new(21_000_000) }).not_to raise_exception
+  end
+
+  it "returns satoshiproc for +,- and * methods if both operands are SatoshiProc" do
+    s1 = SatoshiProc.new(0.001, from_unit: :proc)
+    s2 = SatoshiProc.new(0.002, from_unit: :proc)
+    expect(s1+s2).to be_kind_of(SatoshiProc)
+    expect((s1+s2).to_unit).to eq(0.003)
+    expect(s2-s1).to be_kind_of(SatoshiProc)
+    expect((s2-s1).to_unit).to eq(0.001)
+    expect(s2*s1).to be_kind_of(SatoshiProc)
+    expect((s2*s1).to_unit).to eq(200)
+  end
+
+end

metadata

@@ -0,0 +1,100 @@
+--- !ruby/object:Gem::Specification
+name: satoshiproc-unit
+version: !ruby/object:Gem::Version
+  version: 0.2.2
+platform: ruby
+authors:
+- Roman Snitko
+- Oscar Guindzberg
+autorequire: 
+bindir: bin
+cert_chain: []
+date: 2017-06-20 00:00:00.000000000 Z
+dependencies:
+- !ruby/object:Gem::Dependency
+  name: bundler
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: '1.0'
+  type: :development
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: '1.0'
+- !ruby/object:Gem::Dependency
+  name: jeweler
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: 2.1.2
+  type: :development
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: 2.1.2
+- !ruby/object:Gem::Dependency
+  name: rspec
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - ">="
+      - !ruby/object:Gem::Version
+        version: '0'
+  type: :development
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - ">="
+      - !ruby/object:Gem::Version
+        version: '0'
+description: Converts various proc denominations in Satoshis and back
+email: oscar.guindzberg@gmail.com
+executables: []
+extensions: []
+extra_rdoc_files:
+- LICENSE.txt
+- README.md
+files:
+- ".document"
+- ".rspec"
+- Gemfile
+- Gemfile.lock
+- LICENSE.txt
+- README.md
+- Rakefile
+- VERSION
+- lib/satoshiproc-unit.rb
+- lib/satoshiproc.rb
+- satoshiproc-unit.gemspec
+- spec/satoshiproc_spec.rb
+homepage: http://github.com/oscarguindzberg/satoshiproc-unit
+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.6.12
+signing_key: 
+specification_version: 4
+summary: Converts various proc denominations in Satoshis and back
+test_files: []