pacing 0.1.3 → 1.0.0

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA256:
-  metadata.gz: 3c9f1bb20d57079d96b0bf851745a047e274cc2ac91698dafb61ddc34800875d
-  data.tar.gz: b83584cd4d641299955cb4b28666d742e17d6ac90ab0168bdf9898e3b20f7307
+  metadata.gz: a1a8fc6f5350111b6fc551118c17dbd22eb496e7fe961b851b3b0c818ca28074
+  data.tar.gz: 3b19d2df9e4d3fd80d6b66fccf864a19a94ebcfbe337bf91bb7c5a030309694d
 SHA512:
-  metadata.gz: 7f9df40d14c5428d64a4465930a675f803eb428d1ccc0602de23e591fd3225993c8c37b9e3437e1954885cd07584d29c7d447d93e2fda4d9d94df4cae0da60a6
-  data.tar.gz: ed423571438c677b40fde49964c6866fd63a40c763a93c2bcac563f9547c12ad64d5371a4ef705d97f35f2b7594b34dd00b0ee70d5951d29aec1ab05a3b19172
+  metadata.gz: 3e5a7500a4873e8f7748052785fb914ad6b9b3a59c9f80df84a7a836346fe757da050fc81c369bd904184485c06da68757462874a8e25fcfac53b602f2db0f5b
+  data.tar.gz: 30f8e30fee65de76a98bc99b5e14ede8d94801647c3927e4aae2e43b73cc559797cd4f434f0d1c05b3bc4ac42b49d4021386fdbf791916d95eeba962c8123eea

data/README.md

@@ -2,15 +2,16 @@
 
 Pacing is a tool that enables therapists to better manage and track their caseload. It is built for cases where there are therapy frequency limitations that need to be adhered to. For example, in the case of an [IEP (Individualized Education Program)](https://ambiki.com/glossary-concepts/iep), 504 plan, or a Services plan. This gem helps to calculate remaining visits as well as a therapist's current pace to meet visit mandates.
 
-+ 🐇 Ahead of pace
-+ 😁 On pace
-+ 🐢 Behind pace
+- 🐇 Ahead of pace
+- 😁 On pace
+- 🐢 Behind pace
 
 ## Getting started
 
 **Ruby**
 
-*Supports Ruby x.x.x and above*
+_Supports Ruby x.x.x and above_
+
 ```
 gem install pacing
 ```
@@ -18,6 +19,7 @@ gem install pacing
 **Ruby on Rails**
 
 Add this line to your application’s Gemfile:
+
 ```ruby
 gem 'pacing'
 ```
@@ -55,52 +57,69 @@ school_plan = {
   ]
 }
 
-date = '01-22-2022' # string (mm-dd-yyyy)
-non_business_days = ['01-25-2022'] # array of strings (mm-dd-yyyy)
-paced = Pacing::Pacer.new(school_plan: school_plan, date: date, non_business_days: non_business_days)
+date = '04-22-2022' # string (mm-dd-yyyy)
+state = :us_tn
+# default is `:us_tn` possible options :us_fl, :us_la, :us_ct, :us_de, :us_gu, :us_hi, :us_in, :us_ky, :us_nj, :us_nc, :us_nd, :us_pr, :us_tn, :us_ms, :us_id, :us_ar, :us_tx, :us_dc, :us_md, :us_va, :us_vt, :us_ak, :us_ca, :us_me, :us_ma, :us_al, :us_ga, :us_ne, :us_mo, :us_sc, :us_wv, :us_vi, :us_ut, :us_ri, :us_az, :us_co, :us_il, :us_mt, :us_nm, :us_ny, :us_oh, :us_pa, :us_mi, :us_mn, :us_nv, :us_or, :us_sd, :us_wa, :us_wi, :us_wy, :us_ia, :us_ks, :us_nh, :us_ok
+non_business_days = ['04-25-2022'] # array of strings (mm-dd-yyyy)
+summer_holidays = ["05-31-2022", "08-01-2022"] # [start-of-holiday-date, end-of-holiday-date] array of strings (mm-dd-yyyy)
+mode = :liberal # default is :liberal, two possible options :strict, :liberal
+paced = Pacing::Pacer.new(school_plan: school_plan, date: date, non_business_days: non_business_days, mode: :liberal, summer_holidays: summer_holidays, state: state)
 paced.calculate
 
