cashify 0.9.1

checksums.yaml

@@ -0,0 +1,7 @@
+---
+SHA256:
+  metadata.gz: 0d31e15d5b41014afa8408f2eb88f2951ceb129c8b1f189c0fb4783d506a9e99
+  data.tar.gz: 3d88a0eab4b01d2dbfb4ea67cc32c26e255d677f6d71ea34b056fcaca426a3ef
+SHA512:
+  metadata.gz: 4fc2adb94912de958291b7a5aa878a89cde682aa1dad935136576e4df4a9705570b7bfc85fbeadb027e9d0478de0b269e4482fbefbbe664f0914c2d8b83247ac
+  data.tar.gz: 8dac497d6a56923a1d7dadfe96ef64dba8e5fb7aba33b1278e392b8759b83c4ee0f6515a8c7e55c8a0ac7d948b4298cbc2e210449415bc93b19fecafc7377b14

data/.rubocop.yml

@@ -0,0 +1,26 @@
+AllCops:
+  TargetRubyVersion: 3.0.0
+  NewCops: enable
+
+Layout/LineLength:
+  Max: 120
+
+Metrics/CyclomaticComplexity:
+  Max: 8
+
+Metrics/MethodLength:
+  Max: 16
+
+Style/Documentation:
+  Enabled: false
+
+Style/FrozenStringLiteralComment:
+  EnforcedStyle: never
+
+Style/StringLiterals:
+  Enabled: true
+  EnforcedStyle: double_quotes
+
+Style/StringLiteralsInInterpolation:
+  Enabled: true
+  EnforcedStyle: double_quotes

data/.ruby-version

@@ -0,0 +1 @@
+ruby-3.0.2

data/CHANGELOG.md

@@ -0,0 +1,7 @@
+## [0.9.1] - 2021-10-08
+
+- Add `cashify` method for Active Record users (Johan Halse)
+
+## [0.9.0] - 2021-09-24
+
+- Initial release

data/Gemfile

@@ -0,0 +1,11 @@
+source "https://rubygems.org"
+
+# Specify your gem's dependencies in cashify.gemspec
+gemspec
+
+gem "minitest", "~> 5.0"
+gem "pry"
+gem "rake", "~> 13.0"
+gem "rubocop"
+gem "rubocop-minitest"
+gem "rubocop-rake"

data/Gemfile.lock

@@ -0,0 +1,55 @@
+PATH
+  remote: .
+  specs:
+    cashify (0.9.1)
+
+GEM
+  remote: https://rubygems.org/
+  specs:
+    ast (2.4.2)
+    coderay (1.1.3)
+    method_source (1.0.0)
+    minitest (5.14.4)
+    parallel (1.21.0)
+    parser (3.0.2.0)
+      ast (~> 2.4.1)
+    pry (0.14.1)
+      coderay (~> 1.1)
+      method_source (~> 1.0)
+    rainbow (3.0.0)
+    rake (13.0.6)
+    regexp_parser (2.1.1)
+    rexml (3.2.5)
+    rubocop (1.22.1)
+      parallel (~> 1.10)
+      parser (>= 3.0.0.0)
+      rainbow (>= 2.2.2, < 4.0)
+      regexp_parser (>= 1.8, < 3.0)
+      rexml
+      rubocop-ast (>= 1.12.0, < 2.0)
+      ruby-progressbar (~> 1.7)
+      unicode-display_width (>= 1.4.0, < 3.0)
+    rubocop-ast (1.12.0)
+      parser (>= 3.0.1.1)
+    rubocop-minitest (0.15.1)
+      rubocop (>= 0.90, < 2.0)
+    rubocop-rake (0.6.0)
+      rubocop (~> 1.0)
+    ruby-progressbar (1.11.0)
+    unicode-display_width (2.1.0)
+
+PLATFORMS
+  x86_64-darwin-19
+  x86_64-linux
+
+DEPENDENCIES
+  cashify!
+  minitest (~> 5.0)
+  pry
+  rake (~> 13.0)
+  rubocop
+  rubocop-minitest
+  rubocop-rake
+
+BUNDLED WITH
+   2.2.26

data/LICENSE.txt

