turba_chronos 5.2.0

checksums.yaml

@@ -0,0 +1,7 @@
+---
+SHA1:
+  metadata.gz: 045e46b1f23ed3f38ce1781e8f8e97d2598e0f1a
+  data.tar.gz: 0b904b08a2cc996436f7af39acb24cf6dc5783da
+SHA512:
+  metadata.gz: 51a32b800f6074844aa3fec0d365d3d9ea9bedad2365e89bc239bdf6603bc7eab5e74fa06f375f9a009de6cf9dcac45a19987ac31eb7d0e308530270a7e5d89f
+  data.tar.gz: ebc555d435e2082bdf28985f8431c04cb0d17ae07c60a19867ad493c7155995d1789590976ce77ef73202fab2e1e7c2d0c992a28d1bf5762fb8eaf5a8db78b37

data/.gitignore

@@ -0,0 +1,17 @@
+*.gem
+*.rbc
+.bundle
+.config
+.yardoc
+Gemfile.lock
+InstalledFiles
+_yardoc
+coverage
+doc/
+lib/bundler/man
+pkg
+rdoc
+spec/reports
+test/tmp
+test/version_tmp
+tmp

data/.ruby-version

@@ -0,0 +1 @@
+2.3.0

data/Gemfile

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

data/Guardfile

@@ -0,0 +1,6 @@
+guard :rspec, cmd: 'bundle exec rspec' do
+  watch(%r{^spec/.+_spec\.rb$})
+  watch(%r{^lib/.*\.rb$}) { "spec" }
+  watch('spec/spec_helper.rb')  { "spec" }
+end
+

data/LICENSE.txt

@@ -0,0 +1,22 @@
+Copyright (c) 2014 Joffrey JAFFEUX
+
+MIT License
+
+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,68 @@
+# TurbaChronos
+
+TODO: Write a gem description
+
+## Installation
+
+Add this line to your application's Gemfile:
+
+    gem 'turba_chronos'
+
+And then execute:
+
+    $ bundle
+
+Or install it yourself as:
+
+    $ gem install turba_chronos
+
+## Usage
+
+TODO: Write usage instructions here
+
+## Contributing
+
+1. Fork it
+2. Create your feature branch (`git checkout -b my-new-feature`)
+3. Commit your changes (`git commit -am 'Add some feature'`)
+4. Push to the branch (`git push origin my-new-feature`)
+5. Create new Pull Request
+
+
+
+
+
+
+
+
+
+
+
+
+periods_for_days
+
+period_for_day
+
+
+period_1
+period_2
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+

data/Rakefile

@@ -0,0 +1,11 @@
+# require "bundler/gem_tasks"
+
+
+require 'rake/testtask'
+
+Rake::TestTask.new do |task|
+  task.libs << %w(test lib)
+  task.pattern = 'test/test_*.rb'
+end
+
+task :default => :test

data/lib/turba_chronos.rb

@@ -0,0 +1,31 @@
+require 'ostruct'
+require 'active_support/all'
+require 'turba_chronos/core_ext/range'
+require 'turba_chronos/version'
+require 'turba_chronos/timeline'
+require 'turba_chronos/day'
+require 'turba_chronos/periods'
+require 'turba_chronos/period'
+require 'turba_chronos/period_converter'
+require 'turba_chronos/stored_periods'
+require 'turba_chronos/rule'
+
+module TurbaChronos
+  FULL_DAY_TIMERANGE = ['00:00', '23:59']
+
+  def self.load(periods, from, to, timezone = 'Europe/Paris')
+    Time.zone = timezone
+    TurbaChronos.current_numeric_time = Time.zone.now.strftime("%k%M").to_i
+
+    periods = periods.map!(&:with_indifferent_access)
+    @timeline = Timeline.new(periods, Time.parse(from).utc, Time.parse(to).utc)
+  end
+
+  def self.current_numeric_time
+    @current_numeric_time
+  end
+
+  def self.current_numeric_time=(current_numeric_time)
+    @current_numeric_time = current_numeric_time
+  end
+end

data/lib/turba_chronos/core_ext/range.rb

@@ -0,0 +1,5 @@
+class Range
+  def <=>(other)
+    [min.to_i, max.to_i] <=> [other.min.to_i, other.max.to_i]
+  end
+end

data/lib/turba_chronos/day.rb

