timed 0.1.0

checksums.yaml

@@ -0,0 +1,7 @@
+---
+SHA1:
+  metadata.gz: 91f02760afcbcaf91d29ddf7fe817fbc0ec7dcf5
+  data.tar.gz: b7220abee0fce727c26f6961ebbffbc737cc7eb2
+SHA512:
+  metadata.gz: db98749f2945a92b8ae56e58bdeb08d05c4b417fe8e2d9fc627f9de9cf39becf99000189c9b32b3eda704299eb8ac045ab23ba5f42e96191744534559f828c4d
+  data.tar.gz: 076b4b45416d418b1554453f5a97b82c717a242cbff240c827111a527bb0ac24e74b822d03498be917a020f84e035fe4cdec325b8d44b44c8db9e49f96abf97e

data/.gitignore

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

data/.travis.yml

@@ -0,0 +1,5 @@
+sudo: false
+language: ruby
+rvm:
+  - 2.3.0
+before_install: gem install bundler -v 1.12.5

data/Gemfile

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

data/LICENSE.txt

@@ -0,0 +1,21 @@
+The MIT License (MIT)
+
+Copyright (c) 2016 Sebastian Lindberg
+
+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,59 @@
+# Timed
+
+[![Build Status](https://travis-ci.org/seblindberg/ruby-timed.svg?branch=master)](https://travis-ci.org/seblindberg/ruby-timed)
+[![Coverage Status](https://coveralls.io/repos/github/seblindberg/ruby-timed/badge.svg?branch=master)](https://coveralls.io/github/seblindberg/ruby-timed?branch=master)
+[![Inline docs](http://inch-ci.org/github/seblindberg/ruby-timed.svg?branch=master)](http://inch-ci.org/github/seblindberg/ruby-timed)
+
+Gem for working with timed, ordered items. Still early days.
+
+The basic building block is the `Timed::Item`. These begin and end somewhere in time and can thus be related to each other. Several items can then be combined into a `Timed::Sequence`. This object guarantees that the items in it are non overlapping and ordered chronologically.
+
+## Installation
+
+Add this line to your application's Gemfile:
+
+```ruby
+gem 'timed'
+```
+
+And then execute:
+
+    $ bundle
+
+Or install it yourself as:
+
+    $ gem install timed
+
+## Usage
+
+```ruby
+require 'timed'
+
+# Create an empty
+sequence = Timed::Sequence.new
+
+# Add a couple of items. Any object that implements #begin
+# and #end can be added. Internally it is converted to a
+# Timed::Item.
+sequence << 10..20
+sequence << 30..40
+
+# Calculate the time occupied by the items in the sequence
+sequence.time # => 20
+```
+
+## 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/[USERNAME]/timed.
+
+
+## License
+
+The gem is available as open source under the terms of the [MIT License](http://opensource.org/licenses/MIT).
+

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 "timed"
+
+# 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,8 @@
+#!/usr/bin/env bash
+set -euo pipefail
+IFS=$'\n\t'
+set -vx
+
+bundle install
+
+# Do any other automated setup that you need to do here

data/lib/timed/item.rb

@@ -0,0 +1,96 @@
+module Timed
+  # Item
+  #
+  # The Timed Item is a Moment that can be chained to others to form a sequence.
+  # Importantly, items in a sequence are guaranteed to be sequential and non
+  # overlapping.
+  
+  class Item < Linked::Item
+    include Moment
+    # The value field is used to store the timespan and shuold not be accessed
+    # directly.
+
+    protected :value
+    private :value=
+
+    # Creates a new Timed Item from a timespan. A timespan is any object that
+    # responds to #begin and #end with two numerical values. Note that the end
+    # must occur after the start for the span to be valid.
+    #
+    # If given a second argument, the two will instead be interpreted as the
+    # begin and end time.
+    #
+    # timespan - object responding to #begin and #end.
+    # end_at - if given, it togheter with the first argument will be used as the
+    #          begin and end time for the item
+
+    def initialize(timespan, end_at = nil)
+      if end_at
+        begin_at = timespan
+      else
+        begin_at = timespan.begin
+        end_at = timespan.end
+      end
+
+      raise TypeError unless begin_at.is_a?(Numeric) && end_at.is_a?(Numeric)
+      raise ArgumentError if end_at < begin_at
+
+      super begin_at..end_at
+    end
+
+    # Returns the time when the item starts.
+
+    def begin
+      value.begin
+    end
+
+    # Returns the time when the item ends.
+
+    def end
+      value.end
+    end
+
+    # Returns a new Item in the intersection
+    #
+    # other - object that implements both #begin and #end.
+
+    def intersect(other)
+      begin_at = self.begin >= other.begin ? self.begin : other.begin
+      end_at = self.end <= other.end ? self.end : other.end
+
+      begin_at <= end_at ? self.class.new(begin_at, end_at) : nil
+    end
+
+    alias & intersect
+
+    # Inserts an item after this one and before the next in the sequence. The
+    # new item may not overlap with the two it sits between. A RuntimeError will
+    # be raised if it does.
+    #
+    # If the given object is an Item it will be inserted directly. Otherwise, if
+    # the object responds to #begin and #end, a new Item will be created from
+    # that timespan.
+
+    def append(other)
+      raise RuntimeError unless before? other
+      raise RuntimeError unless last? || after?(self.next)
+
+      super
+    end
+
+    # Inserts an item before this one and after the previous in the sequence.
+    # The new item may not overlap with the two it sits between. A RuntimeError
+    # will be raised if it does.
+    #
+    # If the given object is an Item it will be inserted directly. Otherwise, if
+    # the object responds to #begin and #end, a new Item will be created from
+    # that timespan.
+
+    def prepend(other)
+      raise RuntimeError unless after? other
+      raise RuntimeError unless first? || before?(previous)
+
+      super
+    end
+  end
+end

data/lib/timed/moment.rb

@@ -0,0 +1,109 @@
+# frozen_string_literal: true
+
+module Timed
+  # Timed Moment
+  #
+  # By including this module into any object that responds to #begin and #end,
+  # it can be compared with other moments in time.
+  #
+  # To fully support the Moment module the following must hold:
+  # a) #begin returns a Numeric value
+  # b) #end returns a Numeric value larger than (or equal to) begin
+  # c) a new object can be created by a single range-like argument
+
+  module Moment
+    # Returns the moment duration.
+
+    def duration
+      self.end - self.begin
+    end
+
+    # Returns true if the two moments begin and end on exactly the same time.
+    #
+    # other - object that implements both #begin and #end.
+
+    def ==(other)
+      self.begin == other.begin && self.end == other.end
+    rescue NoMethodError
+      false
+    end
+
+    # Returns true if the moment ends before the other one begins. If given a
+    # numeric value it will be treated like instantaneous moment in time.
+    #
+    # other - object that implements #begin, or a numeric value.
+
+    def before?(other)
+      time = other.is_a?(Numeric) ? other : other.begin
+      self.end <= time
+    end
+
+    # Returns true if the moment begins after the other one ends. If given a
+    # numeric value it will be treated like instantaneous moment in time.
+    #
+    # other - object that implements #end, or a numeric value.
+
+    def after?(other)
+      time = other.is_a?(Numeric) ? other : other.end
+      self.begin >= time
+    end
+
+    # Returns true if the moment overlaps with the other one. If given a
+    # numeric value it will be treated like instantaneous moment in time.
+    #
+    # other - object that implements both #begin and #end, or a numeric value.
+
+    def during?(other)
+      if other.is_a? Numeric
+        other_begin = other_end = other
+      else
+        other_begin, other_end = other.begin, other.end
+      end
+
+      self_begin, self_end = self.begin, self.end
+
+      # Check if either of the two items begins during the
+      # span of the other
+      other_begin <= self_begin && self_begin <= other_end ||
+        self_begin <= other_begin && other_begin <= self_end
+    end
+
+    # Returns a new moment in the intersection
+    #
+    # other - object that implements both #begin and #end.
+
+    def intersect(other)
+      begin_at = self.begin >= other.begin ? self.begin : other.begin
+      end_at = self.end <= other.end ? self.end : other.end
+
+      begin_at <= end_at ? self.class.new(begin_at..end_at) : nil
+    end
+
+    alias & intersect
+
+    # Compare the moments with others.
+    #
+    # Return -1 if the item is before the other, 0 if they overlap and 1 if the
+    # item is after the other.
+
+    # def <=>(other)
+    #   case
+    #   when before?(other) then -1
+    #   when after?(other) then 1
+    #   else 0
+    #   end
+    # end
+
+    # Override the default implementation and provide a more useful
+    # representation of the Timed Moment, including when it begins and ends.
+    #
+    # Example
+    #   moment.inspect # => "ClassName   12.20 -> 15.50"
+    #
+    # Returns a string representation of the object.
+
+    def inspect
+      format '%s %7.2f -> %.2f', self.class.name, self.begin, self.end
+    end
+  end
+end

data/lib/timed/sequence.rb

@@ -0,0 +1,154 @@
+module Timed
+  # Sequence
+  #
+  # This class implements a sequence of Timed Items. Any object that implements
+  # the methods #begin and #end can be push to the sequence. Note that the items
+  # must be inserted in chronological order, or the sequence will raise an
+  # exception.
+  #
+  # Example
+  #   sequence = Timed::Sequence.new
+  #   sequence << 2..3
+  #   sequence.prepend Timed::Item.new 1..2 # Same result as above
+  #
+  # A sequence can also be treated like a Moment and be compared, in time, with
+  # other compatible objects.
+  
+  class Sequence
+    include Moment
+    include Linked::List
+
+    # Returns the time at which the first item in the sequence, and therefore
+    # the sequence as a whole, begins. If the sequence is empty, by convention,
+    # it both begins and ends at time 0, giving it a 0 length.
+
+    def begin
+      empty? ? 0 : first.begin
+    end
+
+    # Returns the time at which the last item in the sequence, and therefore
+    # the sequence as a whole, ends. If the sequence is empty, by convention,
+    # it both begins and ends at time 0, giving it a 0 length.
+
+    def end
+      empty? ? 0 : last.end
+    end
+
+    # Returns the total time made up by the items
+
+    def time
+      each_item.reduce(0) { |a, e| a + e.duration }
+    end
+
+    # Extends the standard behaviour of Linked::List#first with the option of
+    # only returning items that begin after a specified time.
+    #
+    # after - a time after which the returned item(s) must occur.
+    #
+    # Returns one or more items, or nil if there are no items after the given
+    # time.
+
+    def first(n = 1, after: nil, &block)
+      return super(n, &block) unless after
+
+      if include? after
+        first_item_after after, n
+      else
+        super(n) { |item| item.after? after }
+      end
+    end
+
+    # Extends the standard behaviour of Linked::List#last with the option of
+    # only returning items that end before a specified time.
+    #
+    # after - a time after which the returned item(s) must occur.
+    #
+    # Returns one or more items, or nil if there are no items before the given
+    # time.
+
+    def last(n = 1, before: nil, &block)
+      return super(n, &block) unless before
+
+      if include? before
+        last_item_before before, n
+      else
+        super(n) { |item| item.before? before }
+      end
+    end
+
+    # This method takes a second sequence and iterates over each intersection
+    # between the two. If a block is given, the beginning and end of each
+    # intersecting period will be yielded to it. Otherwise an enumerator is
+    # returned.
+    #
+    # other - a sequence, or object that responds to #begin and #end and returns
+    #         a Timed::Item in response to #first
+    #
+    # Returns an enumerator unless a block is given, in which case the number of
+    # intersections is returned.
+
+    def intersections(other)
+      return to_enum __callee__, other unless block_given?
+
+      return unless during? other
+
+      # Sort the first items from each sequence into leading
+      # and trailing by whichever begins first
+      if self.begin <= other.begin
+        item_l, item_t = first, other.first
+      else
+        item_l, item_t = other.first, first
+      end
+
+      count = 0
+
+      loop do
+        # Now there are three posibilities:
+        
+        # 1: The leading item ends before the trailing one
+        #    begins. In this case the items do not intersect
+        #    at all and we do nothing.
+        if item_l.end <= item_t.begin
+
+        # 2: The leading item ends before the trailing one
+        #    ends
+        elsif item_l.end <= item_t.end
+          yield item_t.begin, item_l.end
+          count += 1
+
+        # 3: The leading item ends after the trailing one
+        else
+          yield item_t.begin, item_t.end
+          count += 1
+
+          # Swap leading and trailing
+          item_l, item_t = item_t, item_l
+        end
+
+        # Advance the leading item
+        item_l = item_l.next
+
+        # Swap leading and trailing if needed
+        item_l, item_t = item_t, item_l if item_l.begin > item_t.begin
+      end
+
+      count
+    end
+
+    # Returns a new sequence with items that make up the intersection between
+    # the two sequences.
+
+    def intersect(other)
+      intersections(other)
+        .with_object(self.class.new) { |(b, e), a| a << Item.new(b, e) }
+    end
+
+    alias & intersect
+
+    # More efficient than first calling #intersect and then #time on the result.
+
+    def intersect_time(other)
+      intersections(other).reduce(0) { |a, (b, e)| a + e - b }
+    end
+  end
+end

data/lib/timed/version.rb

@@ -0,0 +1,5 @@
+# frozen_string_literal: true
+
+module Timed
+  VERSION = '0.1.0'
+end

data/lib/timed.rb

@@ -0,0 +1,9 @@
+require 'linked'
+require 'timed/version'
+require 'timed/moment'
+require 'timed/item'
+require 'timed/sequence'
+
+module Timed
+  
+end

data/timed.gemspec

@@ -0,0 +1,28 @@
+# coding: utf-8
+lib = File.expand_path('../lib', __FILE__)
+$LOAD_PATH.unshift(lib) unless $LOAD_PATH.include?(lib)
+require 'timed/version'
+
+Gem::Specification.new do |spec|
+  spec.name          = "timed"
+  spec.version       = Timed::VERSION
+  spec.authors       = ["Sebastian Lindberg"]
+  spec.email         = ["seb.lindberg@gmail.com"]
+
+  spec.summary       = %q{Gem for working with timed, ordered items.}
+  #spec.description   = %q{TODO: Write a longer description or delete this line.}
+  spec.homepage      = "https://github.com/seblindberg/ruby-timed"
+  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_dependency "linked", "~> 0.1.3"
+
+  spec.add_development_dependency "bundler", "~> 1.12"
+  spec.add_development_dependency "rake", "~> 10.0"
+  spec.add_development_dependency "minitest", "~> 5.0"
+  spec.add_development_dependency "coveralls", "~> 0.8"
+end

metadata

@@ -0,0 +1,128 @@
+--- !ruby/object:Gem::Specification
+name: timed
+version: !ruby/object:Gem::Version
+  version: 0.1.0
+platform: ruby
+authors:
+- Sebastian Lindberg
+autorequire: 
+bindir: exe
+cert_chain: []
+date: 2016-08-08 00:00:00.000000000 Z
+dependencies:
+- !ruby/object:Gem::Dependency
+  name: linked
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: 0.1.3
+  type: :runtime
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: 0.1.3
+- !ruby/object:Gem::Dependency
+  name: bundler
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: '1.12'
+  type: :development
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: '1.12'
+- !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: '5.0'
+  type: :development
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: '5.0'
+- !ruby/object:Gem::Dependency
+  name: coveralls
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: '0.8'
+  type: :development
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: '0.8'
+description: 
+email:
+- seb.lindberg@gmail.com
+executables: []
+extensions: []
+extra_rdoc_files: []
+files:
+- ".gitignore"
+- ".travis.yml"
+- Gemfile
+- LICENSE.txt
+- README.md
+- Rakefile
+- bin/console
+- bin/setup
+- lib/timed.rb
+- lib/timed/item.rb
+- lib/timed/moment.rb
+- lib/timed/sequence.rb
+- lib/timed/version.rb
+- timed.gemspec
+homepage: https://github.com/seblindberg/ruby-timed
+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.5.1
+signing_key: 
+specification_version: 4
+summary: Gem for working with timed, ordered items.
+test_files: []