time_pieces 1.0.0

checksums.yaml

@@ -0,0 +1,7 @@
+---
+SHA1:
+  metadata.gz: 8dff9eff972d3afdaf7b581ed5a1523d6322ca96
+  data.tar.gz: 04cd28f75eadad0881be6e136b6f1ce30ba58348
+SHA512:
+  metadata.gz: 271412cccca93941de02b4de970b7ac9caddc49a9f2356fea5bec374ae81d2433f79f57336f3874bb50595f3e9c122ca4e03e3c929bcca42d10b4ca0784775e6
+  data.tar.gz: 33efeab9c9575ec061703f737ea51bfc814b6a7b42351c5cd81e7e89e71ab99bc9c804097a45718f0ed49fd4e0795f41f4d7f5e5923eb41790bfa49b1d088f9a

data/Gemfile

@@ -0,0 +1,11 @@
+source 'http://rubygems.org'
+gemspec
+#group :test do
+#      gem "activesupport"
+#
+#  gem "rake"
+#  gem "cucumber"
+#end
+
+
+

data/Gemfile.lock

@@ -0,0 +1,50 @@
+PATH
+  remote: .
+  specs:
+    time_pieces (0.2.0)
+      bundler
+
+GEM
+  remote: http://rubygems.org/
+  specs:
+    activesupport (4.2.5.1)
+      i18n (~> 0.7)
+      json (~> 1.7, >= 1.7.7)
+      minitest (~> 5.1)
+      thread_safe (~> 0.3, >= 0.3.4)
+      tzinfo (~> 1.1)
+    builder (3.2.2)
+    cucumber (2.3.2)
+      builder (>= 2.1.2)
+      cucumber-core (~> 1.4.0)
+      cucumber-wire (~> 0.0.1)
+      diff-lcs (>= 1.1.3)
+      gherkin (~> 3.2.0)
+      multi_json (>= 1.7.5, < 2.0)
+      multi_test (>= 0.1.2)
+    cucumber-core (1.4.0)
+      gherkin (~> 3.2.0)
+    cucumber-wire (0.0.1)
+    diff-lcs (1.2.5)
+    gherkin (3.2.0)
+    i18n (0.7.0)
+    json (1.8.3)
+    minitest (5.8.4)
+    multi_json (1.11.2)
+    multi_test (0.1.2)
+    rake (10.5.0)
+    thread_safe (0.3.5)
+    tzinfo (1.2.2)
+      thread_safe (~> 0.1)
+
+PLATFORMS
+  ruby
+
+DEPENDENCIES
+  activesupport (~> 4.2)
+  cucumber (~> 2.3.2)
+  rake (~> 10.5)
+  time_pieces!
+
+BUNDLED WITH
+   1.10.6

data/README.md

@@ -0,0 +1,48 @@
+# TimePieces
+
+This gem is for managing time pieces.  It lets you add and subtract durations to help you with scheduling.  For example if you have a duration (9:00am - 5:00pm) and you subtract the duration (1:00pm - 2:00pm) it will result in a time set with 2 time duration of (9:00am - 1:00pm) and (2:00pm - 5:00pm).  You can also add durations.  To make an object into a duration just use.  You also have to include the method duration_copy which is used when creating new objects, for example when a duration is split.
+```ruby
+include TimePieces::Duration
+
+def duration_copy
+    return self.clone
+end
+
+```
+
+## Installation
+
+Add this line to your application's Gemfile:
+
+```ruby
+gem 'time_pieces'
+```
+
+And then execute:
+
+    $ bundle
+
+Or install it yourself as:
+
+    $ gem install time_pieces
+
+<!---
+## Usage
+
+TODO: Write usage instructions here
+
+## Development
+
+After checking out the repo, run `bin/setup` to install dependencies. 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/riggleg/time_pieces
+
+
+## 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 @@
+require "bundler/gem_tasks"

data/config/cucumber.yml