@@ -0,0 +1,21 @@
+The MIT License (MIT)
+
+Copyright (c) 2021 Johan Halse
+
+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,227 @@
+[![Main](https://github.com/johanhalse/cashify/actions/workflows/main.yml/badge.svg)](https://github.com/johanhalse/cashify/actions/workflows/main.yml)
+
+# Cashify
+
+Ever had to work with money in more than one currency? Ever wish you could do stuff like add them to one another without getting murdered by exceptions? Here's the gem for you.
+
+![Cashify](https://media4.giphy.com/media/EnoO73pTnn99JrnRR3/giphy.gif)
+
+## Installation
+
+Add this line to your application's Gemfile:
+
+```ruby
+gem "cashify"
+```
+
+And then execute:
+
+    $ bundle install
+
+Or install it yourself as:
+
+    $ gem install cashify
+
+## Usage
+
+Cashify is a money handling gem that's inherently nice to currencies. It lets you treat your money as mostly numbers, freeing you from a lot of headache around manipulating and handling it. Instantiate a new `Cash` object like so:
+
+```ruby
+puts Cash.new(SEK: 100_00)
+# 100 SEK
+```
+
+Add another currency? Sure.
+
+```ruby
+puts Cash.new(EUR: 100_00, SEK: 100_00)
+# 100 EUR, 100 SEK
+```
+
+And then maybe do some addition or subtraction?
+
+```ruby
+puts Cash.new(SEK: 100_00) + Cash.new(USD: 100_00) + Cash.new(USD: 50_00)
+# 100 SEK, 150 USD
+```
+
+Perhaps add a little discount here or there?
+
+```ruby
+puts (Cash.new(SEK: 100_00) + Cash.new(USD: 100_00)) * 0.9
+# 90 SEK, 90 USD
+```
+
+Increase the values a little? Why not!
+
+```ruby
+puts (Cash.new(SEK: 100_00, USD: 100_00) + 20
+# 120 SEK, 120 USD
+```
+
+### What. You can't just add integers to currencies
+
+I can, in fact, totally add integers to currencies. And now you can, too! Also subtract, divide, multiply... look: this probably sounds bad to you. Foreign, somehow. Your parents raised you well, and you've already used the ubiquitous [Money](https://github.com/RubyMoney/money) gem and tried to add a shipping cost or something. The Money gem then told you to stop immediately and stomped off into Exception Land, leaving you empty-handed and full of regret.
+
+Or maybe you wanted to work with zero? You'll get answers on the Internet saying things like "aha but what would zero even mean when using a currency" and my answer to that would be "well at least 0 USD is the same as 0 SEK, right?" and so you can casually do `Cash.new(SEK: 0) + Cash.new(USD: 100)` and get `100 USD` back and then imagine these pedants popping a vein and dying. A zero is a zero. Don't try to tell me otherwise.
+
+### Can you _really_ compare currencies that way though?
+
+Well, I guess we can! And we're not even done. Check this out:
+
+```ruby
+Cash.new(SEK: 100_00) > Cash.new(USD: 50_00)
+# true
+```
+
+Is this right or wrong? Who even knows at this point. But it's _useful_, and that's all we care about! I'll agree that the comparison is super naive, and you can Freedom Patch that if you like, or go the Money Gem route and pipe those objects through your own functions. But you see where we're going, right? Wouldn't it be nice to just grab various sums of currencies from your database, cast them to Cash objects, and have them just sort of _work_ without putting up guardrails everywhere? Yes it would. The default assumption of "when you try to add one money to another money that probably means you want a conversion somewhere" is wrong in most cases. Also, initialization matters! Cashify is very database friendly. Imagine a Rails app with `Purchase` objects that all have a cost. Then look at this beauty:
+
+```ruby
+Cash.new Purchase.all.group(:cost_currency).sum(:cost_cents)
+```
+
+That piece of code pulls _however many objects in however many currencies_ and tallies them up in SQL, returning a useful Cash object containing something along the lines of `1100 EUR, 1400 SEK, 2155 USD`. If you want, you can smack a multiplier on those and add a discount. Or add a processing fee of `100 SEK`. You be the boss.
+
+### This sounds dangerous and illegal, shouldn't these operations throw exceptions?
+
+No, they probably shouldn't. The Money Gem school of thought says that every time you do something potentially hazardous to your money — like try to add an integer, not caring which currency you're dealing with — there's an exception, and then you'll have to handle that exception in a way that makes sense for your use case. I do see the logic, but in practice it gets old REAL fast. You'll be stuck in a never-ending shouting match with your money objects, having to drag them kicking and screaming through a bunch of guard statements in order to do simple things like addition. If you're only dealing with a single currency it's not too bad, but as soon as you add another one to the mix the noise level is deafening. And honestly: if you're only dealing with a single currency, why are you even using a money gem? You could use fixed point integers instead, pushing any currency-specific stuff to the boundaries of your code.
+
+This in mind, Cashify posits that if you want to get these things right, you should be treating your money as simple numbers as often as possible. Currencies are a necessary evil but they're not your overarching concern, and this gem will allow them to lurk in the background where they belong. Throw those Cash objects around, stuff them into arrays, collide them in interesting ways. Swim around in your money like you're Scrooge McDuck and let your database do most of the work for you! It'll feel great, I promise.
+
+### Do you handle displaying currencies nicely, too?
+
+Oof, sounds hard. Out of scope. Write a view helper or something.
+
+### And when you actually do want to convert currencies?
+
+There are plenty of gems for that and it's honestly pretty easy. But you'll have to write your own code for it.
+
+## API
+
+#### `.positive?` and `.negative?`
+
+Returns true if all currencies are positive/negative.
+
+```ruby
+Cash.new(SEK: 100_00, USD: 100_00).positive?
+# true
+
+Cash.new(SEK: 100_00, USD: -1_00).positive?
+# false
+
+Cash.new(SEK: -100_00, USD: -100_00).negative?
+# true
+```
+
+#### `.zero?`
+
+Returns true if all currencies are zero.
+
+```ruby
+Cash.new(SEK: 0).zero?
+# true
+
+Cash.new(SEK: 0, USD: 1_00).zero?
+# false
+```
+
+#### `.abs`
+
+Makes all values positive.
+
+```ruby
+Cash.new(SEK: -100_00, USD: 1_00).abs
+# 100 SEK, 1 USD
+```
+
+#### `.zero`
+
+Shorthand for a zero currency. Use it instead of `Cash.new(DKK: 0)` because having to specify currency for zero feels wordy and awkward.
+
+```ruby
+Cash.zero
+# 0 USD
+```
+
+#### `.to_a`
+
+Splits all the currencies out into an array of `Cash` objects.
+
+```ruby
+Cash.new(EUR: 100_00, SEK: 100_00, USD: 100_00).to_a
+# [Cash(EUR: 100_00), Cash(SEK: 100_00), Cash(USD: 100_00)]
+```
+
+#### `.to_s`
+
+Get a simple string back.
+
+```ruby
+Cash.new(EUR: 100_00, SEK: 100_00, USD: 100_00).to_s
+# "100 EUR, 100 SEK, 100 USD"
+```
+
+#### `.sum`
+
+You'll be working with arrays of Cash objects a lot. You should absolutely be using Ruby's excellent array methods on them, but unfortunately `cash_array.sum` won't work. Ruby's `sum` method injects a `0` as the first value, and even though `Cash.new(USD: 100) + 0` is super valid and nice, `0 + Cash.new(USD: 100)` will try to coerce your Cash object into an integer which just won't work. So if you want to sum an array of Cash, you can instead use:
+
+```ruby
+Cash.sum [Cash.new(EUR: 100_00), Cash.new(SEK: 100_00), Cash.new(EUR: 100_00)]
+# 200 EUR, 100 SEK
+```
+
+#### `.empty?`
+
+Returns true if there are no currencies in the object.
+
+```ruby
+Cash.new.empty?
+# true
+
+Cash.new(NOK: 100_00).empty?
+# false
+```
+
+#### `.round`
+
+Rounds currencies to a power interval.
+
+```ruby
+Cash.new(EUR: 100_50, SEK: 122_25).round(100)
+# 101 EUR, 122 SEK
+
+Cash.new(EUR: 100_50, SEK: 122_25).round(1000)
+# 100 EUR, 120 SEK
+```
+
+#### `.currency`
+
+Returns the first currency in the Cash object as a symbol
+
+```ruby
+Cash.new(NOK: 100).currency
+# :NOK
+```
+
+#### `.value`
+
+Returns the first value in the Cash object.
+
+```ruby
+Cash.new(NOK: 100).value
+# 100
+```
+
+## Development
+
+After checking out the repo, run `bin/setup` to install dependencies. Then, run `rake test` to run the tests. You can also run `bin/console` for an interactive prompt that will allow you to experiment.
+
+To install this gem onto your local machine, run `bundle exec rake install`. To release a new version, update the version number in `version.rb`, and then run `bundle exec rake release`, which will create a git tag for the version, push git commits and the created tag, and push the `.gem` file to [rubygems.org](https://rubygems.org).
+
+## Contributing
+
+Bug reports and pull requests are welcome on GitHub at https://github.com/johanhalse/cashify.
+
+## License
+
+The gem is available as open source under the terms of the [MIT License](https://opensource.org/licenses/MIT).

data/Rakefile

@@ -0,0 +1,14 @@
+require "bundler/gem_tasks"
+require "rake/testtask"
+
+Rake::TestTask.new(:test) do |t|
+  t.libs << "test"
+  t.libs << "lib"
+  t.test_files = FileList["test/**/*_test.rb"]
+end
+
+require "rubocop/rake_task"
+
+RuboCop::RakeTask.new
+
+task default: %i[test rubocop]

data/bin/console

@@ -0,0 +1,13 @@
+#!/usr/bin/env ruby
+require "bundler/setup"
+require "cashify"
+
+# You can add fixtures and/or initialization code here to make experimenting
+# with your gem easier. You can also use a different console, if you like.
+
+# (If you use this, don't forget to add pry to your Gemfile!)
+# require "pry"
+# Pry.start
+
+require "irb"
+IRB.start(__FILE__)

data/bin/setup

@@ -0,0 +1,8 @@
+#!/usr/bin/env bash
+set -euo pipefail
+IFS=$'\n\t'
+set -vx
+
+bundle install
+
+# Do any other automated setup that you need to do here

data/lib/cashify/arithmetic.rb

@@ -0,0 +1,83 @@
+class Cash
+  module Arithmetic
+    def +(other)
+      raise Cash::Errors::AdditionError unless other.respond_to?(:zero?)
+      return self unless present?(other)
+      return self if other.zero?
+      return other if zero?
+
+      return Cash.new(**add_currencies(other)) if other.is_a?(Cash)
+
+      Cash.new(**add_number(other)) if other.is_a?(Integer) || other.is_a?(Float)
+    end
+
+    def -(other)
+      raise Cash::Errors::SubtractionError unless other.respond_to?(:zero?)
+      return self unless present?(other)
+      return Cash.new(**subtract_currencies(other)) if other.is_a?(Cash) || other.zero?
+
+      Cash.new(**subtract_number(other)) if other.is_a?(Integer) || other.is_a?(Float)
+    end
+
+    def *(other)
+      return Cash.new(**multiply_number(other)) if other.is_a?(Integer) || other.is_a?(Float)
+      return Cash.new(**multiply_currencies(other)) if other.is_a?(Cash)
+
+      raise Cash::Errors::MultiplicationError
+    end
+
+    def /(other)
+      return Cash.new(**divide_number(other)) if other.is_a?(Integer) || other.is_a?(Float)
+      return Cash.new(**divide_currencies(other)) if other.is_a?(Cash)
+
+      raise Cash::Errors::DivisionError
+    end
+
+    private
+
+    def present?(other)
+      !(other.nil? || other == "" || other == false)
+    end
+
+    def multiply_number(other)
+      currencies.transform_values { |v| v * other }
+    end
+
+    def multiply_currencies(other)
+      currencies.merge(other.currencies) { |_k, a, b| a * b }
+    end
+
+    def divide_number(other)
+      currencies.transform_values { |v| v / other }
+    end
+
+    def divide_currencies(other)
+      currencies.merge(other.currencies) { |_k, a, b| a / b }
+    end
+
+    def add_currencies(other)
+      currencies.merge(other.currencies) { |_k, a, b| a + b }
+    end
+
+    def add_number(other)
+      currencies.transform_values { |v| v + other }
+    end
+
+    def subtract_number(other)
+      currencies.transform_values { |v| v - other }
+    end
+
+    def subtract_currencies(other) # rubocop:disable Metrics/AbcSize
+      return currencies unless other.respond_to?(:zero?)
+      return currencies if other.zero?
+      return other.currencies.transform_values { |v| 0 - v } if zero?
+
+      (@currencies.keys + other.currencies.keys).uniq.map do |k|
+        minuend = @currencies[k] || 0
+        subtrahend = other.currencies[k] || 0
+
+        [k, minuend - subtrahend]
+      end.to_h
+    end
+  end
+end

data/lib/cashify/cashify.rb

@@ -0,0 +1,25 @@
+class Cash
+  module Cashify
+    extend ActiveSupport::Concern
+
+    included do
+      def self.cashify(*fields)
+        fields.each do |field_name|
+          cents_field = "#{field_name}_cents"
+          currency_field = "#{field_name}_currency"
+
+          define_method(field_name) do
+            return nil if read_attribute(currency_field).nil? || read_attribute(cents_field).nil?
+
+            Cash.new(read_attribute(currency_field) => read_attribute(cents_field))
+          end
+
+          define_method("#{field_name}=") do |cash|
+            write_attribute(cents_field, cash.value)
+            write_attribute(currency_field, cash.currency)
+          end
+        end
+      end
+    end
+  end
+end

data/lib/cashify/errors.rb

@@ -0,0 +1,11 @@
+class Cash
+  module Errors
+    class AdditionError < StandardError; end
+
+    class SubtractionError < StandardError; end
+
+    class MultiplicationError < StandardError; end
+
+    class DivisionError < StandardError; end
+  end
+end

data/lib/cashify/version.rb

@@ -0,0 +1,3 @@
+module Cashify
+  VERSION = "0.9.1".freeze
+end

data/lib/cashify.rb

@@ -0,0 +1,91 @@
+require_relative "cashify/version"
+require_relative "cashify/arithmetic"
+require_relative "cashify/errors"
+
+if defined?(::Rails::Railtie)
+  require_relative "cashify/cashify"
+
+  class CashifyRailtie < Rails::Railtie
+    initializer "cashify.configure_rails_initialization" do
+      ActiveSupport.on_load(:active_record) do
+        ::ActiveRecord::Base.include(Cash::Cashify)
+      end
+    end
+  end
+end
+
+class Cash
+  include Cash::Arithmetic
+  include Cash::Errors
+  include Comparable
+
+  attr_accessor :currencies
+
+  def self.zero
+    new(USD: 0)
+  end
+
+  def self.sum(cashes)
+    cashes.inject(Cash.zero, :+)
+  end
+
+  def initialize(**currencies)
+    @currencies = currencies
+                  .transform_keys(&:to_sym)
+                  .transform_values(&:to_i)
+                  .sort.to_h
+  end
+
+  def ==(other)
+    return currencies == other.currencies || (zero? && other.zero?) if other.is_a?(Cash)
+
+    zero? && (other.respond_to?(:zero?) && other.zero?)
+  end
+
+  def zero?
+    currencies.values.all?(&:zero?)
+  end
+
+  def positive?
+    currencies.values.all?(&:positive?)
+  end
+
+  def negative?
+    currencies.values.all?(&:negative?)
+  end
+
+  def <=>(other)
+    other_sum = other if other.is_a?(Integer) || other.is_a?(Float)
+    other_sum = other.currencies.values.sum if other.is_a?(Cash)
+
+    currencies.values.sum <=> other_sum
+  end
+
+  def to_a
+    currencies.map { |k, v| Cash.new(k => v) }
+  end
+
+  def to_s
+    currencies.map { |k, v| "#{(v * 0.01).round} #{k}" }.join(", ")
+  end
+
+  def currency
+    currencies.keys.first
+  end
+
+  def value
+    currencies.values.first
+  end
+
+  def empty?
+    currencies.empty?
+  end
+
+  def abs
+    Cash.new(**currencies.transform_values(&:abs))
+  end
+
+  def round(interval = 100)
+    Cash.new(**currencies.transform_values { |v| (v / interval.to_f).round * interval })
+  end
+end

metadata

@@ -0,0 +1,63 @@
+--- !ruby/object:Gem::Specification
+name: cashify
+version: !ruby/object:Gem::Version
+  version: 0.9.1
+platform: ruby
+authors:
+- Johan Halse
+autorequire: 
+bindir: exe
+cert_chain: []
+date: 2021-10-08 00:00:00.000000000 Z
+dependencies: []
+description: Money trouble no more! Add, subtract, and have fun with money in different
+  currencies.
+email:
+- johan@hal.se
+executables: []
+extensions: []
+extra_rdoc_files: []
+files:
+- ".rubocop.yml"
+- ".ruby-version"
+- CHANGELOG.md
+- Gemfile
+- Gemfile.lock
+- LICENSE.txt
+- README.md
+- Rakefile
+- bin/console
+- bin/setup
+- lib/cashify.rb
+- lib/cashify/arithmetic.rb
+- lib/cashify/cashify.rb
+- lib/cashify/errors.rb
+- lib/cashify/version.rb
+homepage: https://github.com/johanhalse/cashify
+licenses:
+- MIT
+metadata:
+  allowed_push_host: https://rubygems.org
+  homepage_uri: https://github.com/johanhalse/cashify
+  source_code_uri: https://github.com/johanhalse/cashify
+  changelog_uri: https://github.com/johanhalse/cashify/CHANGELOG.md
+post_install_message: 
+rdoc_options: []
+require_paths:
+- lib
+required_ruby_version: !ruby/object:Gem::Requirement
+  requirements:
+  - - ">="
+    - !ruby/object:Gem::Version
+      version: 3.0.0
+required_rubygems_version: !ruby/object:Gem::Requirement
+  requirements:
+  - - ">="
+    - !ruby/object:Gem::Version
+      version: '0'
+requirements: []
+rubygems_version: 3.2.22
+signing_key: 
+specification_version: 4
+summary: A sensible way to handle money
+test_files: []