rounding 1.0.0

checksums.yaml

@@ -0,0 +1,7 @@
+---
+SHA1:
+  metadata.gz: b4d99f27fefc944b1bcc3a0a47db81474752063b
+  data.tar.gz: 4a189b36da5764596dc6ab7aafab2ebecc1ecdd8
+SHA512:
+  metadata.gz: 27f3843718eeedbd3729d67dd769342b5e862345a98bdac80b7a1c60eaf074b06018c319658cfa55f76dfa03efc0ea6795deafed07d1f4ca8e86a516e8ce3e24
+  data.tar.gz: e53bc824025c5c8c3f78474678a0e738b93d3513f0e6c77eae8735d6d4009301c839413101e62c984c15e3bfc78ccb0cdc308577a2f8403ebf6c498f5c4ee343

data/.gitignore

@@ -0,0 +1,22 @@
+*.gem
+*.rbc
+.bundle
+.config
+.yardoc
+Gemfile.lock
+InstalledFiles
+_yardoc
+coverage
+doc/
+lib/bundler/man
+pkg
+rdoc
+spec/reports
+test/tmp
+test/version_tmp
+tmp
+*.bundle
+*.so
+*.o
+*.a
+mkmf.log

data/.travis.yml

@@ -0,0 +1,5 @@
+language: ruby
+rvm:
+  - 2.1.2
+  - 2.0.0
+  - 1.9.3

data/Gemfile

@@ -0,0 +1,4 @@
+source 'https://rubygems.org'
+
+# Specify your gem's dependencies in rounding.gemspec
+gemspec

data/LICENSE.txt

@@ -0,0 +1,3 @@
+Rounding is dedicated to the public domain by its author, Brian Hempel. No rights are reserved. No restrictions are placed on the use of Rounding. That freedom also means, of course, that no warrenty of fitness is claimed; use Rounding at your own risk.
+
+Public domain dedication is explained by the CC0 1.0 summary (and only the summary) at https://creativecommons.org/publicdomain/zero/1.0/

data/README.md

