active_date_range 0.1.0

data/Guardfile

@@ -0,0 +1,46 @@
+# A sample Guardfile
+# More info at https://github.com/guard/guard#readme
+
+## Uncomment and set this to only include directories you want to watch
+# directories %w(app lib config test spec features) \
+#  .select{|d| Dir.exist?(d) ? d : UI.warning("Directory #{d} does not exist")}
+
+## Note: if you are using the `directories` clause above and you are not
+## watching the project directory ('.'), then you will want to move
+## the Guardfile to a watched dir and symlink it back, e.g.
+#
+#  $ mkdir config
+#  $ mv Guardfile config/
+#  $ ln -s config/Guardfile .
+#
+# and, you'll have to watch "config/Guardfile" instead of "Guardfile"
+
+clearing :on
+
+guard :minitest do
+  # with Minitest::Unit
+  watch(%r{^test/(.*)\/?test_(.*)\.rb$})
+  watch(%r{^test/(.*)\/?(.*)_test\.rb$})
+  watch(%r{^lib/(.*/)?([^/]+)\.rb$})     { |m| "test/#{m[1]}test_#{m[2]}.rb" }
+  watch(%r{^lib/(.*/)?([^/]+)\.rb$})     { |m| "test/#{m[1]}#{m[2]}_test.rb" }
+  watch(%r{^test/test_helper\.rb$})      { 'test' }
+
+  # with Minitest::Spec
+  # watch(%r{^spec/(.*)_spec\.rb$})
+  # watch(%r{^lib/(.+)\.rb$})         { |m| "spec/#{m[1]}_spec.rb" }
+  # watch(%r{^spec/spec_helper\.rb$}) { 'spec' }
+
+  # Rails 4
+  # watch(%r{^app/(.+)\.rb$})                               { |m| "test/#{m[1]}_test.rb" }
+  # watch(%r{^app/controllers/application_controller\.rb$}) { 'test/controllers' }
+  # watch(%r{^app/controllers/(.+)_controller\.rb$})        { |m| "test/integration/#{m[1]}_test.rb" }
+  # watch(%r{^app/views/(.+)_mailer/.+})                    { |m| "test/mailers/#{m[1]}_mailer_test.rb" }
+  # watch(%r{^lib/(.+)\.rb$})                               { |m| "test/lib/#{m[1]}_test.rb" }
+  # watch(%r{^test/.+_test\.rb$})
+  # watch(%r{^test/test_helper\.rb$}) { 'test' }
+
+  # Rails < 4
+  # watch(%r{^app/controllers/(.*)\.rb$}) { |m| "test/functional/#{m[1]}_test.rb" }
+  # watch(%r{^app/helpers/(.*)\.rb$})     { |m| "test/helpers/#{m[1]}_test.rb" }
+  # watch(%r{^app/models/(.*)\.rb$})      { |m| "test/unit/#{m[1]}_test.rb" }
+end

data/LICENSE