+# Below is the result you will get when in liberal mode
 =begin
-=> {
-    school_plan_services: [
-      {
-        school_plan_type: "IEP",
-        start_date: "01-01-2022",
-        end_date: "01-01-2023",
-        type_of_service: "Language Therapy",
-        frequency: 6,
-        interval: "monthly",
-        time_per_session_in_minutes: 30,
-        completed_visits_for_current_interval: 7,
-        extra_sessions_allowable: 1,
-        interval_for_extra_sessions_allowable: "monthly",
-        pace: 3,
-        reset_date: "01-31-2022",
-        remaining_visits: 0,
-        pace_indicator: "🐇"
-      },
-      {
-        school_plan_type: "IEP",
-        start_date: "01-01-2022",
-        end_date: "01-01-2023",
-        type_of_service: "Physical Therapy",
-        frequency: 6,
-        interval: "monthly",
-        time_per_session_in_minutes: 30,
-        completed_visits_for_current_interval: 7,
-        extra_sessions_allowable: 1,
-        interval_for_extra_sessions_allowable: "monthly",
-        pace: 3,
-        reset_date: "01-31-2022",
-        remaining_visits: 0,
-        pace_indicator: "🐇"
-      }
-    ]
-  }
+=> [
+    {
+      discipline: 'Speech Therapy',
+      remaining_visits: 0,
+      used_visits: 7,
+      expected_visits_at_date: 5,
+      reset_date: '05-01-2022',
+      pace: 2,
+      pace_indicator: "🐇",
+      pace_suggestion: "less than once per week"
+    }, {
+      discipline: 'Physical Therapy',
+      remaining_visits: 0,
+      expected_visits_at_date: 5,
+      used_visits: 7,
+      reset_date: '05-01-2022',
+      pace: 2,
+      pace_indicator: "🐇",
+      pace_suggestion: "less than once per week"
+    }
+  ]
 =end
 