@@ -0,0 +1,71 @@
+module TurbaChronos
+  class Day
+    attr_reader :beginning_of_day
+    def initialize(beginning_of_day, periods, timeranges_for_days)
+      @beginning_of_day = beginning_of_day.to_time
+      @rules = get_rules_for_day(periods)
+      @timeranges_for_days = timeranges_for_days
+    end
+
+    def date
+      @date ||= @beginning_of_day.to_datetime.iso8601
+    end
+
+    def opened?
+      current_timeframe.level != 6
+    end
+
+    def timeframes
+      @timeframes ||= get_timeframes(:business_timeranges)
+    end
+
+    def current_timeframe
+      get_timeframes(:timeranges).each do |timeframe|
+        return timeframe if timeframe.timerange === TurbaChronos.current_numeric_time
+      end
+
+      range = (Time.now.utc.beginning_of_hour.strftime("%k%M").to_i..Time.now.utc.end_of_hour.strftime("%k%M").to_i)
+      return TempTimerange.new(range, 6)
+    end
+
+    def current_timeframe_index
+      timeframes.map {|x| x.timerange}.index(current_timeframe.timerange)
+    end
+
+    protected
+
+    def get_rules_for_day(periods)
+      periods.each do |period|
+        next if ([@beginning_of_day.yday] & period.yday_array).blank?
+        return period.rules
+      end
+      raise "Didn’t find rules for this day : #{@beginning_of_day}"
+    end
+
+    TempTimerange = Struct.new(:timerange, :level)do
+      def start_time
+        string_time(timerange.min)
+      end
+
+      def end_time
+        string_time(timerange.max)
+      end
+
+      def string_time(numeric_time)
+        numeric_time.to_s.rjust(4, '0').insert(2, ':')
+      end
+    end
+    def get_timeframes(type)
+      timeframes = []
+      @timeranges_for_days[type].each_with_index do |timerange, index|
+        @rules.each do |rule|
+          if rule.start_time.integer <= timerange.min && rule.end_time.integer >= timerange.max
+            level = rule.wdays[@beginning_of_day.to_datetime.cwday - 1]
+            timeframes.push(TempTimerange.new(timerange, level))
+          end
+        end
+      end
+      timeframes
+    end
+  end
+end

data/lib/turba_chronos/period.rb

@@ -0,0 +1,44 @@
+module TurbaChronos
+  class Period
+    attr_accessor :rules
+    attr_accessor :start_date
+    attr_accessor :end_date
+
+    def initialize(from, to, rules)
+      @rules = complete_rules(rules)
+      @start_date = from
+      @end_date = to.month < from.month ? to.next_year : to
+    end
+
+    def distance
+      @distance ||= end_yday - start_yday
+    end
+
+    def timerange
+      @timerange ||= @rules.map {|rule| rule.range.string_time_array}
+    end
+
+    def start_yday
+      @start_yday ||= @start_date.yday
+    end
+
+    def end_yday
+      @end_yday ||= @end_date.yday
+    end
+
+    def yday_array
+      @yday_array ||= (start_yday..end_yday).to_a
+    end
+
+    private
+
+    def complete_rules(rules)
+      completed_rules = rules.map {|rule| Rule.new(rule)}
+      ranges = completed_rules.map(&:range)
+      uniq_times = ranges.each_with_object([]) { |r,a| a << r.first << r.last }.uniq.sort
+      completed_rules.prepend(Rule.new([FULL_DAY_TIMERANGE.first, completed_rules.first.start_time.text, *[6]*7], true)) if uniq_times[0] != 0
+      completed_rules.push(Rule.new([completed_rules.last.end_time.text, FULL_DAY_TIMERANGE.last, *[6]*7], true)) if uniq_times[-1] != 2359
+      completed_rules
+    end
+  end
+end

data/lib/turba_chronos/period_converter.rb

