weesked 0.0.2

checksums.yaml

@@ -0,0 +1,7 @@
+---
+SHA1:
+  metadata.gz: d713ba18b65104cb45d0b4b44940399164fa1b31
+  data.tar.gz: 11d2fa26b7744f569caeb78f00f341d31d51d0fe
+SHA512:
+  metadata.gz: 2ebfcab19081a08c2f85dba70d7c7abff2db357fb7d94fed6d7eb7b948a9073b30860428e788960504aadea0046c5aa1df085fa5fb05b1938f9052615e4d0cd5
+  data.tar.gz: ed4c59d6b925a01285a9b79c4eebe48601fedc46e3d9f8ee15ba87f54128a7003aedb9b148d0499ec24b43639065446930e5fcd3adcf72db9ff17ce23f065efb

data/.gitignore

@@ -0,0 +1,14 @@
+/.bundle/
+/.yardoc
+/Gemfile.lock
+/_yardoc/
+/coverage/
+/doc/
+/pkg/
+/spec/reports/
+/tmp/
+*.bundle
+*.so
+*.o
+*.a
+mkmf.log

data/.travis.yml

@@ -0,0 +1,2 @@
+rvm:
+  - 2.1.2

data/Gemfile

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

data/LICENSE.txt

@@ -0,0 +1,22 @@
+Copyright (c) 2014 Igor Davydov
+
+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,137 @@
+[![Build Status](https://travis-ci.org/div/weesked.svg?branch=master)](https://travis-ci.org/div/weesked)
+
+# Weesked
+
+Simple weekely schedule based on redis sets
+
+## Installation
+
+Add this line to your application's Gemfile:
+
+```ruby
+gem 'weesked'
+```
+
+And then execute:
+
+    $ bundle
+
+Or install it yourself as:
+
+    $ gem install weesked
+
+## Setup
+
+  Weesked need Redis.current to return your redis instance
+
+## Usage
+
+Let's say that we run some small buisness, we've got several employees which provide some service to our customers. Customers book appointments with our employees. But each employee has her personal week schedule. Some work in the morning, some on weekends etc. So you want to know if this employee is availiable on tuesday at 18.00. We need to check his appointments if he is free at that time, and also we need to check his schedule if he is even availiable on that day. Figuring out appointments is easy - we've got postgres ranges for that. But the weekly schedule is a bit trickier. We could use the same ranges approach to make availibility schedule for the comming weeks, but we'll have to maintain some process to keep this shcedule updated and so on. Other option is to use some scheduling lib like ice_cube. But you wont be able to query all your employees availiability easely.
+
+Here comes weesked - redis weekly scheduler. Schedule is an array of redis sets, each list corresponds to time period in some incremets let's say an hour for now. So our week consists of 24*7=168 sets. We add our employee to a list to mark that she's not availiable at that time.
+
+```ruby
+class Employee
+  include Weesked::Schedule
+
+  def self.weesked_schedule_key
+    "weesked:#{class_name.downcase}"
+    # by default each class has it's own schedule
+    # you can set same key for different classes to share same schedule
+  end
+
+  def id
+    # rails got that for you
+  end
+
+  def weesked_key
+    "#{class.class_name.downcase}:#{id}"
+    # that's defefault - fill free to override
+  end
+
+end
+```
+
+Including Weesked::Schedule module gives you the folowing:
+
+```ruby
+employee = Employee.new
+
+employee.schedule
+=> {monday: [1, 2, 5, 6, 9], tuesday: [0, 18, 25], ...}
+
+employee.schedule = {monday: [1, 2, 5, 6, 9], tuesday: [0, 18, 25], ...}
+=> {monday: [1, 2, 5, 6, 9], tuesday: [0, 18, 25], ...}
+
+employee.availiable? Time.now
+=> true
+
+Employee.availiable Time.now
+=> [1, 3, 18]
+# employee ids
+
+Employee.availiable 10.hours.from_now..12.hours.from_now
+=> [3, 12]
+```
+
+So if we're using rails with postgres and want to get the employees availiable and without appointments, you might do something like that:
+
+```ruby
+time_range = 10.hours.from_now..12.hours.from_now
+booked_employees = Employee.joins(:appointments).merge(Appointment.booked_on(time_range))
+availiable_employees = Eployee.where id: Employee.availiable(time_range)
+```
+Now you'll have to extract the first from the second to get those which are free at this time range.
+Or you can do combine it in a single query (not sure how to do it in AR) and assign to a scope:
+
+```ruby
+  scope :free, -> (range) {
+    from("
+      (
+        (
+          #{Employee.availiable(range).to_sql}
+        )
+        except
+        (
+          #{Employee.booked_on(range).to_sql}
+        )
+      ) #{Employee.table_name}
+    ")
+  }
+```
+
+## Config
+
+You might want to customize method names and/or time step if you need more granularity in your schedule.
+You coluld throw this in an initializer or just config where ever suits your needs.
+
+```ruby
+Weesked.setup do |config|
+  # ...
+  # Configures the methods needed by weesked
+  config.schedule_method = :schedule
+  config.availiable_method = :availiable
+
+  # Configures the default stuff about days and steps
+  config.time_step = 1.hour
+  config.availiable_days = %w(sunday monday tuesday wednesday thursday friday saturday)
+  config.availiable_steps = (9..18).to_a  # if your step is 1.hour i'ts typical workours
+  config.steps_day_shift = 3  # number of steps if you want 2am on tuesday still be 'on monday'
+  # it's only needed if in you UI you want users to pick availiability on monday: from 18pm to 2am
+  # we make it easier to do so with day_shift
+  # ...
+end
+
+Redis.current = Redis.new(url: '//127.0.0.1:6379/1')
+# but it's better to put redis initialization in it's own initializer
+```
+But keep in mind that .schedule will return indexes of your new steps within a day. So if you set step to 15.minutes you'll have 96 periods in a day [0,95] and so on.
+
+
+## Contributing
+
+1. Fork it ( https://github.com/div/weesked/fork )
+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 a new Pull Request

data/Rakefile

@@ -0,0 +1,14 @@
+require "bundler/gem_tasks"
+
+require 'rake/testtask'
+
+desc 'Default: run unit tests.'
+task default: :test
+
+desc 'Test the weesked gem.'
+Rake::TestTask.new(:test) do |t|
+  t.libs << 'lib'
+  t.libs << 'test'
+  t.pattern = 'test/**/*_test.rb'
+  t.verbose = true
+end

data/lib/weesked/availiability.rb

@@ -0,0 +1,41 @@
+module Weesked
+  module Availiability
+
+    class << self
+      def included(klass)
+        klass.send :include, InstanceMethods
+        klass.extend ClassMethods
+      end
+    end
+
+    module ClassMethods
+
+      def availiability range
+        keys = range_keys range
+        if keys.empty?
+          []
+        else
+          redis.sinter *keys
+        end
+      end
+
+      def range_keys range
+        keys = []
+        day = Day.build range
+        return keys unless day.steps
+        day.steps.each do |step|
+          keys << self.weesked_schedule_key(day.day, step)
+        end
+        keys
+      end
+
+    end
+
+    module InstanceMethods
+      def availiable? range
+        self.class.availiability(range).include?(id.to_s)
+      end
+    end
+
+  end
+end

data/lib/weesked/configuration.rb

@@ -0,0 +1,59 @@
+require File.expand_path('../version', __FILE__)
+
+module Weesked
+  MINUTES_IN_HOUR = 60
+  SECONDS_IN_MINUTE = 60
+  SECONDS_IN_HOUR = MINUTES_IN_HOUR * SECONDS_IN_MINUTE
+  SUNDAY = 0
+  SATURDAY = 6
+
+  module Configuration
+    VALID_OPTIONS_KEYS = [
+      :time_step,
+      :availiable_days,
+      :availiable_steps,
+      :steps_day_shift,
+      # :redis
+    ].freeze
+
+
+    # By default, 1.hour
+    DEFAULT_TIME_STEP = SECONDS_IN_HOUR  # 1.hour
+
+    # By default, the whole week
+    DEFAULT_AVAILIABLE_DAYS = %w(sunday monday tuesday wednesday thursday friday saturday)
+
+    # By default, whole day in hours
+    DEFAULT_AVAILIABLE_STEPS = (0..23).to_a
+
+    # By default, we use astonomical day
+    DEFAULT_STEPS_DAY_SHIFT = 0
+
+    attr_accessor *VALID_OPTIONS_KEYS
+
+    # When this module is extended, set all configuration options to their default values
+    def self.extended(base)
+      base.reset
+    end
+
+    # Convenience method to allow configuration options to be set in a block
+    def configure
+      yield self
+    end
+
+    # Create a hash of options and their values
+    def options
+      VALID_OPTIONS_KEYS.inject({}) do |option, key|
+        option.merge!(key => send(key))
+      end
+    end
+
+    # Reset all configuration options to defaults
+    def reset
+      self.time_step = DEFAULT_TIME_STEP
+      self.availiable_days = DEFAULT_AVAILIABLE_DAYS
+      self.availiable_steps = DEFAULT_AVAILIABLE_STEPS
+      self.steps_day_shift = DEFAULT_STEPS_DAY_SHIFT
+    end
+  end
+end

data/lib/weesked/day.rb

@@ -0,0 +1,25 @@
+module Weesked
+  class WrongDay < StandardError; end
+  class Day
+    attr_reader :day
+
+    def self.build date
+      DayBuilder.new(date).run
+    end
+
+    def initialize(day, steps=[])
+      @steps = steps
+      @day = if day.kind_of?(Integer)
+        Weesked.availiable_days.fetch(day.to_i).to_sym
+      else
+        raise WrongDay unless Weesked.availiable_days.include?(day.to_s)
+        day.to_sym
+      end
+    end
+
+    def steps
+      steps = (Array(@steps)- ['', nil]).map(&:to_i)
+      Weesked.availiable_steps&steps
+    end
+  end
+end

data/lib/weesked/day_builder.rb

@@ -0,0 +1,68 @@
+module Weesked
+
+  class DateNotRecognized < StandardError; end
+  class NotAvailiable < StandardError; end
+
+  class DayBuilder
+
+    def initialize dates
+      @dates = dates
+    end
+
+    def run
+      if dates.kind_of? Range
+        build_from_date_range
+      elsif dates.kind_of? Time
+        build_from_single_date
+      else
+        raise DateNotRecognized
+      end
+    end
+
+    private
+
+      attr_reader :dates
+
+      def build_from_single_date date=dates
+        wd = date.wday
+        time = beginning_of_step date
+        step = step_index time
+        raise NotAvailiable unless Weesked.availiable_steps.include? step
+        if step < Weesked.steps_day_shift
+          if wd == SUNDAY
+            wd = SATURDAY
+          else
+            wd -= 1
+          end
+        end
+        Day.new(wd, step)
+      end
+
+      def build_from_date_range
+        start = build_from_single_date dates.begin
+        ending = build_from_single_date dates.end
+        raise NotAvailiable unless start.day == ending.day
+        i_start = Weesked.availiable_steps.index start.steps.first
+        i_end = Weesked.availiable_steps.index ending.steps.first
+        array = if Weesked.steps_day_shift > 0 && i_start > i_end
+          Weesked.availiable_steps.slice(i_start..-1) + Weesked.availiable_steps.slice(0..i_end)
+        else
+          Weesked.availiable_steps.slice(i_start..i_end)
+        end
+        Day.new start.day, array
+      end
+
+      def beginning_of_step time
+        (seconds_since_midnight(time) / Weesked.time_step) * Weesked.time_step
+      end
+
+      def step_index seconds
+        seconds / Weesked.time_step
+      end
+
+      def seconds_since_midnight time
+        time.hour * SECONDS_IN_HOUR + time.min * SECONDS_IN_MINUTE + time.sec
+      end
+  end
+
+end

data/lib/weesked/offset_handler.rb

@@ -0,0 +1,53 @@
+module Weesked
+  class OffsetHandler
+
+    def initialize(ary = [], offset = 0, length = 24)
+      @ary = ary.sort
+      @offset = offset
+      @length = length
+    end
+
+    def to_a
+      return ary if ary.length == 0 || offset == 0
+      ary.push(ary.shift(offset)).flatten
+    end
+
+    def to_range
+      to_a.inject([]) do |spans, n|
+        if start_new_range? spans, n
+          spans + [n..n]
+        else
+          spans[0..-2] + [spans.last.first..n]
+        end
+      end
+    end
+
+    private
+
+      attr_reader :ary, :offset, :length
+
+      def start_new_range? spans, current
+        return true if spans.empty?
+        previous = spans.last.last
+        return true unless consecutive?(previous, current) || consecutive_with_offset?(previous, current)
+      end
+
+      def max? n
+        n == max
+      end
+
+      def max
+        length - 1
+      end
+
+      def consecutive_with_offset? x, y
+        x % max == y && max?(x)
+      end
+
+      def consecutive? x, y
+        x == y - 1
+      end
+
+  end
+
+end

data/lib/weesked/schedule.rb

@@ -0,0 +1,122 @@
+module Weesked
+  module Schedule
+
+    class NotConnected < StandardError; end
+    class NilObjectId  < StandardError; end
+
+    class << self
+      def redis=(conn)
+        @redis = conn
+      end
+
+      def redis
+        @redis || $redis || Redis.current ||
+          raise(NotConnected, "Redis not set to a Redis.new connection")
+      end
+
+      def included(klass)
+        klass.instance_variable_set('@redis', nil)
+        klass.send :include, InstanceMethods
+        klass.extend ClassMethods
+      end
+    end
+
+    module ClassMethods
+      attr_writer :redis
+      def redis
+        @redis || Schedule.redis
+      end
+
+      def redis_prefix=(redis_prefix) @redis_prefix = redis_prefix end
+      def redis_prefix(klass = self)
+        @redis_prefix ||= klass.name.to_s.
+          sub(%r{(.*::)}, '').
+          gsub(/([A-Z]+)([A-Z][a-z])/,'\1_\2').
+          gsub(/([a-z\d])([A-Z])/,'\1_\2').
+          downcase
+      end
+
+      def weesked_schedule_key(day, step)
+        "weesked:availiability:#{self.name.downcase}:#{day}:#{step}"
+      end
+
+      def availiable date
+      end
+
+      def reset_schedule
+        redis.multi do
+          Weesked.availiable_days.each do |day|
+            Weesked.availiable_steps.each do |step|
+              redis.del weesked_schedule_key(day, step)
+            end
+          end
+        end
+      end
+
+    end
+
+    module InstanceMethods
+      def redis
+        self.class.redis
+      end
+
+      def schedule=(availiability_hash)
+        update_schedule_for_instance availiability_hash
+        update_schedule_for_class
+      end
+
+      def schedule(range=false)
+        return get_schedule unless range
+        Hash[get_schedule.map {|k,v| [k, OffsetHandler.new(v, Weesked.steps_day_shift, 24).to_range] }]
+      end
+
+      def availiable? date
+      end
+
+      def weesked_key(day)
+        raise NilDay unless day
+        if id.nil?
+          raise NilObjectId,
+            "Weesked schedule on class #{self.class.name} with nil id (unsaved record?) [object_id=#{object_id}]"
+        end
+        day = Day.new(day).day
+        "weesked:#{self.class.name.downcase}:#{id}:#{day}"
+      end
+
+      private
+
+        def update_schedule_for_class
+          sch = schedule
+          redis.multi do
+            Weesked.availiable_days.each do |day|
+              Weesked.availiable_steps.each do |step|
+                if sch[day.to_sym].include?(step)
+                  redis.sadd self.class.weesked_schedule_key(day, step), id
+                else
+                  redis.srem self.class.weesked_schedule_key(day, step), id
+                end
+              end
+            end
+          end
+        end
+
+        def update_schedule_for_instance hash
+          redis.multi do
+            Weesked.availiable_days.each do |d|
+              redis.del weesked_key(d)
+              steps = hash.fetch d.to_sym
+              day = Day.new d, steps
+              redis.sadd(weesked_key(d), day.steps) if day.steps.any?
+            end
+          end
+        end
+
+        def get_schedule
+          Weesked.availiable_days.each_with_object(Hash.new) do |day, h|
+            h[day.to_sym] = redis.smembers(weesked_key(day)).map(&:to_i)
+          end
+        end
+
+    end
+  end
+end

data/lib/weesked/version.rb

@@ -0,0 +1,3 @@
+module Weesked
+  VERSION = "0.0.2"
+end

data/lib/weesked.rb

@@ -0,0 +1,10 @@
+require File.expand_path('../weesked/configuration', __FILE__)
+require File.expand_path('../weesked/schedule', __FILE__)
+require File.expand_path('../weesked/day', __FILE__)
+require File.expand_path('../weesked/day_builder', __FILE__)
+require File.expand_path('../weesked/availiability', __FILE__)
+require File.expand_path('../weesked/offset_handler', __FILE__)
+
+module Weesked
+  extend Configuration
+end

data/test/test_helper.rb

@@ -0,0 +1,46 @@
+require 'weesked'
+require 'minitest'
+require 'minitest/autorun'
+require 'minitest/spec'
+require 'fakeredis'
+
+
+MONDAY_SUNDAY_12_14 = {
+  sunday: [ '12', '13', '14' ],
+  monday: [ '12', '13', '14' ],
+  tuesday: [ '12', '13', '14' ],
+  wednesday: [ '12', '13', '14' ],
+  thursday: [ '12', '13', '14' ],
+  friday: [ '12', '13', '14' ],
+  saturday: [ '12', '13', '14' ],
+}.freeze
+
+EMPTY_AVAIL = {
+  monday: [ ],
+  tuesday: [ ],
+  wednesday: [ ],
+  thursday: [ ],
+  friday: [ ],
+  saturday: [ ],
+  sunday: [ ]
+}
+
+MONDAY_TUESDAY_12_14 = {
+  monday: [ '12', '13', '14' ],
+  tuesday: [ '12', '13', '14' ],
+  wednesday: [  ],
+  thursday: [  ],
+  friday: [  ],
+  saturday: [  ],
+  sunday: [  ]
+}
+
+TUESDAY_12_14 = {
+  monday: [  ],
+  tuesday: [ '12', '13', '14' ],
+  wednesday: [ ],
+  thursday: [ ],
+  friday: [ ],
+  saturday: [ ],
+  sunday: [ ]
+}

data/test/weesked/availiability_test.rb

@@ -0,0 +1,155 @@
+require File.expand_path("../../test_helper", __FILE__)
+
+class Myclass
+  attr_accessor :id
+  include Weesked::Schedule
+  include Weesked::Availiability
+  def initialize(id) @id=id; end
+end
+
+module Weesked
+  describe Availiability do
+
+    let(:sitter1) { Myclass.new 13}
+    let(:sitter2) { Myclass.new 18}
+
+    let(:s1) {
+      MONDAY_TUESDAY_12_14.dup
+    }
+
+    let(:s2) {
+      TUESDAY_12_14.dup
+    }
+
+    let(:empty) {
+      EMPTY_AVAIL.dup
+    }
+
+    subject { Myclass.availiability(date_range) }
+    let(:start_at) { 11 }
+    let(:end_at) { 15 }
+    let(:monday_range) { Time.local(2020, 'jan', 6, start_at)..Time.local(2020, 'jan', 6, end_at, 34) }
+    let(:tuesday_range) { Time.local(2020, 'jan', 7, start_at)..Time.local(2020, 'jan', 7, end_at, 34) }
+    let(:date_range) { monday_range }
+
+    before do
+      Myclass.reset_schedule
+      sitter1.schedule = s1
+      sitter2.schedule = s2
+    end
+
+    describe '.availibility' do
+
+      describe 'single sitter' do
+
+        describe 'no intersection' do
+          let(:start_at) { 15 }
+          let(:end_at) { 18 }
+          it 'empty array' do
+            subject.must_equal Set.new
+          end
+        end
+
+        describe 'partial intersection' do
+          let(:start_at) { 14 }
+          let(:end_at) { 15 }
+          it 'empty array' do
+            subject.must_equal Set.new
+          end
+        end
+
+        describe 'date_range broader than availibility' do
+          let(:start_at) { 10 }
+          let(:end_at) { 22 }
+          it 'empty array' do
+            subject.must_equal Set.new
+          end
+        end
+
+        describe 'exact intersection' do
+          let(:start_at) { 12 }
+          let(:end_at) { 14 }
+          it 'sitter id' do
+            subject.must_equal [ sitter1.id.to_s ]
+          end
+        end
+
+        describe 'date_range narrower than availibility' do
+          let(:start_at) { 12 }
+          let(:end_at) { 13 }
+          it 'sitter id' do
+            subject.must_equal [ sitter1.id.to_s ]
+          end
+        end
+
+      end
+
+      describe 'multiple sitters' do
+
+        let(:date_range) { tuesday_range }
+
+        describe 'no intersection' do
+          let(:start_at) { 15 }
+          let(:end_at) { 18 }
+          it 'empty array' do
+            subject.must_equal Set.new
+          end
+        end
+
+        describe 'partial intersection' do
+          let(:start_at) { 14 }
+          let(:end_at) { 15 }
+          it 'empty array' do
+            subject.must_equal Set.new
+          end
+        end
+
+        describe 'date_range broader than availibility' do
+          let(:start_at) { 10 }
+          let(:end_at) { 22 }
+          it 'empty array' do
+            subject.must_equal Set.new
+          end
+        end
+
+        describe 'exact intersection' do
+          let(:start_at) { 12 }
+          let(:end_at) { 14 }
+          it 'sitter id' do
+            subject.must_equal [ sitter1.id.to_s, sitter2.id.to_s ]
+          end
+        end
+
+        describe 'date_range narrower than availibility' do
+          let(:start_at) { 12 }
+          let(:end_at) { 13 }
+          it 'sitter id' do
+            subject.must_equal [ sitter1.id.to_s, sitter2.id.to_s ]
+          end
+        end
+
+      end
+
+      describe '.availiable?' do
+        subject { sitter1.availiable?(date_range) }
+
+        describe 'for availiable' do
+          let(:start_at) { 12 }
+          let(:end_at) { 13 }
+          it 'true' do
+            subject.must_equal true
+          end
+        end
+
+        describe 'for unavailiable' do
+          let(:start_at) { 18 }
+          let(:end_at) { 19 }
+          it 'false' do
+            subject.must_equal false
+          end
+        end
+      end
+
+    end
+  end
+end

data/test/weesked/configuration_test.rb

@@ -0,0 +1,13 @@
+require File.expand_path("../../test_helper", __FILE__)
+
+module Weesked
+  describe Configuration do
+    Configuration::VALID_OPTIONS_KEYS.each do |key|
+      describe ".#{key}" do
+        it 'returns default value' do
+          Weesked.send(key).must_equal Configuration.const_get("DEFAULT_#{key.upcase}")
+        end
+      end
+    end
+  end
+end

data/test/weesked/day_bulder_test.rb

@@ -0,0 +1,98 @@
+require File.expand_path("../../test_helper", __FILE__)
+
+module Weesked
+  describe DayBuilder do
+
+
+    describe '#run' do
+      describe 'converts single datetime to Day' do
+
+
+        let(:dates) {
+          {
+            sunday:     Time.local(2020, 'jan', 5, hour, 17),
+            monday:     Time.local(2020, 'jan', 6, hour, 12),
+            wednesday:  Time.local(2020, 'jan', 8, hour, 13),
+          }
+        }
+
+        describe 'with day hours' do
+          let(:hour) { 14 }
+
+          it 'returns correct day' do
+            dates.each_pair do |day, date|
+              subject = DayBuilder.new(date).run
+              date.wday.must_equal Weesked.availiable_days.index(day.to_s)
+              subject.must_be_instance_of Day
+              subject.day.must_equal day
+              subject.steps.must_equal [ hour ]
+            end
+          end
+
+        end
+
+        describe 'handles unavailiable times' do
+          let(:hour) { 2 }
+          it "works" do
+            Weesked.availiable_steps = [0,1]
+            dates.each_value do |date|
+              -> { DayBuilder.new(date).run }.must_raise NotAvailiable
+            end
+            Weesked.reset
+          end
+        end
+     end
+
+      describe 'converts date range to window' do
+
+        describe 'with day hours' do
+          let(:monday_day_range) { Time.local(2020, 'jan', 6, start_at)..Time.local(2020, 'jan', 6, end_at, 34) }
+          let(:start_at) { 11 }
+          let(:end_at) { 15 }
+          subject { DayBuilder.new(monday_day_range).run }
+          it 'works for monday' do
+            subject.day.must_equal :monday
+            subject.steps.must_equal (start_at..end_at).to_a
+          end
+        end
+
+        describe 'with night hours' do
+          let(:monday_night_range) { Time.local(2020, 'jan', 6, start_at, 12)..Time.local(2020, 'jan', 7, end_at, 34) }
+          let(:start_at) { 22 }
+          let(:end_at) { 1 }
+          subject { DayBuilder.new(monday_night_range).run }
+          before do
+            Weesked.steps_day_shift = 2
+          end
+          it 'works for night' do
+            subject.day.must_equal :monday
+            subject.steps.must_equal [0, 1, 22, 23]
+          end
+          after do
+            Weesked.reset
+          end
+        end
+
+        describe 'with unavailiable hours' do
+          let(:monday_night_range) { Time.local(2020, 'jan', 6, start_at, 12)..Time.local(2020, 'jan', 7, end_at, 34) }
+          let(:start_at) { 1 }
+          let(:end_at) { 4 }
+          subject { DayBuilder.new(monday_night_range).run }
+          it 'works for night' do
+            -> { subject }.must_raise NotAvailiable
+          end
+        end
+
+        describe 'with too long range' do
+          let(:monday_night_range) { Time.local(2020, 'jan', 6, start_at, 12)..Time.local(2020, 'jan', 10, end_at, 34) }
+          let(:start_at) { 22 }
+          let(:end_at) { 1 }
+          subject { DayBuilder.new(monday_night_range).run }
+          it 'works for night' do
+            -> { subject }.must_raise NotAvailiable
+          end
+        end
+      end
+    end
+  end
+end

data/test/weesked/day_test.rb

@@ -0,0 +1,86 @@
+require File.expand_path("../../test_helper", __FILE__)
+
+module Weesked
+  describe Day do
+
+    subject { Day.new day, steps}
+    let(:steps) { [18, 19] }
+    let(:day) { :monday }
+
+    describe '.steps' do
+
+      describe 'can be initialized with' do
+        describe 'single int' do
+          let(:steps) { 22 }
+          it 'works' do
+            subject.steps.must_equal [22]
+          end
+        end
+
+        describe'single literal' do
+          let(:steps) { '22' }
+          it 'works' do
+            subject.steps.must_equal [22]
+          end
+        end
+
+        describe'array of ints' do
+          let(:steps) { [22, 23] }
+          it 'works' do
+            subject.steps.must_equal [22, 23]
+          end
+        end
+
+        describe'array of literals' do
+          let(:steps) { ['22', '23'] }
+          it 'works' do
+            subject.steps.must_equal [22, 23]
+          end
+        end
+      end
+
+      describe 'unavailiable steps' do
+        let(:steps) { [22, 23, 24, 25, 26] }
+        it 'skips' do
+          subject.steps.must_equal [22, 23]
+        end
+      end
+
+    end
+
+    describe '.day' do
+
+      describe 'can be initialized with' do
+        describe 'single int' do
+          let(:day) { 1 }
+          it 'works' do
+            subject.day.must_equal :monday
+          end
+        end
+
+        describe 'day name as string' do
+          let(:day) { 'monday' }
+          it 'works' do
+            subject.day.must_equal :monday
+          end
+        end
+
+        describe 'day name as symbol' do
+          let(:day) { :monday }
+          it 'works' do
+            subject.day.must_equal :monday
+          end
+        end
+      end
+
+      describe 'unavailiable day' do
+        let(:day) { :monday123 }
+        it 'raises' do
+          -> { subject }.must_raise WrongDay
+        end
+      end
+    end
+
+
+  end
+end

data/test/weesked/offset_handler_spec.rb

@@ -0,0 +1,39 @@
+require File.expand_path("../../test_helper", __FILE__)
+
+module Weesked
+  describe OffsetHandler do
+
+    let(:input)    { [0, 1, 13, 14, 15, 21, 22, 23] }
+    let(:input2)   { [1, 2, 3, 13, 14, 15, 21, 22, 23] }
+    let(:offset)   { 2 }
+    let(:offset2)  { 3 }
+
+    describe '#offset' do
+      let(:output)  { [13, 14, 15, 21, 22, 23, 0, 1] }
+      let(:output2) { [13, 14, 15, 21, 22, 23, 1, 2, 3] }
+      subject { OffsetHandler.new(input, offset).to_a }
+      it 'returns same array if input empty or offset in zero' do
+        OffsetHandler.new.to_a.must_equal []
+        OffsetHandler.new(input).to_a.must_equal input
+      end
+      it 'returns array with offset' do
+        subject.must_equal output
+      end
+      it 'returns array with offset' do
+        OffsetHandler.new(input2, offset2).to_a.must_equal output2
+      end
+    end
+
+    describe '#to_range' do
+      let(:output)  { [13..15, 21..1] }
+      let(:output2)  { [13..15, 21..23, 1..3] }
+      subject { OffsetHandler.new(input, offset).to_range }
+      it 'returns array with ranges' do
+        subject.must_equal output
+      end
+      it 'returns array with ranges' do
+        (OffsetHandler.new(input2, offset2).to_range).must_equal output2
+      end
+    end
+  end
+end

data/test/weesked/schedule_test.rb

@@ -0,0 +1,87 @@
+require File.expand_path("../../test_helper", __FILE__)
+
+class MyClass
+  include Weesked::Schedule
+  def id
+    1
+  end
+end
+
+module Weesked
+  describe Schedule do
+
+    before do
+      MyClass.redis = Redis.new
+    end
+
+    subject { MyClass.new }
+
+    let(:availiability) {
+      MONDAY_SUNDAY_12_14.dup
+    }
+
+    let(:availiability_int) {
+      availiability.each_with_object(Hash.new) do |k, h|
+        h[k.first] = Array(k.last).map(&:to_i).sort.reverse
+      end
+    }
+
+    it '#redis' do
+      MyClass.redis = '123'
+      subject.redis.must_equal '123'
+    end
+
+    it '#weesked_schedule_key' do
+      MyClass.weesked_schedule_key(:monday, 10).must_equal 'weesked:availiability:myclass:monday:10'
+    end
+
+    it 'has key' do
+      subject.weesked_key(:monday).must_equal 'weesked:myclass:1:monday'
+    end
+
+    describe '.schedule=' do
+
+      describe 'with date hash' do
+
+        it 'saves to redis with strings' do
+          subject.schedule = availiability
+          Redis.current.smembers(subject.weesked_key(:monday)).sort.must_equal availiability[:monday].map(&:to_s)
+        end
+
+        it 'saves to redis with empty array' do
+          availiability[:monday] = []
+          subject.schedule = availiability
+          Redis.current.smembers(subject.weesked_key(:monday)).sort.must_equal availiability[:monday].map(&:to_s)
+        end
+
+        it 'clears before save' do
+          subject.schedule = availiability
+          availiability[:monday] = [10]
+          subject.schedule = availiability
+          Redis.current.smembers(subject.weesked_key(:monday)).sort.must_equal availiability[:monday].map(&:to_s)
+        end
+
+        it 'handles empty string' do
+          availiability[:monday] = ''
+          subject.schedule = availiability
+          Redis.current.smembers(subject.weesked_key(:monday)).sort.must_equal []
+        end
+
+        it 'saves to redis with ints' do
+          subject.schedule = availiability_int
+          Redis.current.smembers(subject.weesked_key(:monday)).sort.must_equal availiability[:monday].map(&:to_s)
+        end
+      end
+    end
+
+    describe '.schedule' do
+
+      it 'gets hash' do
+        subject.schedule = availiability
+        subject.schedule.must_equal availiability_int
+      end
+
+    end
+
+  end
+end

data/test/weesked_test.rb

@@ -0,0 +1,7 @@
+require File.expand_path("../test_helper", __FILE__)
+
+describe Weesked do
+  it "is valid" do
+    Weesked.must_be_kind_of Module
+  end
+end

data/weesked.gemspec

@@ -0,0 +1,25 @@
+# coding: utf-8
+lib = File.expand_path('../lib', __FILE__)
+$LOAD_PATH.unshift(lib) unless $LOAD_PATH.include?(lib)
+require 'weesked/version'
+
+Gem::Specification.new do |spec|
+  spec.name          = "weesked"
+  spec.version       = Weesked::VERSION
+  spec.authors       = ["Igor Davydov"]
+  spec.email         = ["iskiche@gmail.com"]
+  spec.summary       = %q{Simple availialibility schedlule based on Redis lists}
+  spec.description   = %q{Each time step has its redis list of booked objects}
+  spec.homepage      = ""
+  spec.license       = "MIT"
+
+  spec.files         = `git ls-files -z`.split("\x0")
+  spec.executables   = spec.files.grep(%r{^bin/}) { |f| File.basename(f) }
+  spec.test_files    = spec.files.grep(%r{^(test|spec|features)/})
+  spec.require_paths = ["lib"]
+
+  spec.add_development_dependency "bundler", "~> 1.6"
+  spec.add_development_dependency "rake", "~> 10.0"
+  spec.add_development_dependency "minitest", "~> 5"
+  spec.add_development_dependency "fakeredis", "~> 0.3"
+end

metadata

@@ -0,0 +1,131 @@
+--- !ruby/object:Gem::Specification
+name: weesked
+version: !ruby/object:Gem::Version
+  version: 0.0.2
+platform: ruby
+authors:
+- Igor Davydov
+autorequire: 
+bindir: bin
+cert_chain: []
+date: 2014-12-10 00:00:00.000000000 Z
+dependencies:
+- !ruby/object:Gem::Dependency
+  name: bundler
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: '1.6'
+  type: :development
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: '1.6'
+- !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'
+  type: :development
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: '5'
+- !ruby/object:Gem::Dependency
+  name: fakeredis
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: '0.3'
+  type: :development
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: '0.3'
+description: Each time step has its redis list of booked objects
+email:
+- iskiche@gmail.com
+executables: []
+extensions: []
+extra_rdoc_files: []
+files:
+- ".gitignore"
+- ".travis.yml"
+- Gemfile
+- LICENSE.txt
+- README.md
+- Rakefile
+- lib/weesked.rb
+- lib/weesked/availiability.rb
+- lib/weesked/configuration.rb
+- lib/weesked/day.rb
+- lib/weesked/day_builder.rb
+- lib/weesked/offset_handler.rb
+- lib/weesked/schedule.rb
+- lib/weesked/version.rb
+- test/test_helper.rb
+- test/weesked/availiability_test.rb
+- test/weesked/configuration_test.rb
+- test/weesked/day_bulder_test.rb
+- test/weesked/day_test.rb
+- test/weesked/offset_handler_spec.rb
+- test/weesked/schedule_test.rb
+- test/weesked_test.rb
+- weesked.gemspec
+homepage: ''
+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.4
+signing_key: 
+specification_version: 4
+summary: Simple availialibility schedlule based on Redis lists
+test_files:
+- test/test_helper.rb
+- test/weesked/availiability_test.rb
+- test/weesked/configuration_test.rb
+- test/weesked/day_bulder_test.rb
+- test/weesked/day_test.rb
+- test/weesked/offset_handler_spec.rb
+- test/weesked/schedule_test.rb
+- test/weesked_test.rb