@@ -0,0 +1,21 @@
+MIT License
+
+Copyright (c) 2021 Moneybird
+
+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,138 @@
+# Active Date Range
+
+`ActiveDateRange` provides a range of dates with a powerful API to manipulate and use date ranges in your software. Date ranges are commonly used in reporting tools, but can be of use in many situation where you need for example filtering or reporting.
+
+## Installation
+
+Add this line to your application's Gemfile:
+
+```ruby
+gem 'active_date_range'
+```
+
+And then execute:
+
+    $ bundle install
+
+Or install it yourself as:
+
+    $ gem install active_date_range
+
+## Usage
+
+### Initialize a new date range
+
+Initialize a new range:
+
+```ruby
+ActiveDateRange::DateRange.new(Date.new(2021, 1, 1), Date.new(2021, 12, 31))
+ActiveDateRange::DateRange.new(Date.new(2021, 1, 1)..Date.new(2021, 12, 31))
+```
+
+You can also use shorthands to initialize a range relative to today. Shorthands are available for `this`, `prev` and `next` for the ranges `month`, `quarter` and `year`:
+
+```ruby
+ActiveDateRange::DateRange.this_month
+ActiveDateRange::DateRange.this_year
+ActiveDateRange::DateRange.this_quarter
+ActiveDateRange::DateRange.prev_month
+ActiveDateRange::DateRange.prev_year
+ActiveDateRange::DateRange.prev_quarter
+ActiveDateRange::DateRange.next_month
+ActiveDateRange::DateRange.next_year
+ActiveDateRange::DateRange.next_quarter
+```
+
+The third option is to use parse:
+
+```ruby
+ActiveDateRange::DateRange.parse('202101..202112')
+ActiveDateRange::DateRange.parse('20210101..20210115')
+```
+
+Parse accepts three formats: `YYYYMM..YYYYMM`, `YYYYMMDD..YYYYMMDD` and any short hand like `this_month`.
+
+### The date range instance
+
+A `DateRange` object is an extension of a regular `Range` object. You can use [all methods available on `Range`](https://ruby-doc.org/core-3.0.0/Range.html):
+
+```ruby
+date_range = ActiveDateRange::DateRange.parse('202101..202112')
+date_range.begin                            # => Date.new(2021, 1, 1)
+date_range.end                              # => Date.new(2021, 12, 31)
+date_range.cover?(Date.new(2021, 2, 1))     # => true
+```
+
+`DateRange` adds extra methods to work with date ranges:
+
+```ruby
+date_range.days                             # => 365
+date_range.months                           # => 12
+date_range.quarters                         # => 4
+date_range.years                            # => 1
+date_range.one_month?                       # => false
+date_range.one_year?                        # => true
+date_range.full_year?                       # => true
+date_range.same_year?                       # => true
+date_range.before?(Date.new(2022, 1, 1))    # => true
+date_range.after?(ActiveDateRange::DateRange.parse('202001..202012')) # => true
+date_range.granularity                      # => :year
+date_range.to_param                         # => "202101..202112"
+date_range.to_param(relative: true)         # => "this_year"
+```
+
+You can also do calculations with the ranges:
+
+```ruby
+date_range.previous                             # => DateRange.parse('202001..202012')
+date_range.previous(2)                          # => DateRange.parse('201901..202012')
+date_range.next                                 # => DateRange.parse('202201..202212')
+date_range + DateRange.parse('202201..202202')  # => DateRange.parse('202101..202202')
+date_range.in_groups_of(:month)                 # => [DateRange.parse('202101..202101'), ..., DateRange.parse('202112..202112')]
+```
+
+And lastly you can call `.humanize` to get a localizable human representation of the range for in the user interface:
+
+```ruby
+date_range.humanize                      # => '2021'
+date_range.humanize(format: :explicit)   # => 'January 1st, 2021 - December 31st 2021'
+```
+
+See [active_date_range/locale/en.yml](https://github.com/moneybird/active-date-range/blob/main/lib/active_date_range/locale/en.yml) for all the I18n keys you need to translate for your application.
+
+### Usage example
+
+Use the shorthands to link to a specific period:
+
+```ruby
+<%= link_to "Show report for #{DateRange.this_year.humanize}", report_url(period: DateRange.this_year.to_param(relative: true)) %>
+```
+
+Because we use `to_params(relative: true)`, the user gets a bookmarkable URL which always points to the current year. If you need the URL to be bookmarkable and always point to the same period, remove `relative: true`.
+
+In your controller, use the parameter in your queries:
+
+```ruby
+def report
+  @period = DateRange.parse(params[:period])
+  @data = SomeModel.where(date: @period)
+end
+```
+
+In the report view, use the period object to render previous and next links:
+
+```ruby
+<%= link_to "Next period", report_url(period: @period.next) %>
+<%= link_to "Previous period", report_url(period: @period.previous) %>
+```
+
+## 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 tags, 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/moneybird/active-date-range.
+

data/Rakefile

@@ -0,0 +1,10 @@
+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
+
+task :default => :test

data/active_date_range.gemspec

@@ -0,0 +1,34 @@
+require_relative 'lib/active_date_range/version'
+
+Gem::Specification.new do |spec|
+  spec.name          = "active_date_range"
+  spec.version       = ActiveDateRange::VERSION
+  spec.authors       = ["Edwin Vlieg"]
+  spec.email         = ["edwin@moneybird.com"]
+
+  spec.summary       = "DateRange for ActiveSupport"
+  spec.description   = "ActiveDateRange provides a range of dates with a powerful API to manipulate and use date ranges in your software."
+  spec.homepage      = "https://github.com/moneybird/active-date-range"
+  spec.required_ruby_version = Gem::Requirement.new(">= 2.3.0")
+
+  spec.metadata["homepage_uri"] = spec.homepage
+  spec.metadata["source_code_uri"] = "https://github.com/moneybird/active-date-range"
+  spec.metadata["changelog_uri"] = "https://github.com/moneybird/active-date-range/CHANGELOG.md"
+
+  # Specify which files should be added to the gem when it is released.
+  # The `git ls-files -z` loads the files in the RubyGem that have been added into git.
+  spec.files         = Dir.chdir(File.expand_path('..', __FILE__)) do
+    `git ls-files -z`.split("\x0").reject { |f| f.match(%r{^(test|spec|features)/}) }
+  end
+  spec.bindir        = "exe"
+  spec.executables   = spec.files.grep(%r{^exe/}) { |f| File.basename(f) }
+  spec.require_paths = ["lib"]
+
+  spec.add_dependency "activesupport", "~> 6.1"
+  spec.add_dependency "i18n"
+
+  spec.add_development_dependency "rubocop"
+  spec.add_development_dependency "rubocop-packaging"
+  spec.add_development_dependency "rubocop-performance"
+  spec.add_development_dependency "rubocop-rails"
+end

data/bin/console

@@ -0,0 +1,17 @@
+#!/usr/bin/env ruby
+
+require "bundler/setup"
+require "active_support"
+require "active_date_range"
+
+Time.zone = "UTC"
+
+# 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,6 @@
+#!/usr/bin/env bash
+set -euo pipefail
+IFS=$'\n\t'
+set -vx
+
+bundle install

data/lib/active_date_range.rb

@@ -0,0 +1,21 @@
+# frozen_string_literal: true
+
+# require "active_support"
+require "active_support/core_ext/array"
+require "active_support/core_ext/time"
+require "active_support/core_ext/date"
+require "active_support/core_ext/integer"
+require "active_date_range/core_ext/integer"
+require "active_date_range/core_ext/date"
+
+require "active_date_range/version"
+require "active_date_range/date_range"
+require "active_date_range/humanizer"
+
+module ActiveDateRange
+  class Error < StandardError; end
+  class InvalidDateRange < Error; end
+  class InvalidAddition < Error; end
+  class InvalidDateRangeFormat < Error; end
+  class UnknownGranularity < Error; end
+end

data/lib/active_date_range/core_ext/date.rb

@@ -0,0 +1,10 @@
+# frozen_string_literal: true
+
+class Date
+  # Returns the number of the quarter for this date
+  #
+  #   Date.new(2021, 1, 1).quarter # => 1
+  def quarter
+    (month / 3.0).ceil
+  end
+end

data/lib/active_date_range/core_ext/integer.rb

@@ -0,0 +1,12 @@
+# frozen_string_literal: true
+
+class Integer
+  # Returns Duration instance matching the number of quarters provided
+  #
+  #   2.quarters # => 6 months
+  def quarters
+    self * 3.months
+  end
+
+  alias quarter quarters
+end

data/lib/active_date_range/date_range.rb

@@ -0,0 +1,293 @@
+# frozen_string_literal: true
+
+module ActiveDateRange
+  # Provides a <tt>DateRange</tt> with parsing, calculations and query methods
+  class DateRange < Range
+    SHORTHANDS = {
+      this_month: -> { DateRange.new(Time.zone.today.all_month) },
+      prev_month: -> { DateRange.new(1.month.ago.to_date.all_month) },
+      next_month: -> { DateRange.new(1.month.from_now.to_date.all_month) },
+      this_quarter: -> { DateRange.new(Time.zone.today.all_quarter) },
+      prev_quarter: -> { DateRange.new(3.months.ago.to_date.all_quarter) },
+      next_quarter: -> { DateRange.new(3.months.from_now.to_date.all_quarter) },
+      this_year: -> { DateRange.new(Time.zone.today.all_year) },
+      prev_year: -> { DateRange.new(12.months.ago.to_date.all_year) },
+      next_year: -> { DateRange.new(12.months.from_now.to_date.all_year) }
+    }.freeze
+
+    RANGE_PART_REGEXP = %r{\A(?<year>((1\d|2\d)\d\d))-?(?<month>0[1-9]|1[012])-?(?<day>[0-2]\d|3[01])?\z}
+
+    class << self
+      SHORTHANDS.each do |method, range|
+        define_method(method, range)
+      end
+    end
+
+    # Parses a date range string to a <tt>DateRange</tt> instance. Valid formats are:
+    # - A relative shorthand: <tt>this_month</tt>, <tt>prev_month</tt>, <tt>next_month</tt>, etc.
+    # - A begin and end date: <tt>YYYYMMDD..YYYYMMDD</tt>
+    # - A begin and end month: <tt>YYYYMM..YYYYMM</tt>
+    def self.parse(input)
+      return DateRange.new(input) if input.kind_of?(Range)
+      return SHORTHANDS[input.to_sym].call if SHORTHANDS.key?(input.to_sym)
+
+      begin_date, end_date = input.split("..")
+      raise InvalidDateRangeFormat, "#{input} doesn't have a begin..end format" unless begin_date && end_date
+
+      DateRange.new(parse_date(begin_date), parse_date(end_date, last: true))
+    end
+
+    def self.parse_date(input, last: false)
+      match_data = input.match(RANGE_PART_REGEXP)
+      raise InvalidDateRangeFormat, "#{input} isn't a valid date format YYYYMMDD or YYYYMM" unless match_data
+
+      date = Date.new(
+        match_data[:year].to_i,
+        match_data[:month].to_i,
+        match_data[:day]&.to_i || 1
+      )
+      return date.at_end_of_month if match_data[:day].nil? && last
+
+      date
+    rescue Date::Error
+      raise InvalidDateRangeFormat
+    end
+
+    private_class_method :parse_date
+
+    # Initializes a new DateRange. Accepts both a begin and end date or a range of dates.
+    # Make sures the begin date is before the end date.
+    def initialize(begin_date, end_date = nil)
+      begin_date, end_date = begin_date.begin, begin_date.end if begin_date.kind_of?(Range)
+      begin_date = begin_date.to_date if begin_date.kind_of?(Time)
+      end_date = end_date.to_date if end_date.kind_of?(Time)
+
+      raise InvalidDateRange, "Date range invalid, begin should be a date" unless begin_date.kind_of?(Date)
+      raise InvalidDateRange, "Date range invalid, end should be a date" unless end_date.kind_of?(Date)
+      raise InvalidDateRange, "Date range invalid, begin #{begin_date} is after end #{end_date}" if begin_date > end_date
+
+      super(begin_date, end_date)
+    end
+
+    # Adds two date ranges together. Fails when the ranges are not subsequent.
+    def +(other)
+      raise InvalidAddition if self.end != (other.begin - 1.day)
+
+      DateRange.new(self.begin, other.end)
+    end
+
+    # Sorts two date ranges by the begin date.
+    def <=>(other)
+      self.begin <=> other.begin
+    end
+
+    # Returns the number of days in the range
+    def days
+      @days ||= (self.end - self.begin).to_i + 1
+    end
+
+    # Returns the number of months in the range or nil when range is no full month
+    def months
+      return nil unless full_month?
+
+      ((self.end.year - self.begin.year) * 12) + (self.end.month - self.begin.month + 1)
+    end
+
+    # Returns the number of quarters in the range or nil when range is no full quarter
+    def quarters
+      return nil unless full_quarter?
+
+      months / 3
+    end
+
+    # Returns the number of years on the range or nil when range is no full year
+    def years
+      return nil unless full_year?
+
+      months / 12
+    end
+
+    # Returns true when begin of the range is at the beginning of the month
+    def begin_at_beginning_of_month?
+      self.begin.day == 1
+    end
+
+    # Returns true when begin of the range is at the beginning of the quarter
+    def begin_at_beginning_of_quarter?
+      begin_at_beginning_of_month? && [1, 4, 7, 10].include?(self.begin.month)
+    end
+
+    # Returns true when begin of the range is at the beginning of the year
+    def begin_at_beginning_of_year?
+      begin_at_beginning_of_month? && self.begin.month == 1
+    end
+
+    # Returns true when the range is exactly one month long
+    def one_month?
+      (28..31).cover?(days) &&
+        begin_at_beginning_of_month? &&
+        self.end == self.begin.at_end_of_month
+    end
+
+    # Returns true when the range is exactly one quarter long
+    def one_quarter?
+      (90..92).cover?(days) &&
+        begin_at_beginning_of_quarter? &&
+        self.end == self.begin.at_end_of_quarter
+    end
+
+    # Returns true when the range is exactly one year long
+    def one_year?
+      (365..366).cover?(days) &&
+        begin_at_beginning_of_year? &&
+        self.end == self.begin.at_end_of_year
+    end
+
+    # Returns true when the range is exactly one or more months long
+    def full_month?
+      begin_at_beginning_of_month? && self.end == self.end.at_end_of_month
+    end
+
+    alias :full_months? :full_month?
+
+    # Returns true when the range is exactly one or more quarters long
+    def full_quarter?
+      begin_at_beginning_of_quarter? && self.end == self.end.at_end_of_quarter
+    end
+
+    alias :full_quarters? :full_quarter?
+
+    # Returns true when the range is exactly one or more years long
+    def full_year?
+      begin_at_beginning_of_year? && self.end == self.end.at_end_of_year
+    end
+
+    alias :full_years? :full_year?
+
+    # Returns true when begin and end are in the same year
+    def same_year?
+      self.begin.year == self.end.year
+    end
+
+    # Returns true when the date range is before the given date. Accepts both a <tt>Date</tt>
+    # and <tt>DateRange</tt> as input.
+    def before?(date)
+      date = date.begin if date.kind_of?(DateRange)
+      self.end.before?(date)
+    end
+
+    # Returns true when the date range is after the given date. Accepts both a <tt>Date</tt>
+    # and <tt>DateRange</tt> as input.
+    def after?(date)
+      date = date.end if date.kind_of?(DateRange)
+      self.begin.after?(date)
+    end
+
+    # Returns the granularity of the range. Returns either <tt>:year</tt>, <tt>:quarter</tt> or
+    # <tt>:month</tt> based on if the range has exactly this length.
+    #
+    #   DateRange.this_month.granularity    # => :month
+    #   DateRange.this_quarter.granularity  # => :quarter
+    #   DateRange.this_year.granularity     # => :year
+    def granularity
+      if one_year?
+        :year
+      elsif one_quarter?
+        :quarter
+      elsif one_month?
+        :month
+      end
+    end
+
+    # Returns a string representation of the date range relative to today. For example
+    # a range of 2021-01-01..2021-12-31 will return `this_year` when the current date
+    # is somewhere in 2021.
+    def relative_param
+      @relative_param ||= SHORTHANDS
+        .select { |key, _| key.end_with?(granularity.to_s) }
+        .find { |key, range| self == range.call }
+        &.first
+        &.to_s
+    end
+
+    # Returns a param representation of the date range. When `relative` is true,
+    # the `relative_param` is returned when available. This allows for easy bookmarking of
+    # URL's that always return the current month/quarter/year for the end user.
+    #
+    # When `relative` is false, a `YYYYMMDD..YYYYMMDD` or `YYYYMM..YYYYMM` format is
+    # returned. The output of `to_param` is compatible with the `parse` method.
+    #
+    #   DateRange.parse("202001..202001").to_param                  # => "202001..202001"
+    #   DateRange.parse("20200101..20200115").to_param              # => "20200101..20200115"
+    #   DateRange.parse("202001..202001").to_param(relative: true)  # => "this_month"
+    def to_param(relative: true)
+      if relative && relative_param
+        relative_param
+      else
+        format = full_month? ? "%Y%m" : "%Y%m%d"
+        "#{self.begin.strftime(format)}..#{self.end.strftime(format)}"
+      end
+    end
+
+    # Returns a Range with begin and end as DateTime instances.
+    def to_datetime_range
+      Range.new(self.begin.to_datetime.at_beginning_of_day, self.end.to_datetime.at_end_of_day)
+    end
+
+    def to_s
+      "#{self.begin.strftime('%Y%m%d')}..#{self.end.strftime('%Y%m%d')}"
+    end
+
+    # Returns the period previous to the current period. `periods` can be raised to return more
+    # than 1 previous period.
+    #
+    #   DateRange.this_month.previous # => DateRange.prev_month
+    #   DateRange.this_month.previous(2) # => DateRange.prev_month.previous + DateRange.prev_month
+    def previous(periods = 1)
+      if granularity
+        DateRange.new(self.begin - periods.send(granularity), self.begin - 1.day)
+      elsif full_month?
+        DateRange.new(in_groups_of(:month).first.previous(periods * months).begin, self.begin - 1.day)
+      else
+        DateRange.new((self.begin - (periods * days).days).at_beginning_of_month, self.begin - 1.day)
+      end
+    end
+
+    # Returns the period next to the current period. `periods` can be raised to return more
+    # than 1 next period.
+    #
+    #   DateRange.this_month.next # => DateRange.next_month
+    #   DateRange.this_month.next(2) # => DateRange.next_month + DateRange.next_month.next
+    def next(periods = 1)
+      if granularity
+        DateRange.new(self.end + 1.day, (self.end + periods.send(granularity)).at_end_of_month)
+      else
+        DateRange.new(self.end + 1.day, (self.end + days.days).at_end_of_month)
+      end
+    end
+
+    # Returns an array with date ranges containing full months/quarters/years in the current range.
+    # Comes in handy when you need to have columns by month for a given range:
+    # `DateRange.this_year.in_groups_of(:months)`
+    #
+    # Always returns full months/quarters/years, from the first to the last day of the period.
+    # The first and last item in the array can have a partial month/quarter/year, depending on
+    # the date range.
+    #
+    #   DateRange.parse("202101..202103").in_groups_of(:month) # => [DateRange.parse("202001..202001"), DateRange.parse("202002..202002"), DateRange.parse("202003..202003")]
+    #   DateRange.parse("202101..202106").in_groups_of(:month, amount: 2) # => [DateRange.parse("202001..202002"), DateRange.parse("202003..202004"), DateRange.parse("202005..202006")]
+    def in_groups_of(granularity, amount: 1)
+      raise UnknownGranularity, "Unknown granularity #{granularity}. Valid are: month, quarter and year" unless %w[month quarter year].include?(granularity.to_s)
+
+      group_by { |d| [d.year, d.send(granularity)] }
+        .map { |_, group| DateRange.new(group.first..group.last) }
+        .in_groups_of(amount)
+        .map { |group| group.inject(:+) }
+    end
+
+    # Returns a human readable format for the date range. See DateRange::Humanizer for options.
+    def humanize(format: :short)
+      Humanizer.new(self, format: format).humanize
+    end
+  end
+end