@@ -0,0 +1,69 @@
+module TurbaChronos
+  class PeriodConverter
+    Bounds = Struct.new(:from, :to)
+
+    def initialize(dates)
+      raise ArgumentError if dates.empty?
+      @dates = dates
+    end
+
+    def parse
+      return days_parser(*@dates.split(':')) if @dates.include?(':')
+      return day_parser(*@dates.split('/')) if @dates.include?('/')
+      return month_parser(@dates) if month_names.include?(@dates)
+      return months_parser(@dates.split('-')) if @dates.include?('-')
+      return stored_period_parser(@dates)
+      raise ArgumentError
+    end
+
+    private
+
+    def month_names
+      @month_names ||= Date::MONTHNAMES.compact.map(&:downcase)
+    end
+
+    def stored_period_parser(stored_period_name)
+      stored_period_dates = stored_periods.fetch(stored_period_name.to_sym)
+      dates = []
+      stored_period_dates.each do |date|
+        dates.push(day_parser(*date[0].split('/'))) if date.count == 1
+        dates.push(days_parser(*date)) if date.count == 2
+      end
+      dates.flatten
+    end
+
+    def stored_periods
+      @stored_periods ||= TurbaChronos::StoredPeriods.all
+    end
+
+    def days_parser(first_day, second_day)
+      first_day = first_day.split('/')
+      second_day = second_day.split('/')
+      year = Time.now.utc.year
+      first_parsed_day = Time.local(year, first_day[1], first_day[0]).utc
+      second_parsed_day = Time.local(year, second_day[1], second_day[0]).utc
+      if second_parsed_day < first_parsed_day
+        second_parsed_day = second_parsed_day.next_year
+      end
+
+      [Bounds.new(first_parsed_day, second_parsed_day)]
+    end
+
+    def day_parser(day, month)
+      parsed_day = Time.local(Time.now.utc.year, month, day).utc
+      [Bounds.new(parsed_day, parsed_day)]
+    end
+
+    def months_parser(months)
+      from = Time.parse(months[0]).utc
+      to = Time.parse(months[1]).utc.end_of_month
+      raise ArgumentError if from > to
+      [Bounds.new(from, to)]
+    end
+
+    def month_parser(month)
+      parsed_month = Time.parse(month).utc
+      [Bounds.new(parsed_month, parsed_month.end_of_month)]
+    end
+  end
+end

data/lib/turba_chronos/periods.rb

@@ -0,0 +1,43 @@
+module TurbaChronos
+  class Periods
+
+    def initialize(periods)
+      @raw_periods = raw_periods_from_dates(periods)
+    end
+
+    def raw_periods
+      @raw_periods
+    end
+
+    def complete
+      start_year = Time.now.utc.beginning_of_year
+      end_year = Time.now.utc.end_of_year
+
+      @raw_periods.map! do |period|
+        if period[1].year > period[0].year
+          end_date = Time.local(Time.now.utc.year, period[1].month, period[1].day).utc
+          [
+            Period.new(start_year, end_date, period[2]),
+            Period.new(period[0], end_year, period[2])
+          ]
+        else
+          [Period.new(period[0], period[1], period[2])]
+        end
+      end.flatten!.sort_by!(&:distance)
+    end
+
+    private
+
+    def raw_periods_from_dates(periods)
+      raw_periods = []
+      periods.each do |period|
+        period[:dates].each do |dates|
+          PeriodConverter.new(dates).parse.each do |date|
+            raw_periods.push([date.from, date.to, period[:rules]])
+          end
+        end
+      end
+      raw_periods
+    end
+  end
+end

data/lib/turba_chronos/rule.rb

@@ -0,0 +1,52 @@
+module TurbaChronos
+  class Rule
+    attr_accessor :start_time
+    attr_accessor :end_time
+    attr_accessor :range
+    attr_accessor :business_hours
+
+    def initialize(rule, business_hours=false)
+      @business_hours = business_hours
+      if rule.is_a?(Array)
+        @wdays = rule[2..-2]
+        self.start_time = rule[0]
+        self.end_time = rule[1]
+      else
+        @wdays = [rule[:mo], rule[:tu], rule[:we], rule[:th], rule[:fr], rule[:sa], rule[:su]]
+        self.start_time = rule[:s]
+        self.end_time = rule[:e]
+      end
+    end
+
+    def min
+      range.min
+    end
+
+    def max
+      range.max
+    end
+
+    def start_time=(start_time)
+      @start_time = text_time_to_hash(start_time)
+    end
+
+    def end_time=(end_time)
+      @end_time = text_time_to_hash(end_time)
+    end
+
+    def range
+      (start_time.integer..end_time.integer)
+    end
+
+    def wdays
+      @cachewdays ||= @wdays.map(&:to_i)
+    end
+
+    private
+
+    TextTime = Struct.new(:text, :integer)
+    def text_time_to_hash(text_time)
+      TextTime.new(text_time, text_time.gsub(':', '').to_i)
+    end
+  end
+end