@@ -0,0 +1,239 @@
+# Rounding
+
+[![Gem Version](https://badge.fury.io/rb/rounding.svg)](http://badge.fury.io/rb/rounding)
+[![Build Status](https://travis-ci.org/brianhempel/rounding.svg)](https://travis-ci.org/brianhempel/rounding)
+
+Rounding allows you to round any numeric value to anything you want. You can also round a Time to, for example, the nearest 15 minutes.
+
+Some quick examples:
+
+```ruby
+require 'rounding'
+
+26.round_to(10)               # => 30
+8.77.floor_to(2.5)            # => 7.5
+101.ceil_to(25)               # => 125
+Time.now.round_to(15.minutes) # => 2014-09-08 22:30:00 -0400
+```
+
+Rounding is compatible with ActiveSupport's Time extensions, but also works fine without ActiveSupport.
+
+## Installation
+
+Add this line to your application's Gemfile:
+
+```ruby
+gem 'rounding'
+```
+
+And then execute:
+
+    $ bundle
+
+Or install it yourself like so:
+
+    $ gem install rounding
+
+## Usage
+
+First, require the gem.
+
+```ruby
+require 'rounding'
+```
+
+Rounding adds three methods to all Numeric objects: `round_to`, `floor_to`, and `ceil_to`.
+
+`round_to` rounds to the nearest multiple of the chosen step.
+
+```ruby
+254.round_to(100) # => 300
+1.4.round_to(3)   # => 0
+1.5.round_to(3)   # => 3
+1.6.round_to(3)   # => 3
+-8.round_to(3)    # => -9
+```
+
+`floor_to` rounds down to a multiple of the chosen step.
+
+```ruby
+299.floor_to(100)  # => 200
+1.81.floor_to(0.5) # => 1.5
+60.floor_to(15)    # => 60
+-8.floor_to(3)     # => -9
+```
+
+`ceil_to` rounds up to a multiple of the chosen step.
+
+```ruby
+201.ceil_to(100)  # => 300
+1.71.ceil_to(0.5) # => 2.0
+60.ceil_to(15)    # => 60
+-8.ceil_to(3)     # => -6
+```
+
+For all methods, the class of the result depends on the input arguments.
+
+```ruby
+16.round_to(10)     # => 20
+16.round_to(10.0)   # => 20.0
+16.0.round_to(10)   # => 20
+16.0.round_to(10.0) # => 20.0
+```
+
+If you need super-precise rounding, use Rationals.
+
+```ruby
+time = Time.now.to_f         # => 1410230400.4758651
+time.round_to(0.0001)        # => 1410230400.4759002 # Float is not exact
+time.round_to(1.to_r/10_000) # => (14102304004759/10000)
+```
+
+You can provide an offset if you want the multiples to start counting from something other than zero.
+
+```ruby
+# rounding by 10 with an offset of 3 will round to 3, 13, 23, 33, 43, 53 etc.
+18.round_to(10, 3) # => 23
+18.floor_to(10, 3) # => 13
+18.ceil_to(10, 3)  # => 23
+0.ceil_to(10, 3)   # => 3
+0.floor_to(10, 3)  # => -7
+```
+
+### Usage with Time and TimeWithZone objects
+
+You can round times to whatever you like. The units are seconds.
+
+```ruby
+time = Time.now      # => 2014-09-08 22:57:34 -0400
+
+# to next 10 minutes...
+time.ceil_to(60*10)  # => 2014-09-08 23:00:00 -0400
+
+# to previous 15 minutes...
+time.floor_to(60*15) # => 2014-09-08 22:45:00 -0400
+
+# to nearest hour...
+time.round_to(60*60) # => 2014-09-08 23:00:00 -0400
+```
+
+If you need to round to something smaller than one second, use rationals to avoid precision loss.
+
+```ruby
+time.xmlschema(6)                       # => "2014-09-08T22:57:34.433197-04:00"
+time.round_to(1.to_r/1000).xmlschema(6) # => "2014-09-08T22:57:34.433000-04:00"
+```
+
+Times are rounded in their time zone.
+
+```ruby
+ONE_DAY = 60*60*24
+
+time.round_to(ONE_DAY) # => 2014-09-09 00:00:00 -0400
+```
+
+If you want to round in UTC, use `round_in_utc_to`, `floor_in_utc_to`, and `ceil_in_utc_to`.
+
+```ruby
+time.round_in_utc_to(ONE_DAY) # => 2014-09-08 20:00:00 -0400
+time.floor_in_utc_to(ONE_DAY) # => 2014-09-08 20:00:00 -0400
+time.ceil_in_utc_to(ONE_DAY)  # => 2014-09-09 20:00:00 -0400
+```
+
+If you want the result in UTC instead of the original time zone, convert to UTC first.
+
+```ruby
+time.dup.utc.round_to(ONE_DAY) # => 2014-09-09 00:00:00 UTC
+```
+
+You can provide a base value to round around.
+
+```ruby
+# round to Wednesday
+
+wednesday = Time.parse("2014-09-03 -0400")
+one_week  = ONE_DAY*7
+
+time.round_to(one_week, wednesday) # => 2014-09-10 00:00:00 -0400
+```
+
+If you've loaded ActiveSupport, you can use ActiveSupport's duration sugar to write expressions like `1.day` instead of `60*60*24`.
+
+```ruby
+require "active_support/time"
+
+time.round_to(1.day)     # => 2014-09-09 00:00:00 -0400
+time.round_to(5.minutes) # => 2014-09-08 23:00:00 -0400
+```
+
+ActiveSupport's TimeWithZone is fully supported.
+
+```ruby
+time = ActiveSupport::TimeZone["Bern"].parse("2014-09-08 22:57:34 -0400")
+# => Tue, 09 Sep 2014 04:57:34 CEST +02:00
+
+time.round_to(12.hours)       # => Tue, 09 Sep 2014 00:00:00 CEST +02:00
+time.round_to(12.hours).class # => ActiveSupport::TimeWithZone
+```
+
+For rounding to the month or year, you should use ActiveSupport's time extensions. Months and years have variable numbers of days and thus are not correctly supported by Rounding.
+
+### Usage with DateTime objects
+
+Rounding also works with DateTime objects. Unlike Time objects, you will be rounding to a chosen number of days rather than a number of seconds.
+
+```ruby
+require 'date'
+
+date_time = DateTime.now # => Mon, 08 Sep 2014 23:46:16 -0400
+
+date_time.round_to(1)    # => Tue, 09 Sep 2014 00:00:00 -0400
+```
+
+Use rational fractions of a day to round to the desired unit.
+
+```ruby
+# 1 hour
+date_time.floor_to(1.to_r/24)      # => Mon, 08 Sep 2014 23:00:00 -0400
+# 5 minutes
+date_time.floor_to(1.to_r/24/60*5) # => Mon, 08 Sep 2014 23:45:00 -0400
+```
+
+ActiveSupport's duration helpers can save you from writing ugly expressions.
+
+```ruby
+date_time.floor_to(1.hour)    # => Mon, 08 Sep 2014 23:00:00 -0400
+date_time.floor_to(5.minutes) # => Mon, 08 Sep 2014 23:45:00 -0400
+```
+
+The `round_in_utc_to`, `floor_in_utc_to`, and `ceil_in_utc_to` are also available on DateTime objects. However, to round around the UNIX epoch in your time zone, you will need to provide a custom center for rounding.
+
+```ruby
+fortnight = 2.weeks
+
+# UNIX epoch is a Thursday in UTC, Julian epoch is a Monday
+
+date_time.round_to(fortnight)                        # => Mon, 15 Sep 2014 00:00:00 -0400
+date_time.round_in_utc_to(fortnight)                 # => Wed, 10 Sep 2014 20:00:00 -0400
+
+unix_epoch_minus_four = DateTime.new(1970, 1, 1, 0, 0, 0, "-0400")
+date_time.round_to(fortnight, unix_epoch_minus_four) # => Thu, 11 Sep 2014 00:00:00 -0400
+```
+
+Happy rounding!
+
+## License
+
+Rounding is dedicated to the public domain by its author, Brian Hempel. No rights are reserved. No restrictions are placed on the use of Rounding. That freedom also means, of course, that no warrenty of fitness is claimed; use Rounding at your own risk.
+
+Public domain dedication is explained by the CC0 1.0 summary (and only the summary) at https://creativecommons.org/publicdomain/zero/1.0/
+
+## Contributing
+
+1. Fork it ( https://github.com/brianhempel/rounding/fork )
+2. Create your feature branch (`git checkout -b my-new-feature`)
+3. Run the tests with `rspec`
+4. There is also a `bin/console` command to load up a REPL for playing around
+5. Commit your changes (`git commit -am 'Add some feature'`)
+6. Push to the branch (`git push origin my-new-feature`)
+7. Create a new Pull Request

data/Rakefile

@@ -0,0 +1,8 @@
+require "bundler/gem_tasks"
+
+task :default => :spec
+
+desc "Run the tests"
+task :spec do
+  exec "bundle exec rspec"
+end

data/bin/console

@@ -0,0 +1,11 @@
+#!/usr/bin/env ruby
+
+$LOAD_PATH.unshift File.expand_path("../../lib", __FILE__)
+require "rounding"
+require "active_support/time"
+require "pry"
+
+TIME_ZONE = ActiveSupport::TimeZone["Bern"]
+AST       = ActiveSupport::TimeZone["Kuwait"] # something without DST
+
+binding.pry

data/lib/rounding.rb

@@ -0,0 +1,5 @@
+require "rounding/version"
+require "rounding/core_ext/numeric"
+require "rounding/core_ext/time"
+require "rounding/core_ext/date_time"
+require "rounding/active_support_ext/time_with_zone"

data/lib/rounding/active_support_ext/time_with_zone.rb

@@ -0,0 +1,7 @@
+require 'rounding/time_extensions'
+
+module ActiveSupport
+  class TimeWithZone
+    include Rounding::TimeExtensions
+  end
+end

data/lib/rounding/core_ext/date_time.rb

@@ -0,0 +1,53 @@
+require 'rounding/time_extensions'
+
+class DateTime < Date
+  include Rounding::TimeExtensions
+
+  UNIX_EPOCH = 2440588
+
+  raise "DateTime#to_r already defined! Definitions may conflict" if method_defined?(:to_r)
+  def to_r
+    no_offset = new_offset(0)
+    no_offset.jd + no_offset.day_fraction
+  end
+
+  def floor_to(step, around=-offset)
+    step   = decode_duration(step)
+    around = decode_duration(around)
+    super(step, around)
+  end
+
+  def ceil_to(step, around=-offset)
+    step   = decode_duration(step)
+    around = decode_duration(around)
+    super(step, around)
+  end
+
+  def round_to(step, around=-offset)
+    step   = decode_duration(step)
+    around = decode_duration(around)
+    super(step, around)
+  end
+
+  def floor_in_utc_to(step)
+    floor_to(step, UNIX_EPOCH)
+  end
+
+  def ceil_in_utc_to(step)
+    ceil_to(step, UNIX_EPOCH)
+  end
+
+  def round_in_utc_to(step)
+    round_to(step, UNIX_EPOCH)
+  end
+
+  private
+
+  def decode_duration(value)
+    if defined?(ActiveSupport::Duration) && ActiveSupport::Duration === value
+      value.to_r / 1.day.to_r
+    else
+      value  
+    end
+  end
+end

data/lib/rounding/core_ext/numeric.rb

@@ -0,0 +1,18 @@
+class Numeric
+  def floor_to(step, around=0)
+    whole, _ = (self - around).divmod(step)
+    whole * step + around
+  end
+
+  def ceil_to(step, around=0)
+    whole, remainder = (self - around).divmod(step)
+    num_steps = remainder > 0 ? whole + 1 : whole
+    num_steps * step + around
+  end
+
+  def round_to(step, around=0)
+    whole, remainder = (self - around).divmod(step)
+    num_steps = remainder*2 >= step ? whole + 1 : whole
+    num_steps * step + around
+  end
+end

data/lib/rounding/core_ext/time.rb

@@ -0,0 +1,5 @@
+require 'rounding/time_extensions'
+
+class Time
+  include Rounding::TimeExtensions
+end

data/lib/rounding/time_extensions.rb

@@ -0,0 +1,34 @@
+module Rounding::TimeExtensions
+  def floor_to(step, around=-utc_offset)
+    around = around.to_r
+    rational_self = self.to_r
+    difference = rational_self - rational_self.floor_to(step, around)
+    self - difference
+  end
+
+  def ceil_to(step, around=-utc_offset)
+    around = around.to_r
+    rational_self = self.to_r
+    difference = rational_self - rational_self.ceil_to(step, around)
+    self - difference
+  end
+
+  def round_to(step, around=-utc_offset)
+    around = around.to_r
+    rational_self = self.to_r
+    difference = rational_self - rational_self.round_to(step, around)
+    self - difference
+  end
+
+  def floor_in_utc_to(step)
+    floor_to(step, 0)
+  end
+
+  def ceil_in_utc_to(step)
+    ceil_to(step, 0)
+  end
+
+  def round_in_utc_to(step)
+    round_to(step, 0)
+  end
+end

data/lib/rounding/version.rb

@@ -0,0 +1,3 @@
+module Rounding
+  VERSION = "1.0.0"
+end

data/rounding.gemspec

@@ -0,0 +1,25 @@
+# coding: utf-8
+lib = File.expand_path('../lib', __FILE__)
+$LOAD_PATH.unshift(lib) unless $LOAD_PATH.include?(lib)
+require 'rounding/version'
+
+Gem::Specification.new do |spec|
+  spec.name          = "rounding"
+  spec.version       = Rounding::VERSION
+  spec.authors       = ["Brian Hempel"]
+  spec.email         = ["plasticchicken@gmail.com"]
+  spec.summary       = %q{Floor/nearest/ceiling rounding by arbitrary steps for Integers, Floats, Times, TimeWithZones, and DateTimes.}
+  spec.description   = spec.summary
+  spec.homepage      = "https://github.com/brianhempel/rounding"
+  spec.license       = "Public Domain"
+
+  spec.files         = `git ls-files -z`.split("\x0")
+  # spec.executables   = spec.files.grep(%r{^bin/}) { |f| File.basename(f) }
+  spec.test_files    = spec.files.grep(%r{^(test|spec|features)/})
+  spec.require_paths = ["lib"]
+
+  spec.add_development_dependency "bundler", "~> 1.6"
+  spec.add_development_dependency "rake"
+  spec.add_development_dependency "rspec"
+  spec.add_development_dependency "activesupport"
+end

data/spec/rounding_spec.rb

@@ -0,0 +1,318 @@
+$LOAD_PATH.unshift File.expand_path("../../lib", __FILE__)
+require "rounding"
+require "date"
+require "active_support/time"
+
+TIME_ZONE = ActiveSupport::TimeZone["Bern"]
+AST       = ActiveSupport::TimeZone["Kuwait"] # something without DST
+
+ONE_DAY   = 60*60*24
+ONE_WEEK  = ONE_DAY * 7
+WEDNESDAY = Time.new(2014, 9, 3, 0, 0, 0, "-06:00")
+
+describe "Rounding" do
+
+  def self.it_rounds_correctly(method, input, step, expected)
+    it "should be #{expected.inspect} for #{input.class} #{input.inspect} step by #{step.inspect}" do
+      result = input.send(method, step)
+      expect(result).to eq(expected)
+    end
+
+    it "should be class #{expected.class.inspect} for #{input.inspect} step by #{step.inspect}" do
+      result = input.send(method, step)
+      expect(result.class).to eq(expected.class)
+    end
+
+    if input.respond_to?(:utc_offset)
+      it "should have utc_offset #{expected.utc_offset.inspect} for #{input.inspect} step by #{step.inspect}" do
+        result_utc_offset = input.send(method, step).utc_offset
+        expect(result_utc_offset).to eq(expected.utc_offset)
+      end
+    end
+
+    if input.respond_to?(:offset)
+      it "should have offset #{expected.offset.inspect} for #{input.inspect} step by #{step.inspect}" do
+        result_offset = input.send(method, step).offset
+        expect(result_offset).to eq(expected.offset)
+      end
+    end
+  end
+
+  describe "#floor_to" do
+    FLOOR_TO_EXPECTATIONS = {
+      [3,     2]   => 2,
+      [2,     2]   => 2,
+      [0,     2]   => 0,
+      [-1,    2]   => -2,
+      [-2,    2]   => -2,
+      [104,   5]   => 100,
+      [3.0,   2]   => 2,
+      [2.0,   2]   => 2,
+      [0.0,   2]   => 0,
+      [-1.0,  2]   => -2,
+      [-2.0,  2]   => -2,
+      [104.0, 5]   => 100,
+      [3,     2.5] => 2.5,
+      [-3,    2.5] => -5.0,
+      [105,   2.5] => 105.0,
+      [4.9,   2.5] => 2.5,
+      [Time.new(2014, 9, 5, 18,  8, 29, "-04:00"), 60]                        => Time.new(2014, 9, 5, 18, 8, 00, "-04:00"),
+      [Time.new(2014, 9, 5, 18,  8, 30, "-05:00"), 60]                        => Time.new(2014, 9, 5, 18, 8, 00, "-05:00"),
+      [Time.new(2014, 9, 5, 18,  8, 31, "-06:00"), 60]                        => Time.new(2014, 9, 5, 18, 8, 00, "-06:00"),
+      [Time.new(2014, 9, 5, 11, 59, 59, "-07:00"), ONE_DAY]                   => Time.new(2014, 9, 5,  0, 0, 00, "-07:00"),
+      [Time.new(2014, 9, 5, 12,  0, 00, "-08:00"), ONE_DAY]                   => Time.new(2014, 9, 5,  0, 0, 00, "-08:00"),
+      [Time.new(2014, 9, 5, 12,  0, 01, "-09:00"), ONE_DAY]                   => Time.new(2014, 9, 5,  0, 0, 00, "-09:00"),
+      [Time.new(2014, 9, 5, 12,  0, 00, "-08:00"), ONE_DAY*365]               => Time.new(2013, 12, 21,  0, 0, 00, "-08:00"),
+      [Time.at(1409955065, 284499), 1.to_r/1000]                              => Time.at(1409955065, 284000),
+      [Time.at(1409955065, 284500), 1.to_r/1000]                              => Time.at(1409955065, 284000),
+      [Time.at(1409955065, 284501), 1.to_r/1000]                              => Time.at(1409955065, 284000),
+      [TIME_ZONE.local(2014, 9, 5, 18, 8, 30), 60]                            => TIME_ZONE.local(2014, 9, 5, 18, 8, 00),
+      [DateTime.new(2014, 9, 5, 18,  8, 29, "-04:00"), 60.to_r/ONE_DAY]       => DateTime.new(2014, 9, 5, 18, 8, 00, "-04:00"),
+      [DateTime.new(2014, 9, 5, 18,  8, 30, "-05:00"), 60.to_r/ONE_DAY]       => DateTime.new(2014, 9, 5, 18, 8, 00, "-05:00"),
+      [DateTime.new(2014, 9, 5, 18,  8, 31, "-06:00"), 60.to_r/ONE_DAY]       => DateTime.new(2014, 9, 5, 18, 8, 00, "-06:00"),
+      [DateTime.new(2014, 9, 5, 11, 59, 59, "-07:00"), 1]                     => DateTime.new(2014, 9, 5,  0, 0, 00, "-07:00"),
+      [DateTime.new(2014, 9, 5, 12,  0, 00, "-08:00"), 1]                     => DateTime.new(2014, 9, 5,  0, 0, 00, "-08:00"),
+      [DateTime.new(2014, 9, 5, 12,  0, 01, "-09:00"), 1]                     => DateTime.new(2014, 9, 5,  0, 0, 00, "-09:00"),
+      [DateTime.new(2014, 9, 5, 11, 59, 59, "-07:00"), 1.day]                 => DateTime.new(2014, 9, 5,  0, 0, 00, "-07:00"),
+      [DateTime.new(2014, 9, 5, 12,  0, 00, "-08:00"), 1.day]                 => DateTime.new(2014, 9, 5,  0, 0, 00, "-08:00"),
+      [DateTime.new(2014, 9, 5, 12,  0, 01, "-09:00"), 1.day]                 => DateTime.new(2014, 9, 5,  0, 0, 00, "-09:00"),
+      [DateTime.new(2014, 9, 5, 12,  0, 00, "-08:00"), 365]                   => DateTime.new(2014, 6, 6,  0, 0, 00, "-08:00"), # rounds around Julian epoch: -4712-01-01 00:00:00
+      [DateTime.jd(106138433640660311.to_r/43200000000), 1.to_r/1000/ONE_DAY] => DateTime.jd(1768973894011.to_r/720000), # fractional seconds test
+    }
+
+    FLOOR_TO_EXPECTATIONS.each do |(input, step), expected|
+      it_rounds_correctly(:floor_to, input, step, expected)
+    end
+
+    it "allows an around offset to center the rounding" do
+      expect(4.floor_to(2.5, 1)).to eq(3.5)
+      expect(4.5.floor_to(2, 1)).to eq(3.0)
+    end
+
+    it "allows a time around offset to center the rounding" do
+      time = Time.new(2014, 9, 5, 12,  0, 00, "-06:00")
+      expect(time.floor_to(ONE_WEEK, WEDNESDAY)).to eq(Time.new(2014, 9, 3, 0, 0, 0, "-06:00"))
+    end
+  end
+
+  describe "#ceil_to" do
+    CEIL_TO_EXPECTATIONS = {
+      [3,     2]   => 4,
+      [2,     2]   => 2,
+      [0,     2]   => 0,
+      [-1,    2]   => 0,
+      [-2,    2]   => -2,
+      [104,   5]   => 105,
+      [3.0,   2]   => 4,
+      [2.0,   2]   => 2,
+      [0.0,   2]   => 0,
+      [-1.0,  2]   => 0,
+      [-2.0,  2]   => -2,
+      [104.0, 5]   => 105,
+      [3,     2.5] => 5.0,
+      [-3,    2.5] => -2.5,
+      [105,   2.5] => 105.0,
+      [4.9,   2.5] => 5.0,
+      [Time.new(2014, 9, 5, 18,  8, 29, "-04:00"), 60]                        => Time.new(2014, 9, 5, 18, 9, 00, "-04:00"),
+      [Time.new(2014, 9, 5, 18,  8, 30, "-05:00"), 60]                        => Time.new(2014, 9, 5, 18, 9, 00, "-05:00"),
+      [Time.new(2014, 9, 5, 18,  8, 31, "-06:00"), 60]                        => Time.new(2014, 9, 5, 18, 9, 00, "-06:00"),
+      [Time.new(2014, 9, 5, 11, 59, 59, "-07:00"), 60*60*24]                  => Time.new(2014, 9, 6,  0, 0, 00, "-07:00"),
+      [Time.new(2014, 9, 5, 12,  0, 00, "-08:00"), 60*60*24]                  => Time.new(2014, 9, 6,  0, 0, 00, "-08:00"),
+      [Time.new(2014, 9, 5, 12,  0, 01, "-09:00"), 60*60*24]                  => Time.new(2014, 9, 6,  0, 0, 00, "-09:00"),
+      [Time.new(2014, 9, 5, 12,  0, 00, "-08:00"), ONE_DAY*365]               => Time.new(2014, 12, 21,  0, 0, 00, "-08:00"),
+      [Time.at(1409955065, 284499), 1.to_r/1000]                              => Time.at(1409955065, 285000),
+      [Time.at(1409955065, 284500), 1.to_r/1000]                              => Time.at(1409955065, 285000),
+      [Time.at(1409955065, 284501), 1.to_r/1000]                              => Time.at(1409955065, 285000),
+      [TIME_ZONE.local(2014, 9, 5, 18, 8, 30), 60]                            => TIME_ZONE.local(2014, 9, 5, 18, 9, 00),
+      [DateTime.new(2014, 9, 5, 18,  8, 29, "-04:00"), 60.to_r/ONE_DAY]       => DateTime.new(2014, 9, 5, 18, 9, 00, "-04:00"),
+      [DateTime.new(2014, 9, 5, 18,  8, 30, "-05:00"), 60.to_r/ONE_DAY]       => DateTime.new(2014, 9, 5, 18, 9, 00, "-05:00"),
+      [DateTime.new(2014, 9, 5, 18,  8, 31, "-06:00"), 60.to_r/ONE_DAY]       => DateTime.new(2014, 9, 5, 18, 9, 00, "-06:00"),
+      [DateTime.new(2014, 9, 5, 11, 59, 59, "-07:00"), 1]                     => DateTime.new(2014, 9, 6,  0, 0, 00, "-07:00"),
+      [DateTime.new(2014, 9, 5, 12,  0, 00, "-08:00"), 1]                     => DateTime.new(2014, 9, 6,  0, 0, 00, "-08:00"),
+      [DateTime.new(2014, 9, 5, 12,  0, 01, "-09:00"), 1]                     => DateTime.new(2014, 9, 6,  0, 0, 00, "-09:00"),
+      [DateTime.new(2014, 9, 5, 11, 59, 59, "-07:00"), 1.day]                 => DateTime.new(2014, 9, 6,  0, 0, 00, "-07:00"),
+      [DateTime.new(2014, 9, 5, 12,  0, 00, "-08:00"), 1.day]                 => DateTime.new(2014, 9, 6,  0, 0, 00, "-08:00"),
+      [DateTime.new(2014, 9, 5, 12,  0, 01, "-09:00"), 1.day]                 => DateTime.new(2014, 9, 6,  0, 0, 00, "-09:00"),
+      [DateTime.new(2014, 9, 5, 12,  0, 00, "-08:00"), 365]                   => DateTime.new(2015, 6, 6,  0, 0, 00, "-08:00"), # rounds around Julian epoch: -4712-01-01 00:00:00
+      [DateTime.jd(106138433640660311.to_r/43200000000), 1.to_r/1000/ONE_DAY] => DateTime.jd(212276867281321.to_r/86400000), # fractional seconds test
+    }
+
+    CEIL_TO_EXPECTATIONS.each do |(input, step), expected|
+      it_rounds_correctly(:ceil_to, input, step, expected)
+    end
+
+    it "allows an around offset to center the rounding" do
+      expect(4.ceil_to(2.5, 1)).to eq(6.0)
+      expect(4.5.ceil_to(2, 1)).to eq(5.0)
+    end
+
+    it "allows a time around offset to center the rounding" do
+      time = Time.new(2014, 9, 5, 12,  0, 00, "-06:00")
+      expect(time.ceil_to(ONE_WEEK, WEDNESDAY)).to eq(Time.new(2014, 9, 10, 0, 0, 0, "-06:00"))
+    end
+  end
+
+  describe "#round_to" do
+    TO_NEAREST_EXPECTATIONS = {
+      [3,     2]   => 4,
+      [2,     2]   => 2,
+      [0,     2]   => 0,
+      [-1,    2]   => 0,
+      [-2,    2]   => -2,
+      [102,   5]   => 100,
+      [103,   5]   => 105,
+      [104,   5]   => 105,
+      [105,   5]   => 105,
+      [84,   10]   => 80,
+      [85,   10]   => 90,
+      [3.0,   2]   => 4,
+      [2.0,   2]   => 2,
+      [0.0,   2]   => 0,
+      [-1.0,  2]   => 0,
+      [-2.0,  2]   => -2,
+      [102.0, 5]   => 100,
+      [103.0, 5]   => 105,
+      [104.0, 5]   => 105,
+      [105.0, 5]   => 105,
+      [84.0, 10]   => 80,
+      [85.0, 10]   => 90,
+      [3,     2.5] => 2.5,
+      [-3,    2.5] => -2.5,
+      [1.24,  2.5] => 0.0,
+      [1.25,  2.5] => 2.5,
+      [103,   2.5] => 102.5,
+      [104,   2.5] => 105.0,
+      [105,   2.5] => 105.0,
+      [4.9,   2.5] => 5.0,
+      [Time.new(2014, 9, 5, 18,  8, 29, "-04:00"), 60]                        => Time.new(2014, 9, 5, 18, 8, 00, "-04:00"),
+      [Time.new(2014, 9, 5, 18,  8, 30, "-05:00"), 60]                        => Time.new(2014, 9, 5, 18, 9, 00, "-05:00"),
+      [Time.new(2014, 9, 5, 18,  8, 31, "-06:00"), 60]                        => Time.new(2014, 9, 5, 18, 9, 00, "-06:00"),
+      [Time.new(2014, 9, 5, 11, 59, 59, "-07:00"), 60*60*24]                  => Time.new(2014, 9, 5,  0, 0, 00, "-07:00"),
+      [Time.new(2014, 9, 5, 12,  0, 00, "-08:00"), 60*60*24]                  => Time.new(2014, 9, 6,  0, 0, 00, "-08:00"),
+      [Time.new(2014, 9, 5, 12,  0, 01, "-09:00"), 60*60*24]                  => Time.new(2014, 9, 6,  0, 0, 00, "-09:00"),
+      [Time.new(2014, 9, 5, 12,  0, 00, "-08:00"), ONE_DAY*365]               => Time.new(2014, 12, 21,  0, 0, 00, "-08:00"),
+      [Time.at(1409955065, 284499), 1.to_r/1000]                              => Time.at(1409955065, 284000),
+      [Time.at(1409955065, 284500), 1.to_r/1000]                              => Time.at(1409955065, 285000),
+      [Time.at(1409955065, 284501), 1.to_r/1000]                              => Time.at(1409955065, 285000),
+      [TIME_ZONE.local(2014, 9, 5, 18, 8, 30), 60]                            => TIME_ZONE.local(2014, 9, 5, 18, 9, 00),
+      [DateTime.new(2014, 9, 5, 18,  8, 29, "-04:00"), 60.to_r/ONE_DAY]       => DateTime.new(2014, 9, 5, 18, 8, 00, "-04:00"),
+      [DateTime.new(2014, 9, 5, 18,  8, 30, "-05:00"), 60.to_r/ONE_DAY]       => DateTime.new(2014, 9, 5, 18, 9, 00, "-05:00"),
+      [DateTime.new(2014, 9, 5, 18,  8, 31, "-06:00"), 60.to_r/ONE_DAY]       => DateTime.new(2014, 9, 5, 18, 9, 00, "-06:00"),
+      [DateTime.new(2014, 9, 5, 11, 59, 59, "-07:00"), 1]                     => DateTime.new(2014, 9, 5,  0, 0, 00, "-07:00"),
+      [DateTime.new(2014, 9, 5, 12,  0, 00, "-08:00"), 1]                     => DateTime.new(2014, 9, 6,  0, 0, 00, "-08:00"),
+      [DateTime.new(2014, 9, 5, 12,  0, 01, "-09:00"), 1]                     => DateTime.new(2014, 9, 6,  0, 0, 00, "-09:00"),
+      [DateTime.new(2014, 9, 5, 11, 59, 59, "-07:00"), 1.day]                 => DateTime.new(2014, 9, 5,  0, 0, 00, "-07:00"),
+      [DateTime.new(2014, 9, 5, 12,  0, 00, "-08:00"), 1.day]                 => DateTime.new(2014, 9, 6,  0, 0, 00, "-08:00"),
+      [DateTime.new(2014, 9, 5, 12,  0, 01, "-09:00"), 1.day]                 => DateTime.new(2014, 9, 6,  0, 0, 00, "-09:00"),
+      [DateTime.new(2014, 9, 5, 12,  0, 00, "-08:00"), 365]                   => DateTime.new(2014, 6, 6,  0, 0, 00, "-08:00"), # rounds around Julian epoch: -4712-01-01 00:00:00
+      [DateTime.jd(106138433640660311.to_r/43200000000), 1.to_r/1000/ONE_DAY] => DateTime.jd(212276867281321.to_r/86400000), # fractional seconds test
+    }
+
+    TO_NEAREST_EXPECTATIONS.each do |(input, step), expected|
+      it_rounds_correctly(:round_to, input, step, expected)
+    end
+
+    it "allows an around offset to center the rounding" do
+      expect(4.round_to(2.5, 1)).to eq(3.5)
+      expect(4.5.round_to(2, 1)).to eq(5.0)
+    end
+
+    it "allows a time around offset to center the rounding" do
+      time = Time.new(2014, 9, 5, 12,  0, 00, "-06:00")
+      expect(time.round_to(ONE_WEEK, WEDNESDAY)).to eq(Time.new(2014, 9, 3, 0, 0, 0, "-06:00"))
+    end
+  end
+
+  describe "#floor_in_utc_to" do
+    FLOOR_IN_UTC_TO_EXPECTATIONS = {
+      [Time.new(2014, 9, 5, 18,  8, 29, "-04:00"), 60]                        => Time.new(2014, 9, 5, 18, 8, 00, "-04:00"),
+      [Time.new(2014, 9, 5, 18,  8, 30, "-05:00"), 60]                        => Time.new(2014, 9, 5, 18, 8, 00, "-05:00"),
+      [Time.new(2014, 9, 5, 18,  8, 31, "-06:00"), 60]                        => Time.new(2014, 9, 5, 18, 8, 00, "-06:00"),
+      [Time.new(2014, 9, 5,  4, 59, 59, "-07:00"), 60*60*24]                  => Time.new(2014, 9, 4, 17, 0, 00, "-07:00"),
+      [Time.new(2014, 9, 5,  4,  0, 00, "-08:00"), 60*60*24]                  => Time.new(2014, 9, 4, 16, 0, 00, "-08:00"),
+      [Time.new(2014, 9, 5,  3,  0, 01, "-09:00"), 60*60*24]                  => Time.new(2014, 9, 4, 15, 0, 00, "-09:00"),
+      [Time.at(1409955065, 284499), 1.to_r/1000]                              => Time.at(1409955065, 284000),
+      [Time.at(1409955065, 284500), 1.to_r/1000]                              => Time.at(1409955065, 284000),
+      [Time.at(1409955065, 284501), 1.to_r/1000]                              => Time.at(1409955065, 284000),
+      [Time.new(2014, 9, 5, 12,  0, 00, "-08:00"), ONE_DAY*365]               => Time.new(2013, 12, 20,  16, 0, 00, "-08:00"),
+      [AST.local(2014, 9, 5, 18, 8, 30), 60*60*24]                            => AST.local(2014, 9, 5, 3, 0, 00),
+      [DateTime.new(2014, 9, 5, 18,  8, 29, "-04:00"), 60.to_r/ONE_DAY]       => DateTime.new(2014, 9, 5, 18, 8, 00, "-04:00"),
+      [DateTime.new(2014, 9, 5, 18,  8, 30, "-05:00"), 60.to_r/ONE_DAY]       => DateTime.new(2014, 9, 5, 18, 8, 00, "-05:00"),
+      [DateTime.new(2014, 9, 5, 18,  8, 31, "-06:00"), 60.to_r/ONE_DAY]       => DateTime.new(2014, 9, 5, 18, 8, 00, "-06:00"),
+      [DateTime.new(2014, 9, 5, 11, 59, 59, "-07:00"), 1]                     => DateTime.new(2014, 9, 4, 17, 0, 00, "-07:00"),
+      [DateTime.new(2014, 9, 5, 12,  0, 00, "-08:00"), 1]                     => DateTime.new(2014, 9, 4, 16, 0, 00, "-08:00"),
+      [DateTime.new(2014, 9, 5, 12,  0, 01, "-09:00"), 1]                     => DateTime.new(2014, 9, 4, 15, 0, 00, "-09:00"),
+      [DateTime.new(2014, 9, 5, 11, 59, 59, "-07:00"), 1.day]                 => DateTime.new(2014, 9, 4, 17, 0, 00, "-07:00"),
+      [DateTime.new(2014, 9, 5, 12,  0, 00, "-08:00"), 1.day]                 => DateTime.new(2014, 9, 4, 16, 0, 00, "-08:00"),
+      [DateTime.new(2014, 9, 5, 12,  0, 01, "-09:00"), 1.day]                 => DateTime.new(2014, 9, 4, 15, 0, 00, "-09:00"),
+      [DateTime.new(2014, 9, 5, 12,  0, 00, "-08:00"), 365]                   => DateTime.new(2013, 12, 20,  16, 0, 00, "-08:00"), # rounds around UTC epoch: 1970-01-01 00:00:00
+      [DateTime.jd(106138433640660311.to_r/43200000000), 1.to_r/1000/ONE_DAY] => DateTime.jd(1768973894011.to_r/720000), # fractional seconds test
+    }
+
+    FLOOR_IN_UTC_TO_EXPECTATIONS.each do |(input, step), expected|
+      it_rounds_correctly(:floor_in_utc_to, input, step, expected)
+    end
+  end
+
+  describe "#ceil_in_utc_to" do
+    CEIL_IN_UTC_TO_EXPECTATIONS = {
+      [Time.new(2014, 9, 5, 18,  8, 29, "-04:00"), 60]                        => Time.new(2014, 9, 5, 18, 9, 00, "-04:00"),
+      [Time.new(2014, 9, 5, 18,  8, 30, "-05:00"), 60]                        => Time.new(2014, 9, 5, 18, 9, 00, "-05:00"),
+      [Time.new(2014, 9, 5, 18,  8, 31, "-06:00"), 60]                        => Time.new(2014, 9, 5, 18, 9, 00, "-06:00"),
+      [Time.new(2014, 9, 5,  4, 59, 59, "-07:00"), 60*60*24]                  => Time.new(2014, 9, 5, 17, 0, 00, "-07:00"),
+      [Time.new(2014, 9, 5,  4,  0, 00, "-08:00"), 60*60*24]                  => Time.new(2014, 9, 5, 16, 0, 00, "-08:00"),
+      [Time.new(2014, 9, 5,  3,  0, 01, "-09:00"), 60*60*24]                  => Time.new(2014, 9, 5, 15, 0, 00, "-09:00"),
+      [Time.new(2014, 9, 5, 12,  0, 00, "-08:00"), ONE_DAY*365]               => Time.new(2014, 12, 20,  16, 0, 00, "-08:00"),
+      [Time.at(1409955065, 284499), 1.to_r/1000]                              => Time.at(1409955065, 285000),
+      [Time.at(1409955065, 284500), 1.to_r/1000]                              => Time.at(1409955065, 285000),
+      [Time.at(1409955065, 284501), 1.to_r/1000]                              => Time.at(1409955065, 285000),
+      [AST.local(2014, 9, 5, 18, 8, 30), 60*60*24]                            => AST.local(2014, 9, 6, 3, 0, 00),
+      [DateTime.new(2014, 9, 5, 18,  8, 29, "-04:00"), 60.to_r/ONE_DAY]       => DateTime.new(2014, 9, 5, 18, 9, 00, "-04:00"),
+      [DateTime.new(2014, 9, 5, 18,  8, 30, "-05:00"), 60.to_r/ONE_DAY]       => DateTime.new(2014, 9, 5, 18, 9, 00, "-05:00"),
+      [DateTime.new(2014, 9, 5, 18,  8, 31, "-06:00"), 60.to_r/ONE_DAY]       => DateTime.new(2014, 9, 5, 18, 9, 00, "-06:00"),
+      [DateTime.new(2014, 9, 5, 11, 59, 59, "-07:00"), 1]                     => DateTime.new(2014, 9, 5, 17, 0, 00, "-07:00"),
+      [DateTime.new(2014, 9, 5, 12,  0, 00, "-08:00"), 1]                     => DateTime.new(2014, 9, 5, 16, 0, 00, "-08:00"),
+      [DateTime.new(2014, 9, 5, 12,  0, 01, "-09:00"), 1]                     => DateTime.new(2014, 9, 5, 15, 0, 00, "-09:00"),
+      [DateTime.new(2014, 9, 5, 11, 59, 59, "-07:00"), 1.day]                 => DateTime.new(2014, 9, 5, 17, 0, 00, "-07:00"),
+      [DateTime.new(2014, 9, 5, 12,  0, 00, "-08:00"), 1.day]                 => DateTime.new(2014, 9, 5, 16, 0, 00, "-08:00"),
+      [DateTime.new(2014, 9, 5, 12,  0, 01, "-09:00"), 1.day]                 => DateTime.new(2014, 9, 5, 15, 0, 00, "-09:00"),
+      [DateTime.new(2014, 9, 5, 12,  0, 00, "-08:00"), 365]                   => DateTime.new(2014, 12, 20,  16, 0, 00, "-08:00"), # rounds around UTC epoch: 1970-01-01 00:00:00
+      [DateTime.jd(106138433640660311.to_r/43200000000), 1.to_r/1000/ONE_DAY] => DateTime.jd(212276867281321.to_r/86400000), # fractional seconds test
+    }
+
+    CEIL_IN_UTC_TO_EXPECTATIONS.each do |(input, step), expected|
+      it_rounds_correctly(:ceil_in_utc_to, input, step, expected)
+    end
+  end
+
+  describe "#round_in_utc_to" do
+    TO_NEAREST_IN_UTC_EXPECTATIONS = {
+      [Time.new(2014, 9, 5, 18,  8, 29, "-04:00"), 60]                        => Time.new(2014, 9, 5, 18, 8, 00, "-04:00"),
+      [Time.new(2014, 9, 5, 18,  8, 30, "-05:00"), 60]                        => Time.new(2014, 9, 5, 18, 9, 00, "-05:00"),
+      [Time.new(2014, 9, 5, 18,  8, 31, "-06:00"), 60]                        => Time.new(2014, 9, 5, 18, 9, 00, "-06:00"),
+      [Time.new(2014, 9, 5,  4, 59, 59, "-07:00"), 60*60*24]                  => Time.new(2014, 9, 4, 17, 0, 00, "-07:00"),
+      [Time.new(2014, 9, 5,  4,  0, 00, "-08:00"), 60*60*24]                  => Time.new(2014, 9, 5, 16, 0, 00, "-08:00"),
+      [Time.new(2014, 9, 5,  3,  0, 01, "-09:00"), 60*60*24]                  => Time.new(2014, 9, 5, 15, 0, 00, "-09:00"),
+      [Time.new(2014, 9, 5, 12,  0, 00, "-08:00"), ONE_DAY*365]               => Time.new(2014, 12, 20,  16, 0, 00, "-08:00"),
+      [Time.at(1409955065, 284499), 1.to_r/1000]                              => Time.at(1409955065, 284000),
+      [Time.at(1409955065, 284500), 1.to_r/1000]                              => Time.at(1409955065, 285000),
+      [Time.at(1409955065, 284501), 1.to_r/1000]                              => Time.at(1409955065, 285000),
+      [AST.local(2014, 9, 5, 18, 8, 30), 60*60*24]                            => AST.local(2014, 9, 6, 3, 0, 00),
+      [DateTime.new(2014, 9, 5, 18,  8, 29, "-04:00"), 60.to_r/ONE_DAY]       => DateTime.new(2014, 9, 5, 18, 8, 00, "-04:00"),
+      [DateTime.new(2014, 9, 5, 18,  8, 30, "-05:00"), 60.to_r/ONE_DAY]       => DateTime.new(2014, 9, 5, 18, 9, 00, "-05:00"),
+      [DateTime.new(2014, 9, 5, 18,  8, 31, "-06:00"), 60.to_r/ONE_DAY]       => DateTime.new(2014, 9, 5, 18, 9, 00, "-06:00"),
+      [DateTime.new(2014, 9, 5, 11, 59, 59, "-07:00"), 1]                     => DateTime.new(2014, 9, 5, 17, 0, 00, "-07:00"),
+      [DateTime.new(2014, 9, 5, 12,  0, 00, "-08:00"), 1]                     => DateTime.new(2014, 9, 5, 16, 0, 00, "-08:00"),
+      [DateTime.new(2014, 9, 5, 12,  0, 01, "-09:00"), 1]                     => DateTime.new(2014, 9, 5, 15, 0, 00, "-09:00"),
+      [DateTime.new(2014, 9, 5, 11, 59, 59, "-07:00"), 1.day]                 => DateTime.new(2014, 9, 5, 17, 0, 00, "-07:00"),
+      [DateTime.new(2014, 9, 5, 12,  0, 00, "-08:00"), 1.day]                 => DateTime.new(2014, 9, 5, 16, 0, 00, "-08:00"),
+      [DateTime.new(2014, 9, 5, 12,  0, 01, "-09:00"), 1.day]                 => DateTime.new(2014, 9, 5, 15, 0, 00, "-09:00"),
+      [DateTime.new(2014, 9, 5, 12,  0, 00, "-08:00"), 365]                   => DateTime.new(2014, 12, 20,  16, 0, 00, "-08:00"), # rounds around UTC epoch: 1970-01-01 00:00:00
+      [DateTime.jd(106138433640660311.to_r/43200000000), 1.to_r/1000/ONE_DAY] => DateTime.jd(212276867281321.to_r/86400000), # fractional seconds test
+    }
+
+    TO_NEAREST_IN_UTC_EXPECTATIONS.each do |(input, step), expected|
+      it_rounds_correctly(:round_in_utc_to, input, step, expected)
+    end
+  end
+end

metadata

@@ -0,0 +1,119 @@
+--- !ruby/object:Gem::Specification
+name: rounding
+version: !ruby/object:Gem::Version
+  version: 1.0.0
+platform: ruby
+authors:
+- Brian Hempel
+autorequire: 
+bindir: bin
+cert_chain: []
+date: 2014-09-09 00:00:00.000000000 Z
+dependencies:
+- !ruby/object:Gem::Dependency
+  name: bundler
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: '1.6'
+  type: :development
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: '1.6'
+- !ruby/object:Gem::Dependency
+  name: rake
+  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'
+- !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'
+- !ruby/object:Gem::Dependency
+  name: activesupport
+  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: Floor/nearest/ceiling rounding by arbitrary steps for Integers, Floats,
+  Times, TimeWithZones, and DateTimes.
+email:
+- plasticchicken@gmail.com
+executables: []
+extensions: []
+extra_rdoc_files: []
+files:
+- ".gitignore"
+- ".travis.yml"
+- Gemfile
+- LICENSE.txt
+- README.md
+- Rakefile
+- bin/console
+- lib/rounding.rb
+- lib/rounding/active_support_ext/time_with_zone.rb
+- lib/rounding/core_ext/date_time.rb
+- lib/rounding/core_ext/numeric.rb
+- lib/rounding/core_ext/time.rb
+- lib/rounding/time_extensions.rb
+- lib/rounding/version.rb
+- rounding.gemspec
+- spec/rounding_spec.rb
+homepage: https://github.com/brianhempel/rounding
+licenses:
+- Public Domain
+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.2.2
+signing_key: 
+specification_version: 4
+summary: Floor/nearest/ceiling rounding by arbitrary steps for Integers, Floats, Times,
+  TimeWithZones, and DateTimes.
+test_files:
+- spec/rounding_spec.rb