+# Below is the result you will get when in strict mode
+# in strict mode the reset date for intervals of month and week is determined by the start date of the school plan service. e.g the reset date in the 6th month for a start date of "05-11-2022" for an interva of `month` will be "06-11-2022" whereas for `:liberal` mode it will be "06-01-2022"
+=begin
+=> [
+    {
+      discipline: 'Speech Therapy',
+      remaining_visits: 0,
+      used_visits: 7,
+      expected_visits_at_date: 3,
+      reset_date: '05-11-2022',
+      pace: 4,
+      pace_indicator: "🐇",
+      pace_suggestion: "less than once per week"
+    }, {
+      discipline: 'Physical Therapy',
+      remaining_visits: 0,
+      expected_visits_at_date: 3,
+      used_visits: 7,
+      reset_date: '05-11-2022',
+      pace: 4,
+      pace_indicator: "🐇",
+      pace_suggestion: "less than once per week"
+    }
+  ]
+=end
 ```
 
+It is important to note that the `pace` is hugely influenced by the `summer_holidays` period and the `mode` in which it is calculated.
+
 ## Data Types
 
 Pacing accepts input which consists of a school_plan, a date and a non_business_day variable. The school_plan variable is a hash that includes the various school plan services that the client received, the date is a string and the non_business_days variable is an array of dates.
@@ -120,37 +139,36 @@ The following list shows the various variables and what they consist of:
    - `extra_sessions_allowable` is an integer.
    - `interval_for_extra_sessions_allowable` is a string.
 2. Output
-   - `school_plan_type` is a string.
-   - `start_date` is a string.
-   - `end_date` is a string.
-   - `type_of_service` is a string.
-   - `frequency` is an integer.
-   - `interval` is a string.
-   - `time_per_session_in_minutes` is an integer.
-   - `extra_sessions_allowable` is an integer.
-   - `interval_for_extra_sessions_allowable` is a string.
+   - `discipline`: is a string.
+   - `remaining_visits`: is an integer.
+   - `used_visits`: is an integer.
+   - `expected_visits_at_date`: is an integer.
+   - `reset_date`: is a string.
+   - `pace`: is an integer.
+   - `pace_indicator`: is an emoji string.
+   - `pace_suggestion`: is a string.
    - `reset_date` is a string.
    - `pace` is an integer.
    - `pace_indicator` is a string.
 
 ## Terminology
 
-+ **IEP (Individualized Education Program)**: Individualized Education Programs (IEPs) are required by law for every student who receives special education services and are developed on an annual basis. The IEP is an educational document that the school generates. The therapist is bound to the frequency on the IEP, and the insurance companies will not pay for anything above or beyond what is on the IEP. It is a blueprint for a student’s special education experience in a public school. The plan must ensure that the child receives a free appropriate public education, (FAPE).
-+ **504 Plan**: 504 plans are formal plans that schools develop to give kids with disabilities the support they need. That covers any condition that limits daily activities in a major way. These plans prevent discrimination and they protect the rights of kids with disabilities in school. They are covered under Section 504 of the Rehabilitation Act, a civil rights law.
-+ **Services Plan**: A plan paid for by the local school district for students with disabilities who attend private schools. A services plan does not have to ensure a child is provided with FAPE (free appropriate public education). A services plan spells out the special education and related services the LEA will make available to a child. These services are provided at no cost to parents. But the student may not be able to receive these services at the private school. Instead, the LEA can require him to go to a public school for services like speech therapy sessions. [§34 CFR 300.130 through §300.144 of IDEA](https://sites.ed.gov/idea/files/CWD_Enrolled_by_Their_Parents_in_Private_Schools_11-16-06.pdf) is a specific section that describes how services are provided to kids in private school.
+- **IEP (Individualized Education Program)**: Individualized Education Programs (IEPs) are required by law for every student who receives special education services and are developed on an annual basis. The IEP is an educational document that the school generates. The therapist is bound to the frequency on the IEP, and the insurance companies will not pay for anything above or beyond what is on the IEP. It is a blueprint for a student’s special education experience in a public school. The plan must ensure that the child receives a free appropriate public education, (FAPE).
+- **504 Plan**: 504 plans are formal plans that schools develop to give kids with disabilities the support they need. That covers any condition that limits daily activities in a major way. These plans prevent discrimination and they protect the rights of kids with disabilities in school. They are covered under Section 504 of the Rehabilitation Act, a civil rights law.
+- **Services Plan**: A plan paid for by the local school district for students with disabilities who attend private schools. A services plan does not have to ensure a child is provided with FAPE (free appropriate public education). A services plan spells out the special education and related services the LEA will make available to a child. These services are provided at no cost to parents. But the student may not be able to receive these services at the private school. Instead, the LEA can require him to go to a public school for services like speech therapy sessions. [§34 CFR 300.130 through §300.144 of IDEA](https://sites.ed.gov/idea/files/CWD_Enrolled_by_Their_Parents_in_Private_Schools_11-16-06.pdf) is a specific section that describes how services are provided to kids in private school.
 
 ## Testing
 
-+ `bundle exec rspec`
+- `bundle exec rspec`
 
 ## Contributing
 
 Everyone is encouraged to help improve this project. Here are a few ways you can help:
 
-+ [Report bugs](https://github.com/Ambiki/pacing/issues)
-+ Fix bugs and [submit pull requests](https://github.com/Ambiki/pacing/pulls)
-+ Write, clarify, or fix documentation
-+ Suggest or add new features
+- [Report bugs](https://github.com/Ambiki/pacing/issues)
+- Fix bugs and [submit pull requests](https://github.com/Ambiki/pacing/pulls)
+- Write, clarify, or fix documentation
+- Suggest or add new features
 
 To get started with development:
 
@@ -188,4 +206,4 @@ 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.
+WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE SOFTWARE.

data/lib/pacing/pacer.rb

@@ -2,21 +2,24 @@ require 'date'
 require 'holidays'
 
 module Pacing
+  # two modes(strict: use start dates strictly in calculating pacing)
   class Pacer
     COMMON_YEAR_DAYS_IN_MONTH = [nil, 31, 28, 31, 30, 31, 30, 31, 31, 30, 31, 30, 31]
-    attr_reader :school_plan, :date, :non_business_days, :state
+    attr_reader :school_plan, :date, :non_business_days, :state, :mode, :interval, :summer_holidays
 
-    def initialize(school_plan:, date:, non_business_days:, state: :us_tn)
+    def initialize(school_plan:, date:, non_business_days:, state: :us_tn, mode: :liberal, summer_holidays: [])
       @school_plan = school_plan
       @non_business_days = non_business_days
       @date = date
       @state = state
+      @mode = [:strict, :liberal].include?(mode) ? mode : :liberal
 
       raise ArgumentError.new("You must pass in at least one school plan") if @school_plan.nil?
       raise TypeError.new("School plan must be a hash") if @school_plan.class != Hash
       
       raise ArgumentError.new('You must pass in a date') if @date.nil?
       raise TypeError.new("The date should be formatted as a string in the format mm-dd-yyyy") if @date.class != String || !/(0[1-9]|1[012])-(0[1-9]|[12][0-9]|3[01])-(19|20)\d\d/.match?(@date)
+      raise ArgumentError.new('Date must be within the interval range of the school plan') if !date_within_range
       
       @non_business_days.each do |non_business_day|
         raise TypeError.new('"Non business days" dates should be formatted as a string in the format mm-dd-yyyy') if non_business_day.class != String || !/(0[1-9]|1[012])-(0[1-9]|[12][0-9]|3[01])-(19|20)\d\d/.match?(non_business_day)
@@ -45,40 +48,71 @@ module Pacing
 
         raise TypeError.new("Interval for extra sessions allowable must be a string and cannot be nil") if school_plan_service[:interval_for_extra_sessions_allowable].class != String || school_plan_service[:interval_for_extra_sessions_allowable].nil?
       end
+
+      @summer_holidays = summer_holidays.empty? ? parse_summer_holiday_dates : [parse_date(summer_holidays[0]), parse_date(summer_holidays[1])]
     end
 
     def calculate
-      services = @school_plan[:school_plan_services]
+      # filter out services that haven't started or whose time is passed
+      services = @school_plan[:school_plan_services].filter do |school_plan_service|
+        within = true
+        if !(parse_date(school_plan_service[:start_date]) <= parse_date(@date) && parse_date(@date) <= parse_date(school_plan_service[:end_date]))
+          within = false
+        end
+
+        within
+      end
 
       services = services.map do |service|
+        discipline = {}
+
         expected = expected_visits(start_date: parse_date(service[:start_date]), end_date: parse_date(service[:end_date]), frequency: service[:frequency], interval: service[:interval])
 
-        service[:pace] = pace(service[:completed_visits_for_current_interval], expected)
-        service[:reset_date] = reset_date(start_date: service[:start_date], interval: service[:interval_for_extra_sessions_allowable])
-        service[:remaining_visits] = remaining_visits(completed_visits: service[:completed_visits_for_current_interval], required_visits: service[:frequency])
-        service[:pace_indicator] = pace_indicator(service[:pace])
+        discipline[:pace] = pace(service[:completed_visits_for_current_interval], expected)
+
+        discipline[:reset_date] = reset_date(start_date: service[:start_date], interval: service[:interval])
+
+        discipline[:reset_date] = parse_date(discipline[:reset_date]) > parse_date(service[:end_date]) && service[:interval] == "yearly" ? service[:end_date] : discipline[:reset_date]
+
+        discipline[:remaining_visits] = remaining_visits(completed_visits: service[:completed_visits_for_current_interval], required_visits: service[:frequency] + service[:extra_sessions_allowable])
+
+        discipline[:pace_indicator] = pace_indicator(discipline[:pace])
+
+        discipline[:used_visits] =  service[:completed_visits_for_current_interval]
+
+        discipline[:suggested_rate] = suggested_rate(remaining_visits: discipline[:remaining_visits], start_date: parse_date(service[:start_date]), interval: service[:interval])
+
+        discipline[:expected_visits_at_date] = expected
 
-        service
+        discipline[:type_of_service] = service[:type_of_service]
+
+        discipline
       end
 
-      { school_plan_services: services }
+      disciplines_cleaner ([speech_discipline(services), occupational_discipline(services), physical_discipline(services), feeding_discipline(services)])
     end
 
     # get a spreadout of visit dates over an interval by using simple proportion.
     def expected_visits(start_date:, end_date:, frequency:, interval:)
       reset_start = start_of_treatment_date(start_date, interval)
 
-      reset_end =  reset_start + interval_days(interval)
+      reset_end = end_of_treatment_date(reset_start, interval)
 
       days_between = business_days(reset_start, reset_end).count
 
-      days_passed = business_days(reset_start, parse_date(@date)).count
+      days_passed = 0
+
+      visits = 0
+
+      if parse_date(@date) > reset_start
+        days_passed = business_days(reset_start, parse_date(@date)).count
+      end
 
       if days_between != 0
-        return ((frequency/days_between.to_f) * days_passed).round
-      else
-        return 0
+        visits = ((frequency/days_between.to_f) * days_passed).round
       end
+
+      return visits
     end
 
     def interval_days(interval)
@@ -108,7 +142,10 @@ module Pacing
     end
 
     def parse_date(date)
-      Date.strptime(date, '%m-%d-%Y')
+      begin
+        Date.strptime(date, '%m-%d-%Y')
+      rescue => exception
+      end
     end
 
     def parsed_non_business_days
@@ -123,11 +160,13 @@ module Pacing
       # remove holidays(array from Ambiki)
       # remove school holidays/non business days
       # should we remove today?(datetime call?)
+      summer = get_working_days(summer_holidays[0], summer_holidays[1])
+
       working_days = get_working_days(start_date, end_date)
 
       holidays = get_holidays(start_date, end_date)
-      
-      working_days.sort - parsed_non_business_days.sort - holidays.sort
+
+      working_days.sort - parsed_non_business_days.sort - holidays.sort - summer.sort
     end
 
     # scoped to the interval
@@ -168,12 +207,16 @@ module Pacing
     end
 
     def get_holidays(start_date, end_date)
-      Holidays.between(start_date, end_date, @state).map { |holiday| holiday[:date] }
+      begin
+        Holidays.between(start_date, end_date, @state).map { |holiday| holiday[:date] }
+      rescue => exception
+      end
     end
 
     # get actual date of the first day of the week where date falls
     def week_start(date, offset_from_sunday=0)
-      date - ((date.wday - offset_from_sunday)%7)
+      return date if date.monday?
+      date - ((date.wday - offset_from_sunday) % 7)
     end
     
     # reset date for the yearly interval
@@ -183,7 +226,7 @@ module Pacing
 
     # reset date for the monthly interval
     def reset_date_monthly(start_date, interval)
-      (start_of_treatment_date(parse_date(start_date), interval) + COMMON_YEAR_DAYS_IN_MONTH[(parse_date(@date)).month]-1).strftime("%m-%d-%Y")
+      (start_of_treatment_date(parse_date(start_date), interval) + COMMON_YEAR_DAYS_IN_MONTH[(parse_date(@date)).month]).strftime("%m-%d-%Y")
     end
 
     # reset date for the weekly interval
@@ -193,23 +236,213 @@ module Pacing
 
     # start of treatment for the yearly interval
     def start_of_treatment_date_yearly(start_date)
-      parse_date("#{start_date.month}-#{start_date.day}-#{parse_date(@date).year}")
+      start = parse_date("#{start_date.month}-#{start_date.day}-#{parse_date(@date).year}")
+      if start > parse_date(date)
+        start = start_date
+      end
+
+      start
+      # start_date
     end
 
     # start of treatment for the montly interval
     def start_of_treatment_date_monthly(start_date)
-      parse_date("#{parse_date(@date).month}-#{start_date.day}-#{parse_date(@date).year}")
+      if @mode == :strict
+        return parse_date("#{parse_date(@date).month}-#{start_date.day}-#{parse_date(@date).year}")
+      else
+        return parse_date("#{parse_date(@date).month}-01-#{parse_date(@date).year}")
+      end
+    end
+
+    def end_of_treatment_date(reset_start, interval)
+      reset_start + interval_days(interval)
     end
 
     # start of treatment for the weekly interval
     def start_of_treatment_date_weekly(start_date)
-      date = parse_date(@date)
+      parsed_date = parse_date(@date)
+      week_start_date = week_start(parsed_date)
+      weekly_date = week_start_date
 
-      week_start_date = week_start(date)
-      weekly_date = week_start_date + start_date.wday
-      weekly_date = date < weekly_date ? weekly_date - 7 : weekly_date
+      if week_start_date != parsed_date && @mode == :strict
+        weekly_date = week_start_date + start_date.wday #unless start_date.wday == 1
+        weekly_date = parsed_date < weekly_date ? weekly_date - 7 : weekly_date
+      end
 
       weekly_date
     end
+
+    def date_within_range
+      valid_range_or_exceptions = false
+
+      begin
+        @school_plan[:school_plan_services].each do |school_plan_service|
+          if (parse_date(school_plan_service[:start_date]) <= parse_date(@date) && parse_date(@date) <= parse_date(school_plan_service[:end_date]))
+            valid_range_or_exceptions = true
+          end
+        end
+      rescue => exception
+        valid_range_or_exceptions = true
+      end
+      
+      valid_range_or_exceptions
+    end
+
+    def speech_discipline(services)
+      discipline = {
+        :discipline => "Speech Therapy",
+        :remaining_visits => 0,
+        :used_visits => 0,
+        :pace => 0,
+        :pace_indicator => "🐢",
+        :pace_suggestion => "once a day",
+        :suggested_rate => 0,
+        :expected_visits_at_date => 0,
+        :reset_date => nil } # some arbitrarity date in the past
+
+      discipline_services = services.filter do |service|
+        ["Language Therapy", "Speech Therapy", "Speech and Language Therapy", "Speech Language Therapy"].include? service[:type_of_service]
+      end
+
+      return {} if discipline_services.empty?
+
+      discipline_data(discipline_services, discipline)
+    end
+
+    def occupational_discipline(services)
+      discipline = {
+        :discipline=>"Occupational Therapy",
+        :remaining_visits=>0,
+        :used_visits=>0,
+        :pace=>0,
+        :pace_indicator=>"🐢",
+        :pace_suggestion=>"once a day",
+        :suggested_rate => 0,
+        :expected_visits_at_date=>0,
+        :reset_date=> nil } # some arbitrarity date in the past
+
+      discipline_services = services.filter do |service|
+        ["occupation therapy", "occupational therapy"].include? (service[:type_of_service].downcase)
+      end
+
+      return {} if discipline_services.empty?
+
+      discipline_data(discipline_services, discipline)
+    end
+
+    def physical_discipline(services)
+      discipline = {
+        :discipline=>"Physical Therapy",
+        :remaining_visits=>0,
+        :used_visits=>0,
+        :pace=>0,
+        :pace_indicator=>"🐢",
+        :pace_suggestion=>"once a day",
+        :suggested_rate => 0,
+        :expected_visits_at_date=>0,
+        :reset_date=> nil } # some arbitrarity date in the past
+
+      discipline_services = services.filter do |service|
+        ["Physical Therapy"].include? service[:type_of_service]
+      end
+
+      return {} if discipline_services.empty?
+
+      discipline_data(discipline_services, discipline)
+    end
+
+    def feeding_discipline(services)
+      discipline = {
+        :discipline=>"Feeding Therapy",
+        :remaining_visits=>0,
+        :used_visits=>0,
+        :pace=>0,
+        :pace_indicator=>"🐢",
+        :pace_suggestion=>"once a day",
+        :suggested_rate => 0,
+        :expected_visits_at_date=>0,
+        :reset_date=> nil } # some arbitrarity date in the past
+
+      discipline_services = services.filter do |service|
+        ["Feeding Therapy"].include? service[:type_of_service]
+      end
+
+      return {} if discipline_services.empty?
+
+      discipline_data(discipline_services, discipline)
+    end
+
+    def discipline_data(services, discipline)
+      services.each do |service|
+        discipline[:pace] = discipline[:pace] ? discipline[:pace].to_i + service[:pace].to_i : service[:pace]
+
+        discipline[:remaining_visits] = discipline[:remaining_visits] ? discipline[:remaining_visits].to_i + service[:remaining_visits].to_i : service[:remaining_visits]
+
+        discipline[:used_visits] = discipline[:used_visits] ? discipline[:used_visits].to_i + service[:used_visits].to_i : service[:used_visits]
+
+        discipline[:expected_visits_at_date] = discipline[:expected_visits_at_date] ? discipline[:expected_visits_at_date].to_i + service[:expected_visits_at_date].to_i : service[:expected_visits_at_date]
+
+        discipline[:suggested_rate] = discipline[:suggested_rate] ? discipline[:suggested_rate].to_f + service[:suggested_rate].to_f : service[:suggested_rate].to_f
+
+        discipline[:reset_date] = (!discipline[:reset_date].nil? && parse_date(service[:reset_date]) < parse_date(discipline[:reset_date])) ? discipline[:reset_date] : service[:reset_date]
+      end
+
+      discipline[:pace_indicator] = pace_indicator(discipline[:pace])
+      discipline[:pace_suggestion] = readable_suggestion(rate: discipline[:suggested_rate]) 
+
+      discipline.delete(:suggested_rate)
+      discipline
+    end
+
+    def readable_suggestion(rate:)
+      # rate = suggested_rate(remaining_visits: remaining_visits, start_date: start_date, interval: interval)
+
+      if rate < 0.2
+        'less than once per week'
+      elsif rate >= 0.2 && rate < 0.25
+        'once a week'
+      elsif rate >= 0.25 && rate < 0.33
+        'once every 4 days'
+      elsif rate >= 0.33 && rate < 0.5
+        'once every 3 days'
+      elsif rate == 0.5
+        'once every other day'
+      elsif rate > 0.5 && rate < 1
+        'about once every other day'
+      elsif rate >= 1.00
+        'once a day'
+      end
+    end
+
+    def suggested_rate(remaining_visits:, start_date:, interval:)
+      days_left = remaining_days(start_date: start_date, interval: interval).to_f
+      days_left = 1 if days_left == 0
+      (remaining_visits / days_left.to_f).round(2)
+    end
+
+    def remaining_days(start_date:, interval:)
+      reset_start = start_of_treatment_date(start_date, interval)
+      reset_end = end_of_treatment_date(reset_start, interval)
+
+      days_left = business_days(parse_date(@date), reset_end).count
+
+      days_left
+    end
+
+    def disciplines_cleaner(disciplines)
+      # use the fake arbitrary reset date to remove unrequired disciplines
+      disciplines.filter { |discipline| !discipline.empty? }
+    end
+
+    def parse_summer_holiday_dates
+      holidays_start = parse_date("05-13-#{parse_date(@date).year}")
+      holidays_start += 1 until holidays_start.wday == 5
+
+      holidays_end = parse_date("08-01-#{parse_date(@date).year}")
+      holidays_start += 1 until holidays_start.wday == 1
+
+      [holidays_start, holidays_end]
+    end
   end
-end
+end
+

data/lib/pacing/version.rb

@@ -1,5 +1,5 @@
 # frozen_string_literal: true
 
 module Pacing
-  VERSION = "0.1.3"
+  VERSION = "1.0.0"
 end