scheduled_value 1.0.0

checksums.yaml

@@ -0,0 +1,7 @@
+---
+SHA1:
+  metadata.gz: 03256b1fb2793955ad190fb8e3843c2284ebcbec
+  data.tar.gz: 7de94668cee16c3ec62273d27e968cc0e3468aed
+SHA512:
+  metadata.gz: 3c0ff1582c58ef50cd518efc791b5ce467359a3bb0adb0b4155801a8f0e91c471775e9bd34c9ff1fb7a72b391281824372701fb1299d995933f497c1628624fb
+  data.tar.gz: 09b4918af958643332601f717edcd4a83a8ab7a841cf9e3b556f376aac264e030b1d4c8867f5f756408a3c40d55133901d7f4615290f6e7230f5a79aa65ace3c

data/.gitignore

@@ -0,0 +1,9 @@
+/.bundle/
+/.yardoc
+/Gemfile.lock
+/_yardoc/
+/coverage/
+/doc/
+/pkg/
+/spec/reports/
+/tmp/

data/.travis.yml

@@ -0,0 +1,4 @@
+language: ruby
+rvm:
+  - 2.3.1
+before_install: gem install bundler -v 1.10.5

data/CHANGELOG.md

@@ -0,0 +1,3 @@
+# 1.0.0 - December 24, 2016
+
+* Initial public release.

data/Gemfile

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

data/README.md