@@ -0,0 +1,4 @@
+<%
+	std_opts = "--format #{ENV['CUCUMBER_FORMAT'] || 'pretty'} --strict --tags ~@wip"
+%>
+default: <%= std_opts %> features

data/lib/time_pieces/duration.rb

@@ -0,0 +1,131 @@
+module TimePieces
+  module Duration
+    attr_accessor :start_at_seconds, :duration_seconds
+    def end_at_seconds
+      return start_at_seconds + duration_seconds
+    end
+    def end_at_seconds=(new_end_at_seconds)
+      self.duration_seconds = new_end_at_seconds - start_at_seconds
+    end
+    def update_start_seconds_and_end_seconds(new_start_seconds, new_end_seconds)
+      self.start_at_seconds = new_start_seconds
+      self.end_at_seconds = new_end_seconds
+      return self
+    end
+    def left_duration_copy
+      duration_copy
+    end
+    def right_duration_copy
+      duration_copy
+    end
+
+
+    def overlaps_start?(other_td)
+      return true if (start_at_seconds >= other_td.start_at_seconds) && (start_at_seconds < other_td.end_at_seconds)
+      return false
+    end
+    def overlaps_end?(other_td)
+      return true if (end_at_seconds <= other_td.end_at_seconds) && (end_at_seconds > other_td.start_at_seconds)
+      return false
+    end
+    def overlaps_inside?(other_td)
+      return true if (other_td.end_at_seconds > start_at_seconds) && (other_td.end_at_seconds <= end_at_seconds) && (other_td.start_at_seconds >= start_at_seconds) && (other_td.start_at_seconds < end_at_seconds)
+      return false
+    end
+    def overlaps_outside?(other_td)
+      return other_td.overlaps_inside?(self)
+    end
+    def overlaps?(other_td)
+      return true if overlaps_outside?(other_td)
+      return true if overlaps_start?(other_td)
+      return true if overlaps_end?(other_td)
+      return true if overlaps_inside?(other_td)
+      return false
+    end
+    def touches_at_start?(other_td)
+      return true if other_td.end_at_seconds == start_at_seconds
+      return false
+    end
+    def touches_at_end?(other_td)
+      return true if other_td.start_at_seconds == end_at_seconds
+      return false
+    end
+    def touches?(other_td)
+      return (touches_at_start?(other_td) || touches_at_end?(other_td))
+      return false
+    end
+    def <=>(other)
+      start_at_seconds <=> other.start_at_seconds
+    end
+    def +(other_td)
+      ts_ret = TimeSet.new
+      if overlaps?(other_td)
+        if overlaps_start?(other_td) && !overlaps_outside?(other_td)
+          update_start_seconds_and_end_seconds(other_td.start_at_seconds, end_at_seconds)
+          ts_ret << self
+          return ts_ret
+        end
+        if overlaps_end?(other_td) && !overlaps_outside?(other_td)
+          
+          update_start_seconds_and_end_seconds(start_at_seconds, other_td.end_at_seconds)
+          ts_ret << self
+          return ts_ret
+        end
+        if overlaps_inside?(other_td)
+          ts_ret << self
+          return ts_ret
+        end
+        if overlaps_outside?(other_td)
+          ts_ret << other_td
+        end
+        return ts_ret
+      end
+      if touches?(other_td)
+        if touches_at_end?(other_td) && other_td.end_at_seconds > end_at_seconds
+          update_start_seconds_and_end_seconds(start_at_seconds, other_td.end_at_seconds)
+          ts_ret << self
+          return ts_ret
+        end
+        if touches_at_start?(other_td) && other_td.start_at_seconds < start_at_seconds
+          update_start_seconds_and_end_seconds(other_td.start_at_seconds, end_at_seconds)
+          ts_ret << self
+          return ts_ret
+        end
+        return false
+      end
+      ts_ret << self
+      ts_ret << other_td
+      return ts_ret
+    end
+    def -(other_td)
+      ts_ret = TimeSet.new
+      unless overlaps?(other_td)
+        ts_ret << self
+        return ts_ret
+      end
+      if overlaps?(other_td)
+        if overlaps_start?(other_td)
+          update_start_seconds_and_end_seconds(other_td.end_at_seconds, end_at_seconds)
+          ts_ret << self
+          return ts_ret
+        end
+        if overlaps_end?(other_td)
+          puts inspect
+          update_start_seconds_and_end_seconds(start_at_seconds, other_td.start_at_seconds)
+          puts "RUNNING OVERLAPPING END"
+          puts inspect
+          ts_ret << self
+          return ts_ret
+        end
+        if overlaps_inside?(other_td)
+          left_of_break = left_duration_copy.update_start_seconds_and_end_seconds(start_at_seconds, other_td.start_at_seconds)
+          right_of_break = right_duration_copy.update_start_seconds_and_end_seconds(other_td.end_at_seconds, end_at_seconds)
+          ts_ret << left_of_break
+          ts_ret << right_of_break
+        end
+        return ts_ret
+      end
+    end
+
+  end
+end

