time_boots 0.0.1

checksums.yaml

@@ -0,0 +1,7 @@
+---
+SHA1:
+  metadata.gz: 2d915342173e04dfa56b06a071ce00895bfd1f7c
+  data.tar.gz: 224f704b9f2252a6d1915416972e935bb271ee0a
+SHA512:
+  metadata.gz: 75392ebf3e012f77a133ac50cc79bb18e510289574148fc47279c89a8df64264000c1a47e532c212bd1d6b8962a4a3d58c9da270a869372285a715efdd424e04
+  data.tar.gz: 3ab029a28565166df7c4581f447e0a0a127d4eaec7e6024391bcd39374fff88398ef6f7dac61058b45e8d68674a762612867686405bf000b9c3ec4f01d47faf1

data/README.md

@@ -0,0 +1,214 @@
+# Time Boots
+
+[![Dependency Status](https://gemnasium.com/zverok/time_boots.svg)](https://gemnasium.com/zverok/time_boots)
+[![Code Climate](https://codeclimate.com/github/zverok/time_boots/badges/gpa.svg)](https://codeclimate.com/github/zverok/time_boots)
+[![Build Status](https://travis-ci.org/zverok/time_boots.svg?branch=master)](https://travis-ci.org/zverok/time_boots)
+[![Coverage Status](https://coveralls.io/repos/zverok/time_boots/badge.svg?branch=master)](https://coveralls.io/r/zverok/time_boots?branch=master)
+
+**TimeBoots** is a small, no-dependencies library attemting to make time
+steps easier. It provides you with simple, easy-to-remember API, without
+any monkey-patching of core Ruby classes, so it can be used alongside
+Rails or without it, for any purpose.
+
+## Simple time math
+
+### Floor, ceil and round:
+
+```ruby
+TimeBoots.steps
+# => [:sec, :min, :hour, :day, :week, :month, :year]
+
+tm = Time.parse('2015-03-05 10:08')
+# => 2015-03-05 10:08:00 +0200
+
+TimeBoots.floor(:hour, tm)
+# => 2015-03-05 10:00:00 +0200
+
+TimeBoots.floor(:month, tm)
+# => 2015-03-01 00:00:00 +0200
+
+# or
+TimeBoots.month.floor(tm)
+# => 2015-03-01 00:00:00 +0200
+
+TimeBoots.month.ceil(tm)
+# => 2015-04-01 00:00:00 +0300
+# Note the timezone change: our (Ukraine) DST was in March,
+# and TimeBoots plays perfectly well with it.
+
+TimeBoots.month.round(tm)
+# => 2015-03-01 00:00:00 +0200
+
+TimeBoots.month.round?(tm)
+# => false
+
+TimeBoots.min.round?(tm)
+# => true
+```
+
+### Moving in time forwards and backwards
+
+```ruby
+TimeBoots.month.advance(tm)
+# => 2015-04-05 10:08:00 +0300
+
+TimeBoots.month.advance(tm, 4)
+# => 2015-07-05 10:08:00 +0300
+
+TimeBoots.month.advance(tm, -4)
+# => 2014-11-05 10:08:00 +0200
+
+# or
+TimeBoots.month.decrease(tm, 4)
+# => 2014-11-05 10:08:00 +0200
+```
+
+Also abstracted as time **jump**, which you can store in variables and
+pass to other methods:
+
+```ruby
+jump = TimeBoots.month.jump(4)
+# => #<TimeBoots::Jump(month): +4>
+
+jump.before(tm)
+# => 2014-11-05 10:08:00 +0200
+
+jump.after(tm)
+# => 2015-07-05 10:08:00 +0300
+```
+
+### Creating time ranges
+
+```ruby
+TimeBoots.hour.range(tm, 5)
+# => 2015-03-05 10:08:00 +0200...2015-03-05 15:08:00 +0200 
+TimeBoots.hour.range_back(tm, 5)
+# => 2015-03-05 05:08:00 +0200...2015-03-05 10:08:00 +0200 
+```
+
+## Measuring time periods
+
+```ruby
+# My real birthday, in fact!
+birthday = Time.parse('1983-02-14 13:30')
+
+# How many days have I lived?
+TimeBoots.day.measure(birthday, Time.now)
+# => 11764
+
+# And how many weeks (with reminder)?
+TimeBoots.week.measure_rem(birthday, Time.now)
+# => [1680, 2015-04-27 12:30:00 +0300]
+# the thing is "birthday plus 1680 weeks == reminder"
+
+# My full age
+TimeBoots.measure(birthday, Time.now)
+# => {:years=>32, :months=>2, :weeks=>2, :days=>3, :hours=>6, :minutes=>59, :seconds=>7}
+
+# NB: you can use this output with String#format or String%:
+puts "%{years}y %{months}m %{weeks}w %{days}d %{hours}h %{minutes}m %{seconds}s" % TimeBoots.measure(birthday, Time.now)
+# "32y 2m 2w 3d 7h 2m 50s"
+
+# Option: measure without weeks
+TimeBoots.measure(birthday, Time.now, weeks: false)
+# => {:years=>32, :months=>2, :days=>17, :hours=>7, :minutes=>5, :seconds=>11} 
+
+# My full age in days, hours, minutes
+TimeBoots.measure(birthday, Time.now, max_step: :day)
+# => {:days=>11764, :hours=>8, :minutes=>6, :seconds=>41}
+```
+
+## Time series generation: "laces"
+
+I'm a real fan of funny names in gems. Here we have time **boots** for working
+with time **steps**. So, something continuous will be called **lace**.
+
+I hope, next examples are pretty self-explanatory.
+
+```ruby
+from = Time.parse('2015-03-05 10:08')
+to = Time.parse('2015-03-09 11:07')
+
+lace = TimeBoots.month.lace(from, to)
+# => #<TimeBoots::Lace(2015-03-05 10:08:00 +0200 - 2015-03-09 11:07:00 +0200)>
+
+# or
+TimeBoots.lace(:month, from, to)
+# => #<TimeBoots::Lace(2015-03-05 10:08:00 +0200 - 2015-03-09 11:07:00 +0200)>
+
+lace.pull
+# => [2015-03-05 10:08:00 +0200,
+#     2015-03-06 10:08:00 +0200,
+#     2015-03-07 10:08:00 +0200,
+#     2015-03-08 10:08:00 +0200,
+#     2015-03-09 10:08:00 +0200]
+```
+
+So, we have just a series of times, each day, from `from` until `to`.
+Note, there is a same time of the day (10:08), as it was in `from`.
+
+The `pull` method has an optional argument, when it is `true`, the
+method returns `floor`-ed times (e.g. midnights for daily lace):
+
+```ruby
+lace.pull(true)
+# => [2015-03-05 10:08:00 +0200,
+#     2015-03-06 00:00:00 +0200,
+#     2015-03-07 00:00:00 +0200,
+#     2015-03-08 00:00:00 +0200,
+#     2015-03-09 00:00:00 +0200]
+```
+
+Note the first value still at 10:08: we don't want to go before `from`.
+Lace also can "expand" your period for you (`floor` the beginning and
+`ceil` the end):
+
+```ruby
+lace.expand
+# => #<TimeBoots::Lace(2015-03-05 00:00:00 +0200-2015-03-10 00:00:00 +0200)>
+
+# or
+lace.expand!
+
+# or start with expanded:
+TimeBoots.month.lace(from, to, expanded: true)
+```
+
+Another useful lace's functionality is generating periods.
+It can be useful for filtering daily data from database, for example:
+
+```ruby
+lace.pull_ranges
+# => [2015-03-05 10:08:00 +0200...2015-03-06 10:08:00 +0200,
+#     2015-03-06 10:08:00 +0200...2015-03-07 10:08:00 +0200,
+#     2015-03-07 10:08:00 +0200...2015-03-08 10:08:00 +0200,
+#     2015-03-08 10:08:00 +0200...2015-03-09 10:08:00 +0200,
+#     2015-03-09 10:08:00 +0200...2015-03-09 11:07:00 +0200]
+
+# Now, you can do something like:
+
+lace.pull_ranges.map{|range| dataset.where(timestamp: range).count}
+# ...and have your daily stats with one line of code
+
+```
+
+## Got it, what else?
+
+TimeBoots also play well when included into other classes or modules:
+
+```ruby
+class MyModel
+  include TimeBoots
+
+  def next_day
+    day.advance # Here!
+  end
+end
+```
+
+And there are some plans for the future:
+* `TimeBoots.resample`, which would do resampling (take daily data and
+  group it monthly, and so on) easy task;
+* optional `core_ext`, providing methods like `4.months.ago` for the
+  (Rails-less) rest of us;
+* your ideas?..

data/lib/time_boots/boot/day.rb

@@ -0,0 +1,28 @@
+# encoding: utf-8
+module TimeBoots
+  class DayBoot < SimpleBoot
+    def initialize
+      super(:day)
+    end
+
+    protected
+
+    def _advance(tm, steps)
+      fix_dst(super(tm, steps), tm)
+    end
+
+    def _decrease(tm, steps)
+      fix_dst(super(tm, steps), tm)
+    end
+
+    def fix_dst(res, src)
+      if res.dst? && !src.dst?
+        hour.decrease(res)
+      elsif !res.dst? && src.dst?
+        hour.advance(res)
+      else
+        res
+      end
+    end
+  end
+end

data/lib/time_boots/boot/month.rb

@@ -0,0 +1,45 @@
+# encoding: utf-8
+module TimeBoots
+  class MonthBoot < Boot
+    def initialize
+      super(:month)
+    end
+
+    def measure(from, to)
+      ydiff = to.year - from.year
+      mdiff = to.month - from.month
+
+      to.day >= from.day ? (ydiff * 12 + mdiff) : (ydiff * 12 + mdiff - 1)
+    end
+
+    protected
+
+    def succ(tm)
+      return generate(tm, year: tm.year + 1, month: 1) if tm.month == 12
+
+      t = generate(tm, month: tm.month + 1)
+      fix_month(t, t.month + 1)
+    end
+
+    def prev(tm)
+      return generate(tm, year: tm.year - 1, month: 12) if tm.month == 1
+
+      t = generate(tm, month: tm.month - 1)
+      fix_month(t, t.month - 1)
+    end
+
+    def _advance(tm, steps)
+      steps.times.inject(tm){|t| succ(t)}
+    end
+
+    def _decrease(tm, steps)
+      steps.times.inject(tm){|t| prev(t)}
+    end
+
+    # fix for too far advance/insufficient decrease:
+    #  Time.new(2013,2,31) #=> 2013-03-02 00:00:00 +0200
+    def fix_month(t, expected)
+      t.month == expected ? day.decrease(t, t.day) : t
+    end
+  end
+end

data/lib/time_boots/boot/simple.rb

@@ -0,0 +1,42 @@
+# encoding: utf-8
+module TimeBoots
+  class SimpleBoot < Boot
+    def to_seconds(sz = 1)
+      sz * MULTIPLIERS[step_idx..-1].inject(:*)
+    end
+
+    def measure(from, to)
+      ((to - from) / to_seconds).to_i
+    end
+
+    protected
+
+    def _advance(tm, steps)
+      tm + to_seconds(steps)
+    end
+
+    def _decrease(tm, steps)
+      tm - to_seconds(steps)
+    end
+
+    MULTIPLIERS = [12, 30, 24, 60, 60, 1]
+  end
+
+  class SecBoot < SimpleBoot
+    def initialize
+      super(:sec)
+    end
+  end
+
+  class MinBoot < SimpleBoot
+    def initialize
+      super(:min)
+    end
+  end
+
+  class HourBoot < SimpleBoot
+    def initialize
+      super(:hour)
+    end
+  end
+end

data/lib/time_boots/boot/week.rb

@@ -0,0 +1,28 @@
+# encoding: utf-8
+module TimeBoots
+  class WeekBoot < SimpleBoot
+    def initialize
+      super(:week)
+    end
+
+    def floor(tm)
+      f = day.floor(tm)
+      extra_days = tm.wday == 0 ? 6 : tm.wday - 1
+      day.decrease(f, extra_days)
+    end
+
+    def to_seconds(sz = 1)
+      day.to_seconds(sz * 7)
+    end
+
+    protected
+
+    def _advance(tm, steps)
+      day.advance(tm, steps * 7)
+    end
+
+    def _decrease(tm, steps)
+      day.decrease(tm, steps * 7)
+    end
+  end
+end

data/lib/time_boots/boot/year.rb

@@ -0,0 +1,26 @@
+# encoding: utf-8
+module TimeBoots
+  class YearBoot < Boot
+    def initialize
+      super(:year)
+    end
+
+    def measure(from, to)
+      if generate(from, year: to.year) < to
+        to.year - from.year
+      else
+        to.year - from.year - 1
+      end
+    end
+
+    protected
+    
+    def _advance(tm, steps)
+      generate(tm, year: tm.year + steps)
+    end
+
+    def _decrease(tm, steps)
+      generate(tm, year: tm.year - steps)
+    end
+  end
+end

data/lib/time_boots/boot.rb

@@ -0,0 +1,119 @@
+# encoding: utf-8
+module TimeBoots
+  class Boot
+    def initialize(step)
+      @step = step
+    end
+
+    attr_reader :step
+
+    def floor(tm)
+      components = [tm.year,
+                    tm.month,
+                    tm.day,
+                    tm.hour,
+                    tm.min,
+                    tm.sec].first(step_idx + 1)
+        
+      Time.new(*components)
+    end
+
+    def ceil(tm)
+      f = floor(tm)
+
+      f == tm ? f : advance(f)
+    end
+
+    def round(tm)
+      f, c = floor(tm), ceil(tm)
+
+      (tm - f).abs < (tm - c).abs ? f : c
+    end
+
+    def round?(tm)
+      floor(tm) == tm
+    end
+
+    def advance(tm, steps = 1)
+      return decrease(tm, -steps) if steps < 0
+      _advance(tm, steps)
+    end
+
+    def decrease(tm, steps = 1)
+      return advance(tm, -steps) if steps < 0
+      _decrease(tm, steps)
+    end
+
+    def range(tm, steps = 1)
+      (tm...advance(tm, steps))
+    end
+
+    def range_back(tm, steps = 1)
+      (decrease(tm, steps)...tm)
+    end
+
+    def measure(_from, _to)
+      fail NotImplementedError, '#measure should be implemented in subclasses'
+    end
+
+    def measure_rem(from, to)
+      m = measure(from, to)
+      [m, advance(from, m)]
+    end
+
+    def jump(steps)
+      Jump.new(step, steps)
+    end
+
+    def lace(from, to, options = {})
+      Lace.new(step, from, to, options)
+    end
+
+    protected
+    
+    NATURAL_STEPS = [:year, :month, :day, :hour, :min, :sec]
+
+    def step_idx
+      NATURAL_STEPS.index(step) or
+        fail(NotImplementedError, "Can not be used for step #{step}")
+    end
+
+    def generate(tm, replacements = {})
+      hash_to_tm(tm_to_hash(tm).merge(replacements))
+    end
+
+    def tm_to_hash(tm)
+      Hash[*NATURAL_STEPS.flat_map{|s| [s, tm.send(s)]}]
+    end
+
+    def hash_to_tm(hash)
+      components = NATURAL_STEPS.map{|s| hash[s] || 0}
+      Time.new(*components)
+    end
+
+    include TimeBoots # now we can use something like #day inside boots
+
+    require_relative 'boot/simple'
+    require_relative 'boot/day'
+    require_relative 'boot/week'
+    require_relative 'boot/month'
+    require_relative 'boot/year'
+  
+    BOOTS = {
+      sec: SecBoot.new, min: MinBoot.new, hour: HourBoot.new,
+      day: DayBoot.new, week: WeekBoot.new, month: MonthBoot.new,
+      year: YearBoot.new
+    }
+
+    class << self
+      def steps
+        BOOTS.keys
+      end
+      
+      def get(step)
+        BOOTS[step] or
+          fail(ArgumentError, "Unsupported step: #{step}")
+      end
+    end
+  end
+end

data/lib/time_boots/jump.rb

@@ -0,0 +1,30 @@
+# encoding: utf-8
+module TimeBoots
+  class Jump
+    def initialize(step, amount)
+      @step, @amount = step, amount
+      @boot = Boot.get(step)
+    end
+
+    attr_reader :step, :amount
+
+    def before(tm = Time.now)
+      @boot.decrease(tm, amount)
+    end
+
+    def after(tm = Time.now)
+      @boot.advance(tm, amount)
+    end
+
+    alias_method :ago, :before 
+    alias_method :from, :after
+
+    def ==(other)
+      step == other.step && amount == other.amount
+    end
+
+    def inspect
+      '#<%s(%s): %+i>' % [self.class, step, amount]
+    end
+  end
+end

data/lib/time_boots/lace.rb

@@ -0,0 +1,59 @@
+# encoding: utf-8
+module TimeBoots
+  class Lace
+    def initialize(step, from, to, options = {})
+      @boot = Boot.get(step)
+      @from, @to = from, to
+      @options = options.dup
+
+      expand! if options[:expand]
+    end
+
+    attr_reader :from, :to
+
+    def expand!
+      @from = boot.floor(from)
+      @to = boot.ceil(to)
+      
+      self
+    end
+
+    def expand
+      dup.tap(&:expand!)
+    end
+
+    def pull(beginnings = false)
+      seq = []
+
+      iter = from
+      while iter < to
+        seq << iter
+
+        iter = cond_floor(boot.advance(iter), beginnings)
+      end
+      
+      seq
+    end
+
+    def pull_pairs(beginnings = false)
+      seq = pull(beginnings)
+      seq.zip(seq[1..-1] + [to])
+    end
+
+    def pull_ranges(beginnings = false)
+      pull_pairs(beginnings).map{|b, e| (b...e)}
+    end
+
+    def inspect
+      "#<#{self.class}(#{from} - #{to})>"
+    end
+
+    private
+
+    def cond_floor(tm, should_floor)
+      should_floor ? boot.floor(tm) : tm
+    end
+    
+    attr_reader :boot
+  end
+end

data/lib/time_boots/measure.rb

@@ -0,0 +1,32 @@
+# encoding: utf-8
+module TimeBoots
+  module Measure
+    PLURALS = {
+      year: :years,
+      month: :months,
+      week: :weeks,
+      day: :days,
+      hour: :hours,
+      min: :minutes,
+      sec: :seconds
+    }
+    
+    def self.measure(from, to, options = {})
+      select_steps(options).reverse.inject({}) do |res, step|
+        span, from = Boot.get(step).measure_rem(from, to)
+        res.merge(PLURALS[step] => span)
+      end
+    end
+
+    def self.select_steps(options)
+      steps = Boot.steps
+      steps.delete(:week) if options[:weeks] == false
+
+      if (idx = steps.index(options[:max_step]))
+        steps = steps.first(idx + 1)
+      end
+
+      steps
+    end
+  end
+end

data/lib/time_boots/version.rb

@@ -0,0 +1,4 @@
+# encoding: utf-8
+module TimeBoots
+  VERSION = '0.0.1'
+end

data/lib/time_boots.rb

@@ -0,0 +1,95 @@
+# encoding: utf-8
+require 'time'
+
+module TimeBoots
+  # rubocop:disable Style/ModuleFunction
+  extend self
+  # rubocop:enable Style/ModuleFunction
+  
+  def steps
+    Boot.steps
+  end
+
+  # NB: no fancy meta-programming here: we want YARD to be happy
+
+  # Boot shortcuts
+  
+  def sec
+    Boot.get(:sec)
+  end
+
+  def min
+    Boot.get(:min)
+  end
+
+  def hour
+    Boot.get(:hour)
+  end
+
+  def day
+    Boot.get(:day)
+  end
+
+  def week
+    Boot.get(:week)
+  end
+
+  def month
+    Boot.get(:month)
+  end
+
+  def year
+    Boot.get(:year)
+  end
+
+  # Boot-less method shortcuts
+
+  def floor(step, tm)
+    Boot.get(step).floor(tm)
+  end
+
+  def ceil(step, tm)
+    Boot.get(step).ceil(tm)
+  end
+
+  def round(step, tm)
+    Boot.get(step).round(tm)
+  end
+
+  def round?(step, tm)
+    Boot.get(step).round?(tm)
+  end
+
+  def advance(step, tm, steps = 1)
+    Boot.get(step).advance(step, tm, steps)
+  end
+
+  def decrease(step, tm, steps = 1)
+    Boot.get(step).decrease(step, tm, steps)
+  end
+
+  def range(step, tm, steps = 1)
+    Boot.get(step).range(tm, steps)
+  end
+
+  def range_back(step, tm, steps = 1)
+    Boot.get(step).range_back(tm, steps)
+  end
+
+  def jump(step, steps = 1)
+    Boot.get(step).jump(steps)
+  end
+
+  def measure(from, to, options = {})
+    Measure.measure(from, to, options)
+  end
+
+  def lace(step, from, to, options = {})
+    Boot.get(step).lace(from, to, options)
+  end
+end
+
+require_relative './time_boots/boot'
+require_relative './time_boots/lace'
+require_relative './time_boots/measure'
+require_relative './time_boots/jump'

data/time_boots.gemspec

@@ -0,0 +1,36 @@
+require './lib/time_boots/version'
+
+Gem::Specification.new do |s|
+  s.name     = 'time_boots'
+  s.version  = TimeBoots::VERSION
+  s.authors  = ['Victor Shepelev']
+  s.email    = 'zverok.offline@gmail.com'
+  s.homepage = 'https://github.com/zverok/time_boots'
+
+  s.summary = 'Easy time steps math'
+  s.description = <<-EOF
+    TimeBoots is small, no-dependencies library attemting to make time
+    steps easier. It provides you with simple, easy remembered API, without
+    any monkey patching of core Ruby classes, so it can be used alongside
+    Rails or without it, for any purpose.
+  EOF
+  s.licenses = ['MIT']
+
+  s.files = `git ls-files`.split($RS).reject do |file|
+    file =~ /^(?:
+    spec\/.*
+    |Gemfile
+    |Rakefile
+    |\.rspec
+    |\.gitignore
+    |\.rubocop.yml
+    |\.travis.yml
+    )$/x
+  end
+  s.require_paths = ["lib"]
+
+  s.add_development_dependency 'rubocop', '~> 0.30'
+  s.add_development_dependency 'rspec', '~> 3'
+  s.add_development_dependency 'rspec-its', '~> 1'
+  s.add_development_dependency 'simplecov', '~> 0.9'
+end

metadata

@@ -0,0 +1,116 @@
+--- !ruby/object:Gem::Specification
+name: time_boots
+version: !ruby/object:Gem::Version
+  version: 0.0.1
+platform: ruby
+authors:
+- Victor Shepelev
+autorequire: 
+bindir: bin
+cert_chain: []
+date: 2015-05-04 00:00:00.000000000 Z
+dependencies:
+- !ruby/object:Gem::Dependency
+  name: rubocop
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: '0.30'
+  type: :development
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: '0.30'
+- !ruby/object:Gem::Dependency
+  name: rspec
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: '3'
+  type: :development
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: '3'
+- !ruby/object:Gem::Dependency
+  name: rspec-its
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: '1'
+  type: :development
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: '1'
+- !ruby/object:Gem::Dependency
+  name: simplecov
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: '0.9'
+  type: :development
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: '0.9'
+description: |2
+      TimeBoots is small, no-dependencies library attemting to make time
+      steps easier. It provides you with simple, easy remembered API, without
+      any monkey patching of core Ruby classes, so it can be used alongside
+      Rails or without it, for any purpose.
+email: zverok.offline@gmail.com
+executables: []
+extensions: []
+extra_rdoc_files: []
+files:
+- README.md
+- lib/time_boots.rb
+- lib/time_boots/boot.rb
+- lib/time_boots/boot/day.rb
+- lib/time_boots/boot/month.rb
+- lib/time_boots/boot/simple.rb
+- lib/time_boots/boot/week.rb
+- lib/time_boots/boot/year.rb
+- lib/time_boots/jump.rb
+- lib/time_boots/lace.rb
+- lib/time_boots/measure.rb
+- lib/time_boots/version.rb
+- time_boots.gemspec
+homepage: https://github.com/zverok/time_boots
+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.4.6
+signing_key: 
+specification_version: 4
+summary: Easy time steps math
+test_files: []