@@ -0,0 +1,39 @@
+# ScheduledValue
+
+![Codeship test status](https://codeship.com/projects/165d5000-ac28-0134-2a75-16abc9b20ebe/status?branch=master)
+
+ScheduledValue provides a set of Ruby classes for representing values that change over time based on a schedule.  One way to think about this is that for a regular variable, you could reasonably ask "what is its value?"  For a ScheduledValue, you have to ask "what is its value *right now*?"  Some examples of this might be:
+
+* an on-call rotation (who is on call *right now*?)
+* pricing for an event with early bird tickets (what is the price *right now*?)
+
+ScheduledValue also provides a `ScheduledValue::Timespan` class that represents a span of time, which may have a defined start point, a defined end point, both, or neither.  `ScheduledValue::Timespan`s are Ruby `Comparable` objects.
+
+All classes in the ScheduledValue gem are designed to be serializable to and from dictionary-like formats, such as JSON and YAML.  This makes it easy to use them with ActiveRecord's `serialize` class method and other similar techniques for storing them in a database column.
+
+## Installation
+
+Add this line to your application's Gemfile:
+
+```ruby
+gem 'scheduled_value'
+```
+
+And then execute:
+
+    $ bundle
+
+Or install it yourself as:
+
+    $ gem install scheduled_value
+
+## 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/neinteractiveliterature/scheduled_value.
+

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/bin/console

@@ -0,0 +1,14 @@
+#!/usr/bin/env ruby
+
+require "bundler/setup"
+require "scheduled_value"
+
+# 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

data/bin/setup

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

data/lib/scheduled_value.rb

@@ -0,0 +1,7 @@
+require "scheduled_value/version"
+require "scheduled_value/timespan"
+require "scheduled_value/timespan_with_value"
+require "scheduled_value/scheduled_value"
+
+module ScheduledValue
+end

data/lib/scheduled_value/scheduled_value.rb

@@ -0,0 +1,106 @@
+module ScheduledValue
+  class ScheduledValue
+    attr_reader :timespans
+
+    def self.timespan_with_value_class
+      TimespanWithValue
+    end
+
+    def self.always(value)
+      timespan = timespan_with_value_class.new(start: nil, finish: nil, value: value)
+      self.new(timespans: [timespan])
+    end
+
+    def from_json(json, include_root = false)
+      hash = JSON.parse(json)
+      hash = hash.values.first if include_root
+      self.attributes = hash
+      self
+    end
+
+    def initialize(timespans: [])
+      self.timespans = timespans
+    end
+
+    def attributes
+      {
+        timespans: timespans
+      }
+    end
+
+    def attributes=(attributes)
+      self.timespans = attributes[:timespans] || attributes['timespans']
+    end
+
+    def timespans=(timespan_values)
+      @timespans = SortedSet.new
+
+      timespan_values.each do |timespan_value|
+        timespan = case timespan_value
+        when self.class.timespan_with_value_class then timespan_value
+        when Hash then
+          attributes = timespan_value.each_with_object({}) { |(key, value), hash| hash[key.to_sym] = value }
+          self.class.timespan_with_value_class.new(**attributes)
+        end
+
+        self << timespan if timespan
+      end
+
+      @timespans
+    end
+
+    def <<(timespan_with_value)
+      overlapping_timespan = timespan_overlapping(timespan_with_value)
+      raise "Timespan for value #{overlapping_timespan} would overlap with #{timespan_with_value}" if overlapping_timespan
+
+      @timespans << timespan_with_value
+      @timespans_array = nil
+
+      timespan_with_value
+    end
+
+    def set_value_for_timespan(start, finish, value)
+      self << self.class.timespan_with_value_class.new(start: start, finish: finish, vaule: value)
+      value
+    end
+
+    def value_at(timestamp)
+      timespan = timespan_containing(timestamp)
+      raise "No timespan found for #{timestamp}" unless timespan
+
+      timespan.value
+    end
+
+    def next_value_change_after(timestamp)
+      timespan = timespan_containing(timestamp)
+      return nil unless timespan
+
+      timespan.finish
+    end
+
+    def covers_all_time?
+      timespans_array = timespans.to_a
+      !timespans_array.first.start && !timespans_array.last.finish
+    end
+
+    private
+
+    def timespans_array
+      @timespans_array ||= timespans.to_a
+    end
+
+    def timespan_containing(timestamp)
+      timespans_array.bsearch do |timespan|
+        if timespan.contains? timestamp
+          0
+        else
+          (timespan <=> timestamp) * -1
+        end
+      end
+    end
+
+    def timespan_overlapping(timespan)
+      timespans.find { |my_timespan| my_timespan.overlaps? timespan }
+    end
+  end
+end

data/lib/scheduled_value/timespan.rb

@@ -0,0 +1,95 @@
+module ScheduledValue
+  class Timespan
+    include Comparable
+    attr_accessor :start, :finish
+
+    def initialize(start: nil, finish: nil)
+      @start = start
+      @finish = finish
+
+      raise "Finish must be after start" if start && finish && start >= finish
+    end
+
+    def attributes
+      {
+        start: start,
+        finish: finish
+      }
+    end
+
+    def start=(value)
+      @start = convert_time_value(value)
+    end
+
+    def finish=(value)
+      @finish = convert_time_value(value)
+    end
+
+    def contains?(timestamp)
+      return false if start && timestamp < start
+      return false if finish && timestamp >= finish
+
+      true
+    end
+
+    def overlaps?(other)
+      return false if finish && other.start && other.start >= finish
+      return false if start && other.finish && start >= other.finish
+
+      true
+    end
+
+    def <=>(other)
+      case other
+      when Timespan then compare_timespan(other)
+      when Date, Time, DateTime then compare_datetime(other)
+      end
+    end
+
+    def inspect
+      "#<#{self.class.name}: #{self}>"
+    end
+
+    def to_s(format = nil)
+      "#{start_description(format)} #{finish_description(format)}"
+    end
+
+    def start_description(format = nil)
+      if start
+        "from #{start.to_s(format)}"
+      else
+        'anytime'
+      end
+    end
+
+    def finish_description(format = nil)
+      if finish
+        "up to #{finish.to_s(format)}"
+      elsif start
+        "indefinitely"
+      end
+    end
+
+    private
+    def compare_timespan(other)
+      return 0 if other.start == start && other.finish == finish
+      return nil if other.overlaps?(self)
+      return -1 if finish && other.start && other.start >= finish
+      return 1 if start && other.finish && other.finish <= start
+    end
+
+    def compare_datetime(other)
+      return nil if contains?(other)
+      return -1 if finish && other >= finish
+      return 1 if start && other < start
+      0
+    end
+
+    def convert_time_value(value)
+      case value
+      when String then Time.iso8601(value)
+      else value
+      end
+    end
+  end
+end

data/lib/scheduled_value/timespan_with_value.rb

@@ -0,0 +1,18 @@
+module ScheduledValue
+  class TimespanWithValue < Timespan
+    attr_accessor :value
+
+    def initialize(start: nil, finish: nil, value: nil)
+      super(start: start, finish: finish)
+      @value = value
+    end
+
+    def attributes
+      super.merge(value: value)
+    end
+
+    def to_s(format = nil)
+      "#{value} #{super}"
+    end
+  end
+end

data/lib/scheduled_value/version.rb

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

data/scheduled_value.gemspec

@@ -0,0 +1,25 @@
+# coding: utf-8
+lib = File.expand_path('../lib', __FILE__)
+$LOAD_PATH.unshift(lib) unless $LOAD_PATH.include?(lib)
+require 'scheduled_value/version'
+
+Gem::Specification.new do |spec|
+  spec.name          = "scheduled_value"
+  spec.version       = ScheduledValue::VERSION
+  spec.authors       = ["Nat Budin"]
+  spec.email         = ["natbudin@gmail.com"]
+
+  spec.summary       = %q{Ruby classes for values that change over time}
+  spec.description   = %q{ScheduledValue allows you to create and store values which change over time based on a schedule.}
+  spec.homepage      = "https://github.com/neinteractiveliterature/scheduled_value"
+  spec.license       = "MIT"
+
+  spec.files         = `git ls-files -z`.split("\x0").reject { |f| f.match(%r{^(test|spec|features)/}) }
+  spec.bindir        = "exe"
+  spec.executables   = spec.files.grep(%r{^exe/}) { |f| File.basename(f) }
+  spec.require_paths = ["lib"]
+
+  spec.add_development_dependency "bundler", "~> 1.10"
+  spec.add_development_dependency "rake", "~> 10.0"
+  spec.add_development_dependency "minitest"
+end

metadata

@@ -0,0 +1,101 @@
+--- !ruby/object:Gem::Specification
+name: scheduled_value
+version: !ruby/object:Gem::Version
+  version: 1.0.0
+platform: ruby
+authors:
+- Nat Budin
+autorequire: 
+bindir: exe
+cert_chain: []
+date: 2016-12-24 00:00:00.000000000 Z
+dependencies:
+- !ruby/object:Gem::Dependency
+  name: bundler
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: '1.10'
+  type: :development
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: '1.10'
+- !ruby/object:Gem::Dependency
+  name: rake
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: '10.0'
+  type: :development
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: '10.0'
+- !ruby/object:Gem::Dependency
+  name: minitest
+  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: ScheduledValue allows you to create and store values which change over
+  time based on a schedule.
+email:
+- natbudin@gmail.com
+executables: []
+extensions: []
+extra_rdoc_files: []
+files:
+- ".gitignore"
+- ".travis.yml"
+- CHANGELOG.md
+- Gemfile
+- README.md
+- Rakefile
+- bin/console
+- bin/setup
+- lib/scheduled_value.rb
+- lib/scheduled_value/scheduled_value.rb
+- lib/scheduled_value/timespan.rb
+- lib/scheduled_value/timespan_with_value.rb
+- lib/scheduled_value/version.rb
+- scheduled_value.gemspec
+homepage: https://github.com/neinteractiveliterature/scheduled_value
+licenses:
+- MIT
+metadata: {}
+post_install_message: 
+rdoc_options: []
+require_paths:
+- lib
+required_ruby_version: !ruby/object:Gem::Requirement
+  requirements:
+  - - ">="
+    - !ruby/object:Gem::Version
+      version: '0'
+required_rubygems_version: !ruby/object:Gem::Requirement
+  requirements:
+  - - ">="
+    - !ruby/object:Gem::Version
+      version: '0'
+requirements: []
+rubyforge_project: 
+rubygems_version: 2.6.4
+signing_key: 
+specification_version: 4
+summary: Ruby classes for values that change over time
+test_files: []