data/lib/time_pieces/simple_duration.rb

@@ -0,0 +1,30 @@
+module TimePieces
+  class SimpleDuration
+    include TimePieces::Duration
+    #Time is measured as seconds since midnight
+    def start_at=(s_at)
+      self.start_at_seconds = s_at.seconds_since_midnight
+    end
+    def initialize(start_at_seconds, duration_seconds)
+      self.start_at_seconds = start_at_seconds
+      self.duration_seconds = duration_seconds
+    end
+    def self.parse_from_time_string(start_at_str, end_at_str)
+      start_at_seconds = Time.parse(start_at_str).seconds_since_midnight
+      end_at_seconds = Time.parse(end_at_str).seconds_since_midnight
+      return self.new(start_at_seconds, end_at_seconds - start_at_seconds)
+    end
+    def self.new_using_seconds_and_end_at(start_at_seconds, end_at_seconds)
+      return self.new(start_at_seconds, end_at_seconds - start_at_seconds)
+    end
+    def inspect
+      hours_start = start_at_seconds / 60 / 60
+      hours_end = end_at_seconds / 60 / 60
+      duration = duration_seconds / 60 / 60
+      return "TD: #{hours_start} - #{hours_end} time in seconds: #{duration_seconds}"
+    end
+    def bookable_copy
+      return SimpleDuration.new(1,10)
+    end
+  end
+end

data/lib/time_pieces/time_set.rb

@@ -0,0 +1,64 @@
+module TimePieces
+  class TimeSet
+    attr_accessor :time_durations
+    def initialize
+      @time_durations = []
+    end
+    #Adds a new time duration.  Removes invalid time durations.
+    def <<(new_td)
+      if new_td.duration_seconds == 0
+        
+      else
+        new_tds = []
+        has_combined = false
+        time_durations.each do |td|
+          if new_td.overlaps?(td) || new_td.touches?(td)
+            combined_td = td + new_td
+            combined_td.time_durations.each do |td3|
+              new_tds << td3
+            end
+            has_combined = true
+          else
+            new_tds << td
+          end
+        end
+        new_tds << new_td unless has_combined
+        self.time_durations = new_tds
+      end
+      return self
+    end
+    def >>(subtracting_td)
+      new_tds = []
+      time_durations.each do |td|
+        if subtracting_td.overlaps?(td)
+          combined_td = td - subtracting_td
+          combined_td.time_durations.each do |td3|
+            new_tds << td3
+          end
+        else
+          new_tds << td
+        end
+
+      end
+      self.time_durations = new_tds
+      return self
+    end
+    def +(other_ts)
+      ret_ts = TimeSet.new
+      ret_ts.time_durations = time_durations.map{|td| td}
+      other_ts.time_durations.each do |td|
+        ret_ts << td
+      end
+      return ret_ts
+    end
+    def -(other_ts)
+      ret_ts = TimeSet.new
+      ret_ts.time_durations = Array.new(time_durations)
+      other_ts.time_durations.each do |td|
+        ret_ts >> td
+      end
+      return ret_ts
+      
+    end
+  end
+end

data/lib/time_pieces/version.rb

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

data/lib/time_pieces.rb

@@ -0,0 +1,9 @@
+require 'active_support/all'
+#lib = File.expand_path('../lib/', __FILE__)
+lib = File.expand_path('.', __FILE__)
+$LOAD_PATH.unshift(lib) unless $LOAD_PATH.include?(lib)
+require 'time_pieces/version'
+require 'time_pieces/duration'
+
+require 'time_pieces/simple_duration'
+require 'time_pieces/time_set'

data/time_pieces.gemspec

@@ -0,0 +1,41 @@
+# -*- encoding: utf-8 -*-
+lib = File.expand_path('../lib/', __FILE__)
+$LOAD_PATH.unshift(lib) unless $LOAD_PATH.include?(lib)
+require 'time_pieces/version'
+
+Gem::Specification.new do |spec|
+
+  spec.name          = "time_pieces"	
+  spec.version       = TimePieces::VERSION
+  spec.license       = "MIT"  
+  spec.authors     = ["Grant R."]
+  spec.email       = "grant@arsemporium.com"
+  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.homepage    = "http://github.com/riggleg/time_pieces"
+  spec.summary     = "Time based operations."
+  spec.description = "time_pieces is a library to make it easy to add/subtract time from a schedule"
+
+  # s.files            = `git ls-files -- lib/*`.split("\n")
+  #  s.files           += %w[README.md LICENSE.md Changelog.md Capybara.md .yardopts .document]
+  # s.test_files       = []
+  # s.require_path     = "lib"
+
+#  private_key = File.expand_path('~/.gem/rspec-gem-private_key.pem')
+#  if File.exist?(private_key)
+#    s.signing_key = private_key
+#    s.cert_chain = [File.expand_path('~/.gem/rspec-gem-public_cert.pem')]
+#  end
+
+
+#  if RUBY_VERSION <= '1.8.7' && ENV['RAILS_VERSION'] != '3-2-stable'
+#    version_string << '!= 3.2.22.1'
+#  end
+   spec.add_dependency 'bundler'
+  spec.add_development_dependency %q<activesupport>, '~> 4.2'
+
+  spec.add_development_dependency 'rake',     '~> 10.5'
+  spec.add_development_dependency 'cucumber', '~> 2.3.2'
+end

metadata

@@ -0,0 +1,111 @@
+--- !ruby/object:Gem::Specification
+name: time_pieces
+version: !ruby/object:Gem::Version
+  version: 1.0.0
+platform: ruby
+authors:
+- Grant R.
+autorequire: 
+bindir: exe
+cert_chain: []
+date: 2016-02-11 00:00:00.000000000 Z
+dependencies:
+- !ruby/object:Gem::Dependency
+  name: bundler
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - ">="
+      - !ruby/object:Gem::Version
+        version: '0'
+  type: :runtime
+  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: '4.2'
+  type: :development
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: '4.2'
+- !ruby/object:Gem::Dependency
+  name: rake
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: '10.5'
+  type: :development
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: '10.5'
+- !ruby/object:Gem::Dependency
+  name: cucumber
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: 2.3.2
+  type: :development
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: 2.3.2
+description: time_pieces is a library to make it easy to add/subtract time from a
+  schedule
+email: grant@arsemporium.com
+executables: []
+extensions: []
+extra_rdoc_files: []
+files:
+- Gemfile
+- Gemfile.lock
+- README.md
+- Rakefile
+- config/cucumber.yml
+- lib/time_pieces.rb
+- lib/time_pieces/duration.rb
+- lib/time_pieces/simple_duration.rb
+- lib/time_pieces/time_set.rb
+- lib/time_pieces/version.rb
+- time_pieces.gemspec
+homepage: http://github.com/riggleg/time_pieces
+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: Time based operations.
+test_files: []