SpeciesFileGroup/taxonworks

View on GitHub
lib/utilities/dates.rb

Summary

Maintainability
F
1 wk
Test Coverage

File dates.rb has 761 lines of code (exceeds 250 allowed). Consider refactoring.
Open

module Utilities::Dates

  EARLIEST_DATE = '1700/01/10'.freeze # Reconcile with in-app

  LONG_MONTHS = %w{january february march april may june july august september october november december}.freeze
Severity: Major
Found in lib/utilities/dates.rb - About 1 day to fix

    Method date_regex_from_verbatim_label has 261 lines of code (exceeds 25 allowed). Consider refactoring.
    Open

      def self.date_regex_from_verbatim_label(text)
        return nil if text.blank?
        text = ' ' + text.downcase + ' '
    
        date = {}
    Severity: Major
    Found in lib/utilities/dates.rb - About 1 day to fix

      Method extract_dates has 180 lines of code (exceeds 25 allowed). Consider refactoring.
      Open

        def self.extract_dates(trial, match_data)
          end_date_year, end_date_month, end_date_day = 0, 0, 0
          case trial[:method].downcase.to_sym
            when :month_dd_yyyy_2
              start_date_year = 3
      Severity: Major
      Found in lib/utilities/dates.rb - About 7 hrs to fix

        Method date_regex_from_verbatim_label has a Cognitive Complexity of 42 (exceeds 5 allowed). Consider refactoring.
        Open

          def self.date_regex_from_verbatim_label(text)
            return nil if text.blank?
            text = ' ' + text.downcase + ' '
        
            date = {}
        Severity: Minor
        Found in lib/utilities/dates.rb - About 6 hrs to fix

        Cognitive Complexity

        Cognitive Complexity is a measure of how difficult a unit of code is to intuitively understand. Unlike Cyclomatic Complexity, which determines how difficult your code will be to test, Cognitive Complexity tells you how difficult your code will be to read and comprehend.

        A method's cognitive complexity is based on a few simple rules:

        • Code is not considered more complex when it uses shorthand that the language provides for collapsing multiple statements into one
        • Code is considered more complex for each "break in the linear flow of the code"
        • Code is considered more complex when "flow breaking structures are nested"

        Further reading

        Method has too many lines. [43/25]
        Open

          def self.date_sql_from_params(params)
            st_date, end_date = params['st_datepicker'], params['en_datepicker']
            # processing start date data
            st_year, st_month, st_day = params['start_date_year'], params['start_date_month'], params['start_date_day']
            unless st_date.blank?
        Severity: Minor
        Found in lib/utilities/dates.rb by rubocop

        This cop checks if the length of a method exceeds some maximum value. Comment lines can optionally be ignored. The maximum allowed length is configurable.

        Method date_sql_from_params has a Cognitive Complexity of 26 (exceeds 5 allowed). Consider refactoring.
        Open

          def self.date_sql_from_params(params)
            st_date, end_date = params['st_datepicker'], params['en_datepicker']
            # processing start date data
            st_year, st_month, st_day = params['start_date_year'], params['start_date_month'], params['start_date_day']
            unless st_date.blank?
        Severity: Minor
        Found in lib/utilities/dates.rb - About 3 hrs to fix

        Cognitive Complexity

        Cognitive Complexity is a measure of how difficult a unit of code is to intuitively understand. Unlike Cyclomatic Complexity, which determines how difficult your code will be to test, Cognitive Complexity tells you how difficult your code will be to read and comprehend.

        A method's cognitive complexity is based on a few simple rules:

        • Code is not considered more complex when it uses shorthand that the language provides for collapsing multiple statements into one
        • Code is considered more complex for each "break in the linear flow of the code"
        • Code is considered more complex when "flow breaking structures are nested"

        Further reading

        Method extract_dates has a Cognitive Complexity of 23 (exceeds 5 allowed). Consider refactoring.
        Open

          def self.extract_dates(trial, match_data)
            end_date_year, end_date_month, end_date_day = 0, 0, 0
            case trial[:method].downcase.to_sym
              when :month_dd_yyyy_2
                start_date_year = 3
        Severity: Minor
        Found in lib/utilities/dates.rb - About 3 hrs to fix

        Cognitive Complexity

        Cognitive Complexity is a measure of how difficult a unit of code is to intuitively understand. Unlike Cyclomatic Complexity, which determines how difficult your code will be to test, Cognitive Complexity tells you how difficult your code will be to read and comprehend.

        A method's cognitive complexity is based on a few simple rules:

        • Code is not considered more complex when it uses shorthand that the language provides for collapsing multiple statements into one
        • Code is considered more complex for each "break in the linear flow of the code"
        • Code is considered more complex when "flow breaking structures are nested"

        Further reading

        Method date_sql_from_params has 43 lines of code (exceeds 25 allowed). Consider refactoring.
        Open

          def self.date_sql_from_params(params)
            st_date, end_date = params['st_datepicker'], params['en_datepicker']
            # processing start date data
            st_year, st_month, st_day = params['start_date_year'], params['start_date_month'], params['start_date_day']
            unless st_date.blank?
        Severity: Minor
        Found in lib/utilities/dates.rb - About 1 hr to fix

          Method from_parts has a Cognitive Complexity of 8 (exceeds 5 allowed). Consider refactoring.
          Open

            def self.from_parts(y, m, d)
              return '????/??/??' if y.nil? && m.nil? && d.nil?
              [y ? "#{y}" : '????',
               m ? "#{'%02d' % m}" : '??',
               d ? "#{'%02d' % d}" : '??'
          Severity: Minor
          Found in lib/utilities/dates.rb - About 45 mins to fix

          Cognitive Complexity

          Cognitive Complexity is a measure of how difficult a unit of code is to intuitively understand. Unlike Cyclomatic Complexity, which determines how difficult your code will be to test, Cognitive Complexity tells you how difficult your code will be to read and comprehend.

          A method's cognitive complexity is based on a few simple rules:

          • Code is not considered more complex when it uses shorthand that the language provides for collapsing multiple statements into one
          • Code is considered more complex for each "break in the linear flow of the code"
          • Code is considered more complex when "flow breaking structures are nested"

          Further reading

          Method invalid_month_day has a Cognitive Complexity of 8 (exceeds 5 allowed). Consider refactoring.
          Open

            def self.invalid_month_day(trial)
              retval = false
              if trial[:start_date_day].to_i > 31 or trial[:end_date_day].to_i > 31
                retval = true
              end
          Severity: Minor
          Found in lib/utilities/dates.rb - About 45 mins to fix

          Cognitive Complexity

          Cognitive Complexity is a measure of how difficult a unit of code is to intuitively understand. Unlike Cyclomatic Complexity, which determines how difficult your code will be to test, Cognitive Complexity tells you how difficult your code will be to read and comprehend.

          A method's cognitive complexity is based on a few simple rules:

          • Code is not considered more complex when it uses shorthand that the language provides for collapsing multiple statements into one
          • Code is considered more complex for each "break in the linear flow of the code"
          • Code is considered more complex when "flow breaking structures are nested"

          Further reading

          Consider simplifying this complex logical expression.
          Open

                if ((st_y or st_my) and (end_y or end_my)) and not (st_y and end_y)
                  # we have two dates of some kind, complete with years
                  # three specific cases:
                  #   case 1: start year, (start month, (start day)) forward
                  #   case 2: end year, (end month, (end day)) backward
          Severity: Major
          Found in lib/utilities/dates.rb - About 40 mins to fix

            Method fix_2_digit_year has a Cognitive Complexity of 7 (exceeds 5 allowed). Consider refactoring.
            Open

              def self.fix_2_digit_year(year)
                if year.length < 4
                  year = year.gsub("'", '')
                  if year.length < 3
                    tny = Time.now.year
            Severity: Minor
            Found in lib/utilities/dates.rb - About 35 mins to fix

            Cognitive Complexity

            Cognitive Complexity is a measure of how difficult a unit of code is to intuitively understand. Unlike Cyclomatic Complexity, which determines how difficult your code will be to test, Cognitive Complexity tells you how difficult your code will be to read and comprehend.

            A method's cognitive complexity is based on a few simple rules:

            • Code is not considered more complex when it uses shorthand that the language provides for collapsing multiple statements into one
            • Code is considered more complex for each "break in the linear flow of the code"
            • Code is considered more complex when "flow breaking structures are nested"

            Further reading

            Method nomenclature_date has a Cognitive Complexity of 7 (exceeds 5 allowed). Consider refactoring.
            Open

              def self.nomenclature_date(day = nil, month = nil, year = nil)
                if year.nil?
                  nil
                elsif month.nil?
                  Time.utc(year.to_i, 12, 31)
            Severity: Minor
            Found in lib/utilities/dates.rb - About 35 mins to fix

            Cognitive Complexity

            Cognitive Complexity is a measure of how difficult a unit of code is to intuitively understand. Unlike Cyclomatic Complexity, which determines how difficult your code will be to test, Cognitive Complexity tells you how difficult your code will be to read and comprehend.

            A method's cognitive complexity is based on a few simple rules:

            • Code is not considered more complex when it uses shorthand that the language provides for collapsing multiple statements into one
            • Code is considered more complex for each "break in the linear flow of the code"
            • Code is considered more complex when "flow breaking structures are nested"

            Further reading

            Method normalize_and_order_dates has a Cognitive Complexity of 7 (exceeds 5 allowed). Consider refactoring.
            Open

              def self.normalize_and_order_dates(start_date, end_date)
                if start_date.blank? && end_date.blank? # set entire range
                  [ EARLIEST_DATE, today] # 1700-01-01 - Today
                else
                  end_date = start_date if end_date.blank?
            Severity: Minor
            Found in lib/utilities/dates.rb - About 35 mins to fix

            Cognitive Complexity

            Cognitive Complexity is a measure of how difficult a unit of code is to intuitively understand. Unlike Cyclomatic Complexity, which determines how difficult your code will be to test, Cognitive Complexity tells you how difficult your code will be to read and comprehend.

            A method's cognitive complexity is based on a few simple rules:

            • Code is not considered more complex when it uses shorthand that the language provides for collapsing multiple statements into one
            • Code is considered more complex for each "break in the linear flow of the code"
            • Code is considered more complex when "flow breaking structures are nested"

            Further reading

            Avoid too many return statements within this method.
            Open

                    return {}
            Severity: Major
            Found in lib/utilities/dates.rb - About 30 mins to fix

              Avoid too many return statements within this method.
              Open

                      return date
              Severity: Major
              Found in lib/utilities/dates.rb - About 30 mins to fix

                Avoid too many return statements within this method.
                Open

                        return date
                Severity: Major
                Found in lib/utilities/dates.rb - About 30 mins to fix

                  Avoid too many return statements within this method.
                  Open

                        return {}
                  Severity: Major
                  Found in lib/utilities/dates.rb - About 30 mins to fix

                    Avoid too many return statements within this method.
                    Open

                            return {}
                    Severity: Major
                    Found in lib/utilities/dates.rb - About 30 mins to fix

                      Method hunt_dates has a Cognitive Complexity of 6 (exceeds 5 allowed). Consider refactoring.
                      Open

                        def self.hunt_dates(label, filters = REGEXP_DATES.keys)
                          trials = {}
                          filters.each_with_index {|kee, dex|
                            trials[kee] = {}
                            matches = label.to_enum(:scan, REGEXP_DATES[kee][:reg]).map {Regexp.last_match}
                      Severity: Minor
                      Found in lib/utilities/dates.rb - About 25 mins to fix

                      Cognitive Complexity

                      Cognitive Complexity is a measure of how difficult a unit of code is to intuitively understand. Unlike Cyclomatic Complexity, which determines how difficult your code will be to test, Cognitive Complexity tells you how difficult your code will be to read and comprehend.

                      A method's cognitive complexity is based on a few simple rules:

                      • Code is not considered more complex when it uses shorthand that the language provides for collapsing multiple statements into one
                      • Code is considered more complex for each "break in the linear flow of the code"
                      • Code is considered more complex when "flow breaking structures are nested"

                      Further reading

                      Use end_year.present? instead of !end_year.blank?.
                      Open

                          end_my = (!end_month.blank? and !end_year.blank?)
                      Severity: Minor
                      Found in lib/utilities/dates.rb by rubocop

                      This cop checks for code that can be written with simpler conditionals using Object#present? defined by Active Support.

                      Interaction with Style/UnlessElse: The configuration of NotBlank will not produce an offense in the context of unless else if Style/UnlessElse is inabled. This is to prevent interference between the auto-correction of the two cops.

                      Example: NotNilAndNotEmpty: true (default)

                      # Converts usages of `!nil? && !empty?` to `present?`
                      
                      # bad
                      !foo.nil? && !foo.empty?
                      
                      # bad
                      foo != nil && !foo.empty?
                      
                      # good
                      foo.present?

                      Example: NotBlank: true (default)

                      # Converts usages of `!blank?` to `present?`
                      
                      # bad
                      !foo.blank?
                      
                      # bad
                      not foo.blank?
                      
                      # good
                      foo.present?

                      Example: UnlessBlank: true (default)

                      # Converts usages of `unless blank?` to `if present?`
                      
                      # bad
                      something unless foo.blank?
                      
                      # good
                      something if foo.present?

                      Use end_month.present? instead of !end_month.blank?.
                      Open

                          end_m = (!end_month.blank? and end_year.blank?)
                      Severity: Minor
                      Found in lib/utilities/dates.rb by rubocop

                      This cop checks for code that can be written with simpler conditionals using Object#present? defined by Active Support.

                      Interaction with Style/UnlessElse: The configuration of NotBlank will not produce an offense in the context of unless else if Style/UnlessElse is inabled. This is to prevent interference between the auto-correction of the two cops.

                      Example: NotNilAndNotEmpty: true (default)

                      # Converts usages of `!nil? && !empty?` to `present?`
                      
                      # bad
                      !foo.nil? && !foo.empty?
                      
                      # bad
                      foo != nil && !foo.empty?
                      
                      # good
                      foo.present?

                      Example: NotBlank: true (default)

                      # Converts usages of `!blank?` to `present?`
                      
                      # bad
                      !foo.blank?
                      
                      # bad
                      not foo.blank?
                      
                      # good
                      foo.present?

                      Example: UnlessBlank: true (default)

                      # Converts usages of `unless blank?` to `if present?`
                      
                      # bad
                      something unless foo.blank?
                      
                      # good
                      something if foo.present?

                      Use trial[:end_date_day].present? instead of !trial[:end_date_day].blank?.
                      Open

                          if trial[:start_date_day].to_i < 1 or (trial[:end_date_day].to_i < 1 and !trial[:end_date_day].blank?)
                      Severity: Minor
                      Found in lib/utilities/dates.rb by rubocop

                      This cop checks for code that can be written with simpler conditionals using Object#present? defined by Active Support.

                      Interaction with Style/UnlessElse: The configuration of NotBlank will not produce an offense in the context of unless else if Style/UnlessElse is inabled. This is to prevent interference between the auto-correction of the two cops.

                      Example: NotNilAndNotEmpty: true (default)

                      # Converts usages of `!nil? && !empty?` to `present?`
                      
                      # bad
                      !foo.nil? && !foo.empty?
                      
                      # bad
                      foo != nil && !foo.empty?
                      
                      # good
                      foo.present?

                      Example: NotBlank: true (default)

                      # Converts usages of `!blank?` to `present?`
                      
                      # bad
                      !foo.blank?
                      
                      # bad
                      not foo.blank?
                      
                      # good
                      foo.present?

                      Example: UnlessBlank: true (default)

                      # Converts usages of `unless blank?` to `if present?`
                      
                      # bad
                      something unless foo.blank?
                      
                      # good
                      something if foo.present?

                      Use if matches.present? instead of unless matches.blank?.
                      Open

                            unless matches.blank?
                      Severity: Minor
                      Found in lib/utilities/dates.rb by rubocop

                      This cop checks for code that can be written with simpler conditionals using Object#present? defined by Active Support.

                      Interaction with Style/UnlessElse: The configuration of NotBlank will not produce an offense in the context of unless else if Style/UnlessElse is inabled. This is to prevent interference between the auto-correction of the two cops.

                      Example: NotNilAndNotEmpty: true (default)

                      # Converts usages of `!nil? && !empty?` to `present?`
                      
                      # bad
                      !foo.nil? && !foo.empty?
                      
                      # bad
                      foo != nil && !foo.empty?
                      
                      # good
                      foo.present?

                      Example: NotBlank: true (default)

                      # Converts usages of `!blank?` to `present?`
                      
                      # bad
                      !foo.blank?
                      
                      # bad
                      not foo.blank?
                      
                      # good
                      foo.present?

                      Example: UnlessBlank: true (default)

                      # Converts usages of `unless blank?` to `if present?`
                      
                      # bad
                      something unless foo.blank?
                      
                      # good
                      something if foo.present?

                      Use if end_date.present? instead of unless end_date.blank?.
                      Open

                          unless end_date.blank?
                      Severity: Minor
                      Found in lib/utilities/dates.rb by rubocop

                      This cop checks for code that can be written with simpler conditionals using Object#present? defined by Active Support.

                      Interaction with Style/UnlessElse: The configuration of NotBlank will not produce an offense in the context of unless else if Style/UnlessElse is inabled. This is to prevent interference between the auto-correction of the two cops.

                      Example: NotNilAndNotEmpty: true (default)

                      # Converts usages of `!nil? && !empty?` to `present?`
                      
                      # bad
                      !foo.nil? && !foo.empty?
                      
                      # bad
                      foo != nil && !foo.empty?
                      
                      # good
                      foo.present?

                      Example: NotBlank: true (default)

                      # Converts usages of `!blank?` to `present?`
                      
                      # bad
                      !foo.blank?
                      
                      # bad
                      not foo.blank?
                      
                      # good
                      foo.present?

                      Example: UnlessBlank: true (default)

                      # Converts usages of `unless blank?` to `if present?`
                      
                      # bad
                      something unless foo.blank?
                      
                      # good
                      something if foo.present?

                      Use if st_month.present? instead of unless st_month.blank?.
                      Open

                          unless st_month.blank?
                      Severity: Minor
                      Found in lib/utilities/dates.rb by rubocop

                      This cop checks for code that can be written with simpler conditionals using Object#present? defined by Active Support.

                      Interaction with Style/UnlessElse: The configuration of NotBlank will not produce an offense in the context of unless else if Style/UnlessElse is inabled. This is to prevent interference between the auto-correction of the two cops.

                      Example: NotNilAndNotEmpty: true (default)

                      # Converts usages of `!nil? && !empty?` to `present?`
                      
                      # bad
                      !foo.nil? && !foo.empty?
                      
                      # bad
                      foo != nil && !foo.empty?
                      
                      # good
                      foo.present?

                      Example: NotBlank: true (default)

                      # Converts usages of `!blank?` to `present?`
                      
                      # bad
                      !foo.blank?
                      
                      # bad
                      not foo.blank?
                      
                      # good
                      foo.present?

                      Example: UnlessBlank: true (default)

                      # Converts usages of `unless blank?` to `if present?`
                      
                      # bad
                      something unless foo.blank?
                      
                      # good
                      something if foo.present?

                      Use if match_data[1].present? instead of unless match_data[1].blank?.
                      Open

                          unless match_data[1].blank?
                      Severity: Minor
                      Found in lib/utilities/dates.rb by rubocop

                      This cop checks for code that can be written with simpler conditionals using Object#present? defined by Active Support.

                      Interaction with Style/UnlessElse: The configuration of NotBlank will not produce an offense in the context of unless else if Style/UnlessElse is inabled. This is to prevent interference between the auto-correction of the two cops.

                      Example: NotNilAndNotEmpty: true (default)

                      # Converts usages of `!nil? && !empty?` to `present?`
                      
                      # bad
                      !foo.nil? && !foo.empty?
                      
                      # bad
                      foo != nil && !foo.empty?
                      
                      # good
                      foo.present?

                      Example: NotBlank: true (default)

                      # Converts usages of `!blank?` to `present?`
                      
                      # bad
                      !foo.blank?
                      
                      # bad
                      not foo.blank?
                      
                      # good
                      foo.present?

                      Example: UnlessBlank: true (default)

                      # Converts usages of `unless blank?` to `if present?`
                      
                      # bad
                      something unless foo.blank?
                      
                      # good
                      something if foo.present?

                      Use if pieces[1].present? instead of unless pieces[1].blank?.
                      Open

                          unless pieces[1].blank?
                      Severity: Minor
                      Found in lib/utilities/dates.rb by rubocop

                      This cop checks for code that can be written with simpler conditionals using Object#present? defined by Active Support.

                      Interaction with Style/UnlessElse: The configuration of NotBlank will not produce an offense in the context of unless else if Style/UnlessElse is inabled. This is to prevent interference between the auto-correction of the two cops.

                      Example: NotNilAndNotEmpty: true (default)

                      # Converts usages of `!nil? && !empty?` to `present?`
                      
                      # bad
                      !foo.nil? && !foo.empty?
                      
                      # bad
                      foo != nil && !foo.empty?
                      
                      # good
                      foo.present?

                      Example: NotBlank: true (default)

                      # Converts usages of `!blank?` to `present?`
                      
                      # bad
                      !foo.blank?
                      
                      # bad
                      not foo.blank?
                      
                      # good
                      foo.present?

                      Example: UnlessBlank: true (default)

                      # Converts usages of `unless blank?` to `if present?`
                      
                      # bad
                      something unless foo.blank?
                      
                      # good
                      something if foo.present?

                      Use end_month.present? instead of !end_month.blank?.
                      Open

                          end_my = (!end_month.blank? and !end_year.blank?)
                      Severity: Minor
                      Found in lib/utilities/dates.rb by rubocop

                      This cop checks for code that can be written with simpler conditionals using Object#present? defined by Active Support.

                      Interaction with Style/UnlessElse: The configuration of NotBlank will not produce an offense in the context of unless else if Style/UnlessElse is inabled. This is to prevent interference between the auto-correction of the two cops.

                      Example: NotNilAndNotEmpty: true (default)

                      # Converts usages of `!nil? && !empty?` to `present?`
                      
                      # bad
                      !foo.nil? && !foo.empty?
                      
                      # bad
                      foo != nil && !foo.empty?
                      
                      # good
                      foo.present?

                      Example: NotBlank: true (default)

                      # Converts usages of `!blank?` to `present?`
                      
                      # bad
                      !foo.blank?
                      
                      # bad
                      not foo.blank?
                      
                      # good
                      foo.present?

                      Example: UnlessBlank: true (default)

                      # Converts usages of `unless blank?` to `if present?`
                      
                      # bad
                      something unless foo.blank?
                      
                      # good
                      something if foo.present?

                      Use end_year.present? instead of !end_year.blank?.
                      Open

                          end_y = (end_month.blank? and !end_year.blank?)
                      Severity: Minor
                      Found in lib/utilities/dates.rb by rubocop

                      This cop checks for code that can be written with simpler conditionals using Object#present? defined by Active Support.

                      Interaction with Style/UnlessElse: The configuration of NotBlank will not produce an offense in the context of unless else if Style/UnlessElse is inabled. This is to prevent interference between the auto-correction of the two cops.

                      Example: NotNilAndNotEmpty: true (default)

                      # Converts usages of `!nil? && !empty?` to `present?`
                      
                      # bad
                      !foo.nil? && !foo.empty?
                      
                      # bad
                      foo != nil && !foo.empty?
                      
                      # good
                      foo.present?

                      Example: NotBlank: true (default)

                      # Converts usages of `!blank?` to `present?`
                      
                      # bad
                      !foo.blank?
                      
                      # bad
                      not foo.blank?
                      
                      # good
                      foo.present?

                      Example: UnlessBlank: true (default)

                      # Converts usages of `unless blank?` to `if present?`
                      
                      # bad
                      something unless foo.blank?
                      
                      # good
                      something if foo.present?

                      Do not use Date.today without zone. Use Time.zone.today instead.
                      Open

                              Date.parse(date[:start_date_year].to_s + '-' + date[:start_date_month].to_s + '-' + date[:start_date_day].to_s) <= Date.today &&
                      Severity: Minor
                      Found in lib/utilities/dates.rb by rubocop

                      This cop checks for the correct use of Date methods, such as Date.today, Date.current etc.

                      Using Date.today is dangerous, because it doesn't know anything about Rails time zone. You must use Time.zone.today instead.

                      The cop also reports warnings when you are using to_time method, because it doesn't know about Rails time zone either.

                      Two styles are supported for this cop. When EnforcedStyle is 'strict' then the Date methods today, current, yesterday, and tomorrow are prohibited and the usage of both to_time and 'totimeincurrentzone' are reported as warning.

                      When EnforcedStyle is 'flexible' then only Date.today is prohibited and only to_time is reported as warning.

                      Example: EnforcedStyle: strict

                      # bad
                      Date.current
                      Date.yesterday
                      Date.today
                      date.to_time
                      
                      # good
                      Time.zone.today
                      Time.zone.today - 1.day

                      Example: EnforcedStyle: flexible (default)

                      # bad
                      Date.today
                      date.to_time
                      
                      # good
                      Time.zone.today
                      Time.zone.today - 1.day
                      Date.current
                      Date.yesterday
                      date.in_time_zone

                      Do not use Date.today without zone. Use Time.zone.today instead.
                      Open

                                Date.parse(date[:end_date_year].to_s + '-' + date[:end_date_month].to_s + '-' + date[:end_date_day].to_s) <= Date.today &&
                      Severity: Minor
                      Found in lib/utilities/dates.rb by rubocop

                      This cop checks for the correct use of Date methods, such as Date.today, Date.current etc.

                      Using Date.today is dangerous, because it doesn't know anything about Rails time zone. You must use Time.zone.today instead.

                      The cop also reports warnings when you are using to_time method, because it doesn't know about Rails time zone either.

                      Two styles are supported for this cop. When EnforcedStyle is 'strict' then the Date methods today, current, yesterday, and tomorrow are prohibited and the usage of both to_time and 'totimeincurrentzone' are reported as warning.

                      When EnforcedStyle is 'flexible' then only Date.today is prohibited and only to_time is reported as warning.

                      Example: EnforcedStyle: strict

                      # bad
                      Date.current
                      Date.yesterday
                      Date.today
                      date.to_time
                      
                      # good
                      Time.zone.today
                      Time.zone.today - 1.day

                      Example: EnforcedStyle: flexible (default)

                      # bad
                      Date.today
                      date.to_time
                      
                      # good
                      Time.zone.today
                      Time.zone.today - 1.day
                      Date.current
                      Date.yesterday
                      date.in_time_zone

                      Do not use Date.today without zone. Use Time.zone.today instead.
                      Open

                                Date.parse(date[:end_date_year].to_s + '-' + date[:end_date_month].to_s + '-1') <= Date.today &&
                      Severity: Minor
                      Found in lib/utilities/dates.rb by rubocop

                      This cop checks for the correct use of Date methods, such as Date.today, Date.current etc.

                      Using Date.today is dangerous, because it doesn't know anything about Rails time zone. You must use Time.zone.today instead.

                      The cop also reports warnings when you are using to_time method, because it doesn't know about Rails time zone either.

                      Two styles are supported for this cop. When EnforcedStyle is 'strict' then the Date methods today, current, yesterday, and tomorrow are prohibited and the usage of both to_time and 'totimeincurrentzone' are reported as warning.

                      When EnforcedStyle is 'flexible' then only Date.today is prohibited and only to_time is reported as warning.

                      Example: EnforcedStyle: strict

                      # bad
                      Date.current
                      Date.yesterday
                      Date.today
                      date.to_time
                      
                      # good
                      Time.zone.today
                      Time.zone.today - 1.day

                      Example: EnforcedStyle: flexible (default)

                      # bad
                      Date.today
                      date.to_time
                      
                      # good
                      Time.zone.today
                      Time.zone.today - 1.day
                      Date.current
                      Date.yesterday
                      date.in_time_zone

                      Use if st_date.present? instead of unless st_date.blank?.
                      Open

                          unless st_date.blank?
                      Severity: Minor
                      Found in lib/utilities/dates.rb by rubocop

                      This cop checks for code that can be written with simpler conditionals using Object#present? defined by Active Support.

                      Interaction with Style/UnlessElse: The configuration of NotBlank will not produce an offense in the context of unless else if Style/UnlessElse is inabled. This is to prevent interference between the auto-correction of the two cops.

                      Example: NotNilAndNotEmpty: true (default)

                      # Converts usages of `!nil? && !empty?` to `present?`
                      
                      # bad
                      !foo.nil? && !foo.empty?
                      
                      # bad
                      foo != nil && !foo.empty?
                      
                      # good
                      foo.present?

                      Example: NotBlank: true (default)

                      # Converts usages of `!blank?` to `present?`
                      
                      # bad
                      !foo.blank?
                      
                      # bad
                      not foo.blank?
                      
                      # good
                      foo.present?

                      Example: UnlessBlank: true (default)

                      # Converts usages of `unless blank?` to `if present?`
                      
                      # bad
                      something unless foo.blank?
                      
                      # good
                      something if foo.present?

                      Use if st_year.present? instead of unless st_year.blank?.
                      Open

                          unless st_year.blank?
                      Severity: Minor
                      Found in lib/utilities/dates.rb by rubocop

                      This cop checks for code that can be written with simpler conditionals using Object#present? defined by Active Support.

                      Interaction with Style/UnlessElse: The configuration of NotBlank will not produce an offense in the context of unless else if Style/UnlessElse is inabled. This is to prevent interference between the auto-correction of the two cops.

                      Example: NotNilAndNotEmpty: true (default)

                      # Converts usages of `!nil? && !empty?` to `present?`
                      
                      # bad
                      !foo.nil? && !foo.empty?
                      
                      # bad
                      foo != nil && !foo.empty?
                      
                      # good
                      foo.present?

                      Example: NotBlank: true (default)

                      # Converts usages of `!blank?` to `present?`
                      
                      # bad
                      !foo.blank?
                      
                      # bad
                      not foo.blank?
                      
                      # good
                      foo.present?

                      Example: UnlessBlank: true (default)

                      # Converts usages of `unless blank?` to `if present?`
                      
                      # bad
                      something unless foo.blank?
                      
                      # good
                      something if foo.present?

                      Use if st_day.present? instead of unless st_day.blank?.
                      Open

                          unless st_day.blank?
                      Severity: Minor
                      Found in lib/utilities/dates.rb by rubocop

                      This cop checks for code that can be written with simpler conditionals using Object#present? defined by Active Support.

                      Interaction with Style/UnlessElse: The configuration of NotBlank will not produce an offense in the context of unless else if Style/UnlessElse is inabled. This is to prevent interference between the auto-correction of the two cops.

                      Example: NotNilAndNotEmpty: true (default)

                      # Converts usages of `!nil? && !empty?` to `present?`
                      
                      # bad
                      !foo.nil? && !foo.empty?
                      
                      # bad
                      foo != nil && !foo.empty?
                      
                      # good
                      foo.present?

                      Example: NotBlank: true (default)

                      # Converts usages of `!blank?` to `present?`
                      
                      # bad
                      !foo.blank?
                      
                      # bad
                      not foo.blank?
                      
                      # good
                      foo.present?

                      Example: UnlessBlank: true (default)

                      # Converts usages of `unless blank?` to `if present?`
                      
                      # bad
                      something unless foo.blank?
                      
                      # good
                      something if foo.present?

                      Use trial[:end_date_month].present? instead of !trial[:end_date_month].blank?.
                      Open

                          if trial[:start_date_month].to_i < 1 or (trial[:end_date_month].to_i < 1 and !trial[:end_date_month].blank?)
                      Severity: Minor
                      Found in lib/utilities/dates.rb by rubocop

                      This cop checks for code that can be written with simpler conditionals using Object#present? defined by Active Support.

                      Interaction with Style/UnlessElse: The configuration of NotBlank will not produce an offense in the context of unless else if Style/UnlessElse is inabled. This is to prevent interference between the auto-correction of the two cops.

                      Example: NotNilAndNotEmpty: true (default)

                      # Converts usages of `!nil? && !empty?` to `present?`
                      
                      # bad
                      !foo.nil? && !foo.empty?
                      
                      # bad
                      foo != nil && !foo.empty?
                      
                      # good
                      foo.present?

                      Example: NotBlank: true (default)

                      # Converts usages of `!blank?` to `present?`
                      
                      # bad
                      !foo.blank?
                      
                      # bad
                      not foo.blank?
                      
                      # good
                      foo.present?

                      Example: UnlessBlank: true (default)

                      # Converts usages of `unless blank?` to `if present?`
                      
                      # bad
                      something unless foo.blank?
                      
                      # good
                      something if foo.present?

                      Use st_month.present? instead of !st_month.blank?.
                      Open

                          st_m = (!st_month.blank? and st_year.blank?)
                      Severity: Minor
                      Found in lib/utilities/dates.rb by rubocop

                      This cop checks for code that can be written with simpler conditionals using Object#present? defined by Active Support.

                      Interaction with Style/UnlessElse: The configuration of NotBlank will not produce an offense in the context of unless else if Style/UnlessElse is inabled. This is to prevent interference between the auto-correction of the two cops.

                      Example: NotNilAndNotEmpty: true (default)

                      # Converts usages of `!nil? && !empty?` to `present?`
                      
                      # bad
                      !foo.nil? && !foo.empty?
                      
                      # bad
                      foo != nil && !foo.empty?
                      
                      # good
                      foo.present?

                      Example: NotBlank: true (default)

                      # Converts usages of `!blank?` to `present?`
                      
                      # bad
                      !foo.blank?
                      
                      # bad
                      not foo.blank?
                      
                      # good
                      foo.present?

                      Example: UnlessBlank: true (default)

                      # Converts usages of `unless blank?` to `if present?`
                      
                      # bad
                      something unless foo.blank?
                      
                      # good
                      something if foo.present?

                      Do not use Date.today without zone. Use Time.zone.today instead.
                      Open

                              Date.parse(date[:start_date_year].to_s + '-' + date[:start_date_month].to_s + '-1') <= Date.today &&
                      Severity: Minor
                      Found in lib/utilities/dates.rb by rubocop

                      This cop checks for the correct use of Date methods, such as Date.today, Date.current etc.

                      Using Date.today is dangerous, because it doesn't know anything about Rails time zone. You must use Time.zone.today instead.

                      The cop also reports warnings when you are using to_time method, because it doesn't know about Rails time zone either.

                      Two styles are supported for this cop. When EnforcedStyle is 'strict' then the Date methods today, current, yesterday, and tomorrow are prohibited and the usage of both to_time and 'totimeincurrentzone' are reported as warning.

                      When EnforcedStyle is 'flexible' then only Date.today is prohibited and only to_time is reported as warning.

                      Example: EnforcedStyle: strict

                      # bad
                      Date.current
                      Date.yesterday
                      Date.today
                      date.to_time
                      
                      # good
                      Time.zone.today
                      Time.zone.today - 1.day

                      Example: EnforcedStyle: flexible (default)

                      # bad
                      Date.today
                      date.to_time
                      
                      # good
                      Time.zone.today
                      Time.zone.today - 1.day
                      Date.current
                      Date.yesterday
                      date.in_time_zone

                      Use st_year.present? instead of !st_year.blank?.
                      Open

                          st_my = (!st_month.blank? and !st_year.blank?)
                      Severity: Minor
                      Found in lib/utilities/dates.rb by rubocop

                      This cop checks for code that can be written with simpler conditionals using Object#present? defined by Active Support.

                      Interaction with Style/UnlessElse: The configuration of NotBlank will not produce an offense in the context of unless else if Style/UnlessElse is inabled. This is to prevent interference between the auto-correction of the two cops.

                      Example: NotNilAndNotEmpty: true (default)

                      # Converts usages of `!nil? && !empty?` to `present?`
                      
                      # bad
                      !foo.nil? && !foo.empty?
                      
                      # bad
                      foo != nil && !foo.empty?
                      
                      # good
                      foo.present?

                      Example: NotBlank: true (default)

                      # Converts usages of `!blank?` to `present?`
                      
                      # bad
                      !foo.blank?
                      
                      # bad
                      not foo.blank?
                      
                      # good
                      foo.present?

                      Example: UnlessBlank: true (default)

                      # Converts usages of `unless blank?` to `if present?`
                      
                      # bad
                      something unless foo.blank?
                      
                      # good
                      something if foo.present?

                      Use st_month.present? instead of !st_month.blank?.
                      Open

                          st_my = (!st_month.blank? and !st_year.blank?)
                      Severity: Minor
                      Found in lib/utilities/dates.rb by rubocop

                      This cop checks for code that can be written with simpler conditionals using Object#present? defined by Active Support.

                      Interaction with Style/UnlessElse: The configuration of NotBlank will not produce an offense in the context of unless else if Style/UnlessElse is inabled. This is to prevent interference between the auto-correction of the two cops.

                      Example: NotNilAndNotEmpty: true (default)

                      # Converts usages of `!nil? && !empty?` to `present?`
                      
                      # bad
                      !foo.nil? && !foo.empty?
                      
                      # bad
                      foo != nil && !foo.empty?
                      
                      # good
                      foo.present?

                      Example: NotBlank: true (default)

                      # Converts usages of `!blank?` to `present?`
                      
                      # bad
                      !foo.blank?
                      
                      # bad
                      not foo.blank?
                      
                      # good
                      foo.present?

                      Example: UnlessBlank: true (default)

                      # Converts usages of `unless blank?` to `if present?`
                      
                      # bad
                      something unless foo.blank?
                      
                      # good
                      something if foo.present?

                      Use st_year.present? instead of !st_year.blank?.
                      Open

                          st_y = (st_month.blank? and !st_year.blank?)
                      Severity: Minor
                      Found in lib/utilities/dates.rb by rubocop

                      This cop checks for code that can be written with simpler conditionals using Object#present? defined by Active Support.

                      Interaction with Style/UnlessElse: The configuration of NotBlank will not produce an offense in the context of unless else if Style/UnlessElse is inabled. This is to prevent interference between the auto-correction of the two cops.

                      Example: NotNilAndNotEmpty: true (default)

                      # Converts usages of `!nil? && !empty?` to `present?`
                      
                      # bad
                      !foo.nil? && !foo.empty?
                      
                      # bad
                      foo != nil && !foo.empty?
                      
                      # good
                      foo.present?

                      Example: NotBlank: true (default)

                      # Converts usages of `!blank?` to `present?`
                      
                      # bad
                      !foo.blank?
                      
                      # bad
                      not foo.blank?
                      
                      # good
                      foo.present?

                      Example: UnlessBlank: true (default)

                      # Converts usages of `unless blank?` to `if present?`
                      
                      # bad
                      something unless foo.blank?
                      
                      # good
                      something if foo.present?

                      TODO found
                      Open

                        # TODO: Write unit tests
                      Severity: Minor
                      Found in lib/utilities/dates.rb by fixme

                      TODO found
                      Open

                        # TODO: still needs more work for some date combinations
                      Severity: Minor
                      Found in lib/utilities/dates.rb by fixme

                      TODO found
                      Open

                      # TODO: Extract to gem
                      Severity: Minor
                      Found in lib/utilities/dates.rb by fixme

                      Similar blocks of code found in 2 locations. Consider refactoring.
                      Open

                          date[:end_date_month] = date[:end_date_month].gsub('january', '1')
                              .gsub('february', '2')
                              .gsub('march', '3')
                              .gsub('april', '4')
                              .gsub('may', '5')
                      Severity: Major
                      Found in lib/utilities/dates.rb and 1 other location - About 3 hrs to fix
                      lib/utilities/dates.rb on lines 818..853

                      Duplicated Code

                      Duplicated code can lead to software that is hard to understand and difficult to change. The Don't Repeat Yourself (DRY) principle states:

                      Every piece of knowledge must have a single, unambiguous, authoritative representation within a system.

                      When you violate DRY, bugs and maintenance problems are sure to follow. Duplicated code has a tendency to both continue to replicate and also to diverge (leaving bugs as two similar implementations differ in subtle ways).

                      Tuning

                      This issue has a mass of 118.

                      We set useful threshold defaults for the languages we support but you may want to adjust these settings based on your project guidelines.

                      The threshold configuration represents the minimum mass a code block must have to be analyzed for duplication. The lower the threshold, the more fine-grained the comparison.

                      If the engine is too easily reporting duplication, try raising the threshold. If you suspect that the engine isn't catching enough duplication, try lowering the threshold. The best setting tends to differ from language to language.

                      See codeclimate-duplication's documentation for more information about tuning the mass threshold in your .codeclimate.yml.

                      Refactorings

                      Further Reading

                      Similar blocks of code found in 2 locations. Consider refactoring.
                      Open

                          date[:start_date_month] = date[:start_date_month].gsub('january', '1')
                              .gsub('february', '2')
                              .gsub('march', '3')
                              .gsub('april', '4')
                              .gsub('may', '5')
                      Severity: Major
                      Found in lib/utilities/dates.rb and 1 other location - About 3 hrs to fix
                      lib/utilities/dates.rb on lines 855..890

                      Duplicated Code

                      Duplicated code can lead to software that is hard to understand and difficult to change. The Don't Repeat Yourself (DRY) principle states:

                      Every piece of knowledge must have a single, unambiguous, authoritative representation within a system.

                      When you violate DRY, bugs and maintenance problems are sure to follow. Duplicated code has a tendency to both continue to replicate and also to diverge (leaving bugs as two similar implementations differ in subtle ways).

                      Tuning

                      This issue has a mass of 118.

                      We set useful threshold defaults for the languages we support but you may want to adjust these settings based on your project guidelines.

                      The threshold configuration represents the minimum mass a code block must have to be analyzed for duplication. The lower the threshold, the more fine-grained the comparison.

                      If the engine is too easily reporting duplication, try raising the threshold. If you suspect that the engine isn't catching enough duplication, try lowering the threshold. The best setting tends to differ from language to language.

                      See codeclimate-duplication's documentation for more information about tuning the mass threshold in your .codeclimate.yml.

                      Refactorings

                      Further Reading

                      Similar blocks of code found in 2 locations. Consider refactoring.
                      Open

                          elsif matchdata1 = text.match(/\W(\d\d?)[-–—_\.,\/\s]\s?(\d\d?)[-–—_\.,\/\s]\s?(['´`ʹʼˊ]?\s?\d{2})\W/)
                            date[:verbatim_date] = matchdata1[0].strip
                            date[:start_date_day] = matchdata1[2]
                            date[:start_date_month] = matchdata1[1]
                            date[:start_date_year] = matchdata1[3]
                      Severity: Major
                      Found in lib/utilities/dates.rb and 1 other location - About 1 hr to fix
                      lib/utilities/elevation.rb on lines 18..27

                      Duplicated Code

                      Duplicated code can lead to software that is hard to understand and difficult to change. The Don't Repeat Yourself (DRY) principle states:

                      Every piece of knowledge must have a single, unambiguous, authoritative representation within a system.

                      When you violate DRY, bugs and maintenance problems are sure to follow. Duplicated code has a tendency to both continue to replicate and also to diverge (leaving bugs as two similar implementations differ in subtle ways).

                      Tuning

                      This issue has a mass of 56.

                      We set useful threshold defaults for the languages we support but you may want to adjust these settings based on your project guidelines.

                      The threshold configuration represents the minimum mass a code block must have to be analyzed for duplication. The lower the threshold, the more fine-grained the comparison.

                      If the engine is too easily reporting duplication, try raising the threshold. If you suspect that the engine isn't catching enough duplication, try lowering the threshold. The best setting tends to differ from language to language.

                      See codeclimate-duplication's documentation for more information about tuning the mass threshold in your .codeclimate.yml.

                      Refactorings

                      Further Reading

                      Similar blocks of code found in 10 locations. Consider refactoring.
                      Open

                            date[:verbatim_date] = matchdata1[0].strip
                            date[:start_date_day] = matchdata1[2]
                            date[:start_date_month] = matchdata1[1]
                            date[:start_date_year] = matchdata1[5]
                            date[:end_date_day]  = matchdata1[4]
                      Severity: Major
                      Found in lib/utilities/dates.rb and 9 other locations - About 55 mins to fix
                      lib/utilities/dates.rb on lines 686..692
                      lib/utilities/dates.rb on lines 695..701
                      lib/utilities/dates.rb on lines 704..710
                      lib/utilities/dates.rb on lines 722..728
                      lib/utilities/dates.rb on lines 731..737
                      lib/utilities/dates.rb on lines 740..746
                      lib/utilities/dates.rb on lines 749..755
                      lib/utilities/dates.rb on lines 759..765
                      lib/utilities/dates.rb on lines 769..775

                      Duplicated Code

                      Duplicated code can lead to software that is hard to understand and difficult to change. The Don't Repeat Yourself (DRY) principle states:

                      Every piece of knowledge must have a single, unambiguous, authoritative representation within a system.

                      When you violate DRY, bugs and maintenance problems are sure to follow. Duplicated code has a tendency to both continue to replicate and also to diverge (leaving bugs as two similar implementations differ in subtle ways).

                      Tuning

                      This issue has a mass of 44.

                      We set useful threshold defaults for the languages we support but you may want to adjust these settings based on your project guidelines.

                      The threshold configuration represents the minimum mass a code block must have to be analyzed for duplication. The lower the threshold, the more fine-grained the comparison.

                      If the engine is too easily reporting duplication, try raising the threshold. If you suspect that the engine isn't catching enough duplication, try lowering the threshold. The best setting tends to differ from language to language.

                      See codeclimate-duplication's documentation for more information about tuning the mass threshold in your .codeclimate.yml.

                      Refactorings

                      Further Reading

                      Similar blocks of code found in 10 locations. Consider refactoring.
                      Open

                            date[:verbatim_date] = matchdata1[0].strip
                            date[:start_date_day] = matchdata1[1]
                            date[:start_date_month] = matchdata1[3]
                            date[:start_date_year] = matchdata1[4]
                            date[:end_date_day]  = matchdata1[2]
                      Severity: Major
                      Found in lib/utilities/dates.rb and 9 other locations - About 55 mins to fix
                      lib/utilities/dates.rb on lines 686..692
                      lib/utilities/dates.rb on lines 695..701
                      lib/utilities/dates.rb on lines 704..710
                      lib/utilities/dates.rb on lines 713..719
                      lib/utilities/dates.rb on lines 722..728
                      lib/utilities/dates.rb on lines 731..737
                      lib/utilities/dates.rb on lines 740..746
                      lib/utilities/dates.rb on lines 749..755
                      lib/utilities/dates.rb on lines 769..775

                      Duplicated Code

                      Duplicated code can lead to software that is hard to understand and difficult to change. The Don't Repeat Yourself (DRY) principle states:

                      Every piece of knowledge must have a single, unambiguous, authoritative representation within a system.

                      When you violate DRY, bugs and maintenance problems are sure to follow. Duplicated code has a tendency to both continue to replicate and also to diverge (leaving bugs as two similar implementations differ in subtle ways).

                      Tuning

                      This issue has a mass of 44.

                      We set useful threshold defaults for the languages we support but you may want to adjust these settings based on your project guidelines.

                      The threshold configuration represents the minimum mass a code block must have to be analyzed for duplication. The lower the threshold, the more fine-grained the comparison.

                      If the engine is too easily reporting duplication, try raising the threshold. If you suspect that the engine isn't catching enough duplication, try lowering the threshold. The best setting tends to differ from language to language.

                      See codeclimate-duplication's documentation for more information about tuning the mass threshold in your .codeclimate.yml.

                      Refactorings

                      Further Reading

                      Similar blocks of code found in 10 locations. Consider refactoring.
                      Open

                            date[:verbatim_date] = matchdata1[0].strip
                            date[:start_date_day] = matchdata1[2]
                            date[:start_date_month] = matchdata1[1]
                            date[:start_date_year] = matchdata1[3]
                            date[:end_date_day]  = matchdata1[5]
                      Severity: Major
                      Found in lib/utilities/dates.rb and 9 other locations - About 55 mins to fix
                      lib/utilities/dates.rb on lines 695..701
                      lib/utilities/dates.rb on lines 704..710
                      lib/utilities/dates.rb on lines 713..719
                      lib/utilities/dates.rb on lines 722..728
                      lib/utilities/dates.rb on lines 731..737
                      lib/utilities/dates.rb on lines 740..746
                      lib/utilities/dates.rb on lines 749..755
                      lib/utilities/dates.rb on lines 759..765
                      lib/utilities/dates.rb on lines 769..775

                      Duplicated Code

                      Duplicated code can lead to software that is hard to understand and difficult to change. The Don't Repeat Yourself (DRY) principle states:

                      Every piece of knowledge must have a single, unambiguous, authoritative representation within a system.

                      When you violate DRY, bugs and maintenance problems are sure to follow. Duplicated code has a tendency to both continue to replicate and also to diverge (leaving bugs as two similar implementations differ in subtle ways).

                      Tuning

                      This issue has a mass of 44.

                      We set useful threshold defaults for the languages we support but you may want to adjust these settings based on your project guidelines.

                      The threshold configuration represents the minimum mass a code block must have to be analyzed for duplication. The lower the threshold, the more fine-grained the comparison.

                      If the engine is too easily reporting duplication, try raising the threshold. If you suspect that the engine isn't catching enough duplication, try lowering the threshold. The best setting tends to differ from language to language.

                      See codeclimate-duplication's documentation for more information about tuning the mass threshold in your .codeclimate.yml.

                      Refactorings

                      Further Reading

                      Similar blocks of code found in 10 locations. Consider refactoring.
                      Open

                            date[:verbatim_date] = matchdata1[0].strip
                            date[:start_date_day] = matchdata1[2]
                            date[:start_date_month] = matchdata1[1]
                            date[:start_date_year] = matchdata1[4]
                            date[:end_date_day]  = matchdata1[3]
                      Severity: Major
                      Found in lib/utilities/dates.rb and 9 other locations - About 55 mins to fix
                      lib/utilities/dates.rb on lines 686..692
                      lib/utilities/dates.rb on lines 695..701
                      lib/utilities/dates.rb on lines 704..710
                      lib/utilities/dates.rb on lines 713..719
                      lib/utilities/dates.rb on lines 722..728
                      lib/utilities/dates.rb on lines 731..737
                      lib/utilities/dates.rb on lines 740..746
                      lib/utilities/dates.rb on lines 749..755
                      lib/utilities/dates.rb on lines 759..765

                      Duplicated Code

                      Duplicated code can lead to software that is hard to understand and difficult to change. The Don't Repeat Yourself (DRY) principle states:

                      Every piece of knowledge must have a single, unambiguous, authoritative representation within a system.

                      When you violate DRY, bugs and maintenance problems are sure to follow. Duplicated code has a tendency to both continue to replicate and also to diverge (leaving bugs as two similar implementations differ in subtle ways).

                      Tuning

                      This issue has a mass of 44.

                      We set useful threshold defaults for the languages we support but you may want to adjust these settings based on your project guidelines.

                      The threshold configuration represents the minimum mass a code block must have to be analyzed for duplication. The lower the threshold, the more fine-grained the comparison.

                      If the engine is too easily reporting duplication, try raising the threshold. If you suspect that the engine isn't catching enough duplication, try lowering the threshold. The best setting tends to differ from language to language.

                      See codeclimate-duplication's documentation for more information about tuning the mass threshold in your .codeclimate.yml.

                      Refactorings

                      Further Reading

                      Similar blocks of code found in 10 locations. Consider refactoring.
                      Open

                            date[:verbatim_date] = matchdata1[0].strip
                            date[:start_date_day] = matchdata1[2]
                            date[:start_date_month] = matchdata1[1]
                            date[:start_date_year] = matchdata1[3]
                            date[:end_date_day]  = matchdata1[5]
                      Severity: Major
                      Found in lib/utilities/dates.rb and 9 other locations - About 55 mins to fix
                      lib/utilities/dates.rb on lines 686..692
                      lib/utilities/dates.rb on lines 695..701
                      lib/utilities/dates.rb on lines 713..719
                      lib/utilities/dates.rb on lines 722..728
                      lib/utilities/dates.rb on lines 731..737
                      lib/utilities/dates.rb on lines 740..746
                      lib/utilities/dates.rb on lines 749..755
                      lib/utilities/dates.rb on lines 759..765
                      lib/utilities/dates.rb on lines 769..775

                      Duplicated Code

                      Duplicated code can lead to software that is hard to understand and difficult to change. The Don't Repeat Yourself (DRY) principle states:

                      Every piece of knowledge must have a single, unambiguous, authoritative representation within a system.

                      When you violate DRY, bugs and maintenance problems are sure to follow. Duplicated code has a tendency to both continue to replicate and also to diverge (leaving bugs as two similar implementations differ in subtle ways).

                      Tuning

                      This issue has a mass of 44.

                      We set useful threshold defaults for the languages we support but you may want to adjust these settings based on your project guidelines.

                      The threshold configuration represents the minimum mass a code block must have to be analyzed for duplication. The lower the threshold, the more fine-grained the comparison.

                      If the engine is too easily reporting duplication, try raising the threshold. If you suspect that the engine isn't catching enough duplication, try lowering the threshold. The best setting tends to differ from language to language.

                      See codeclimate-duplication's documentation for more information about tuning the mass threshold in your .codeclimate.yml.

                      Refactorings

                      Further Reading

                      Similar blocks of code found in 10 locations. Consider refactoring.
                      Open

                            date[:verbatim_date] = matchdata1[0].strip
                            date[:start_date_day] = matchdata1[1]
                            date[:start_date_month] = matchdata1[2]
                            date[:start_date_year] = matchdata1[5]
                            date[:end_date_day]  = matchdata1[3]
                      Severity: Major
                      Found in lib/utilities/dates.rb and 9 other locations - About 55 mins to fix
                      lib/utilities/dates.rb on lines 686..692
                      lib/utilities/dates.rb on lines 695..701
                      lib/utilities/dates.rb on lines 704..710
                      lib/utilities/dates.rb on lines 713..719
                      lib/utilities/dates.rb on lines 731..737
                      lib/utilities/dates.rb on lines 740..746
                      lib/utilities/dates.rb on lines 749..755
                      lib/utilities/dates.rb on lines 759..765
                      lib/utilities/dates.rb on lines 769..775

                      Duplicated Code

                      Duplicated code can lead to software that is hard to understand and difficult to change. The Don't Repeat Yourself (DRY) principle states:

                      Every piece of knowledge must have a single, unambiguous, authoritative representation within a system.

                      When you violate DRY, bugs and maintenance problems are sure to follow. Duplicated code has a tendency to both continue to replicate and also to diverge (leaving bugs as two similar implementations differ in subtle ways).

                      Tuning

                      This issue has a mass of 44.

                      We set useful threshold defaults for the languages we support but you may want to adjust these settings based on your project guidelines.

                      The threshold configuration represents the minimum mass a code block must have to be analyzed for duplication. The lower the threshold, the more fine-grained the comparison.

                      If the engine is too easily reporting duplication, try raising the threshold. If you suspect that the engine isn't catching enough duplication, try lowering the threshold. The best setting tends to differ from language to language.

                      See codeclimate-duplication's documentation for more information about tuning the mass threshold in your .codeclimate.yml.

                      Refactorings

                      Further Reading

                      Similar blocks of code found in 10 locations. Consider refactoring.
                      Open

                            date[:verbatim_date] = matchdata1[0].strip
                            date[:start_date_day] = matchdata1[2]
                            date[:start_date_month] = matchdata1[1]
                            date[:start_date_year] = matchdata1[5]
                            date[:end_date_day]  = matchdata1[4]
                      Severity: Major
                      Found in lib/utilities/dates.rb and 9 other locations - About 55 mins to fix
                      lib/utilities/dates.rb on lines 686..692
                      lib/utilities/dates.rb on lines 695..701
                      lib/utilities/dates.rb on lines 704..710
                      lib/utilities/dates.rb on lines 713..719
                      lib/utilities/dates.rb on lines 722..728
                      lib/utilities/dates.rb on lines 740..746
                      lib/utilities/dates.rb on lines 749..755
                      lib/utilities/dates.rb on lines 759..765
                      lib/utilities/dates.rb on lines 769..775

                      Duplicated Code

                      Duplicated code can lead to software that is hard to understand and difficult to change. The Don't Repeat Yourself (DRY) principle states:

                      Every piece of knowledge must have a single, unambiguous, authoritative representation within a system.

                      When you violate DRY, bugs and maintenance problems are sure to follow. Duplicated code has a tendency to both continue to replicate and also to diverge (leaving bugs as two similar implementations differ in subtle ways).

                      Tuning

                      This issue has a mass of 44.

                      We set useful threshold defaults for the languages we support but you may want to adjust these settings based on your project guidelines.

                      The threshold configuration represents the minimum mass a code block must have to be analyzed for duplication. The lower the threshold, the more fine-grained the comparison.

                      If the engine is too easily reporting duplication, try raising the threshold. If you suspect that the engine isn't catching enough duplication, try lowering the threshold. The best setting tends to differ from language to language.

                      See codeclimate-duplication's documentation for more information about tuning the mass threshold in your .codeclimate.yml.

                      Refactorings

                      Further Reading

                      Similar blocks of code found in 10 locations. Consider refactoring.
                      Open

                            date[:verbatim_date] = matchdata1[0].strip
                            date[:start_date_day] = matchdata1[2]
                            date[:start_date_month] = matchdata1[1]
                            date[:start_date_year] = matchdata1[4]
                            date[:end_date_day]  = matchdata1[3]
                      Severity: Major
                      Found in lib/utilities/dates.rb and 9 other locations - About 55 mins to fix
                      lib/utilities/dates.rb on lines 686..692
                      lib/utilities/dates.rb on lines 695..701
                      lib/utilities/dates.rb on lines 704..710
                      lib/utilities/dates.rb on lines 713..719
                      lib/utilities/dates.rb on lines 722..728
                      lib/utilities/dates.rb on lines 731..737
                      lib/utilities/dates.rb on lines 749..755
                      lib/utilities/dates.rb on lines 759..765
                      lib/utilities/dates.rb on lines 769..775

                      Duplicated Code

                      Duplicated code can lead to software that is hard to understand and difficult to change. The Don't Repeat Yourself (DRY) principle states:

                      Every piece of knowledge must have a single, unambiguous, authoritative representation within a system.

                      When you violate DRY, bugs and maintenance problems are sure to follow. Duplicated code has a tendency to both continue to replicate and also to diverge (leaving bugs as two similar implementations differ in subtle ways).

                      Tuning

                      This issue has a mass of 44.

                      We set useful threshold defaults for the languages we support but you may want to adjust these settings based on your project guidelines.

                      The threshold configuration represents the minimum mass a code block must have to be analyzed for duplication. The lower the threshold, the more fine-grained the comparison.

                      If the engine is too easily reporting duplication, try raising the threshold. If you suspect that the engine isn't catching enough duplication, try lowering the threshold. The best setting tends to differ from language to language.

                      See codeclimate-duplication's documentation for more information about tuning the mass threshold in your .codeclimate.yml.

                      Refactorings

                      Further Reading

                      Similar blocks of code found in 10 locations. Consider refactoring.
                      Open

                            date[:verbatim_date] = matchdata1[0].strip
                            date[:start_date_day] = matchdata1[1]
                            date[:start_date_month] = matchdata1[2]
                            date[:start_date_year] = matchdata1[3]
                            date[:end_date_day]  = matchdata1[4]
                      Severity: Major
                      Found in lib/utilities/dates.rb and 9 other locations - About 55 mins to fix
                      lib/utilities/dates.rb on lines 686..692
                      lib/utilities/dates.rb on lines 704..710
                      lib/utilities/dates.rb on lines 713..719
                      lib/utilities/dates.rb on lines 722..728
                      lib/utilities/dates.rb on lines 731..737
                      lib/utilities/dates.rb on lines 740..746
                      lib/utilities/dates.rb on lines 749..755
                      lib/utilities/dates.rb on lines 759..765
                      lib/utilities/dates.rb on lines 769..775

                      Duplicated Code

                      Duplicated code can lead to software that is hard to understand and difficult to change. The Don't Repeat Yourself (DRY) principle states:

                      Every piece of knowledge must have a single, unambiguous, authoritative representation within a system.

                      When you violate DRY, bugs and maintenance problems are sure to follow. Duplicated code has a tendency to both continue to replicate and also to diverge (leaving bugs as two similar implementations differ in subtle ways).

                      Tuning

                      This issue has a mass of 44.

                      We set useful threshold defaults for the languages we support but you may want to adjust these settings based on your project guidelines.

                      The threshold configuration represents the minimum mass a code block must have to be analyzed for duplication. The lower the threshold, the more fine-grained the comparison.

                      If the engine is too easily reporting duplication, try raising the threshold. If you suspect that the engine isn't catching enough duplication, try lowering the threshold. The best setting tends to differ from language to language.

                      See codeclimate-duplication's documentation for more information about tuning the mass threshold in your .codeclimate.yml.

                      Refactorings

                      Further Reading

                      Similar blocks of code found in 10 locations. Consider refactoring.
                      Open

                            date[:verbatim_date] = matchdata1[0].strip
                            date[:start_date_day] = matchdata1[1]
                            date[:start_date_month] = matchdata1[3]
                            date[:start_date_year] = matchdata1[4]
                            date[:end_date_day]  = matchdata1[2]
                      Severity: Major
                      Found in lib/utilities/dates.rb and 9 other locations - About 55 mins to fix
                      lib/utilities/dates.rb on lines 686..692
                      lib/utilities/dates.rb on lines 695..701
                      lib/utilities/dates.rb on lines 704..710
                      lib/utilities/dates.rb on lines 713..719
                      lib/utilities/dates.rb on lines 722..728
                      lib/utilities/dates.rb on lines 731..737
                      lib/utilities/dates.rb on lines 740..746
                      lib/utilities/dates.rb on lines 759..765
                      lib/utilities/dates.rb on lines 769..775

                      Duplicated Code

                      Duplicated code can lead to software that is hard to understand and difficult to change. The Don't Repeat Yourself (DRY) principle states:

                      Every piece of knowledge must have a single, unambiguous, authoritative representation within a system.

                      When you violate DRY, bugs and maintenance problems are sure to follow. Duplicated code has a tendency to both continue to replicate and also to diverge (leaving bugs as two similar implementations differ in subtle ways).

                      Tuning

                      This issue has a mass of 44.

                      We set useful threshold defaults for the languages we support but you may want to adjust these settings based on your project guidelines.

                      The threshold configuration represents the minimum mass a code block must have to be analyzed for duplication. The lower the threshold, the more fine-grained the comparison.

                      If the engine is too easily reporting duplication, try raising the threshold. If you suspect that the engine isn't catching enough duplication, try lowering the threshold. The best setting tends to differ from language to language.

                      See codeclimate-duplication's documentation for more information about tuning the mass threshold in your .codeclimate.yml.

                      Refactorings

                      Further Reading

                      Similar blocks of code found in 2 locations. Consider refactoring.
                      Open

                          if date[:start_date_year] && date[:start_date_year].length >=2 && date[:start_date_year].length < 4
                            y = date[:start_date_year].last(2)
                            if y.to_i >= 90
                              y = '18' + y
                            else
                      Severity: Minor
                      Found in lib/utilities/dates.rb and 1 other location - About 50 mins to fix
                      lib/utilities/dates.rb on lines 926..934

                      Duplicated Code

                      Duplicated code can lead to software that is hard to understand and difficult to change. The Don't Repeat Yourself (DRY) principle states:

                      Every piece of knowledge must have a single, unambiguous, authoritative representation within a system.

                      When you violate DRY, bugs and maintenance problems are sure to follow. Duplicated code has a tendency to both continue to replicate and also to diverge (leaving bugs as two similar implementations differ in subtle ways).

                      Tuning

                      This issue has a mass of 42.

                      We set useful threshold defaults for the languages we support but you may want to adjust these settings based on your project guidelines.

                      The threshold configuration represents the minimum mass a code block must have to be analyzed for duplication. The lower the threshold, the more fine-grained the comparison.

                      If the engine is too easily reporting duplication, try raising the threshold. If you suspect that the engine isn't catching enough duplication, try lowering the threshold. The best setting tends to differ from language to language.

                      See codeclimate-duplication's documentation for more information about tuning the mass threshold in your .codeclimate.yml.

                      Refactorings

                      Further Reading

                      Similar blocks of code found in 2 locations. Consider refactoring.
                      Open

                          if date[:end_date_year] && date[:end_date_year].length >=2 && date[:end_date_year].length < 4
                            y = date[:end_date_year].last(2)
                            if y.to_i >= 90
                              y = '18' + y
                            else
                      Severity: Minor
                      Found in lib/utilities/dates.rb and 1 other location - About 50 mins to fix
                      lib/utilities/dates.rb on lines 917..925

                      Duplicated Code

                      Duplicated code can lead to software that is hard to understand and difficult to change. The Don't Repeat Yourself (DRY) principle states:

                      Every piece of knowledge must have a single, unambiguous, authoritative representation within a system.

                      When you violate DRY, bugs and maintenance problems are sure to follow. Duplicated code has a tendency to both continue to replicate and also to diverge (leaving bugs as two similar implementations differ in subtle ways).

                      Tuning

                      This issue has a mass of 42.

                      We set useful threshold defaults for the languages we support but you may want to adjust these settings based on your project guidelines.

                      The threshold configuration represents the minimum mass a code block must have to be analyzed for duplication. The lower the threshold, the more fine-grained the comparison.

                      If the engine is too easily reporting duplication, try raising the threshold. If you suspect that the engine isn't catching enough duplication, try lowering the threshold. The best setting tends to differ from language to language.

                      See codeclimate-duplication's documentation for more information about tuning the mass threshold in your .codeclimate.yml.

                      Refactorings

                      Further Reading

                      Re-enable Metrics/MethodLength cop with # rubocop:enable after disabling it.
                      Open

                        # rubocop:disable Metrics/MethodLength
                      Severity: Minor
                      Found in lib/utilities/dates.rb by rubocop

                      Do not use Time.new without zone. Use one of Time.zone.local, Time.current, Time.new.in_time_zone, Time.new.utc, Time.new.getlocal, Time.new.xmlschema, Time.new.iso8601, Time.new.jisx0301, Time.new.rfc3339, Time.new.httpdate, Time.new.to_i, Time.new.to_f instead.
                      Open

                          start = Time.new(1970, 1, 1)
                      Severity: Minor
                      Found in lib/utilities/dates.rb by rubocop

                      This cop checks for the use of Time methods without zone.

                      Built on top of Ruby on Rails style guide (https://github.com/rubocop-hq/rails-style-guide#time) and the article http://danilenko.org/2012/7/6/rails_timezones/

                      Two styles are supported for this cop. When EnforcedStyle is 'strict' then only use of Time.zone is allowed.

                      When EnforcedStyle is 'flexible' then it's also allowed to use Time.intimezone.

                      Example: EnforcedStyle: strict

                      # `strict` means that `Time` should be used with `zone`.
                      
                      # bad
                      Time.now
                      Time.parse('2015-03-02 19:05:37')
                      
                      # bad
                      Time.current
                      Time.at(timestamp).in_time_zone
                      
                      # good
                      Time.zone.now
                      Time.zone.parse('2015-03-02 19:05:37')

                      Example: EnforcedStyle: flexible (default)

                      # `flexible` allows usage of `in_time_zone` instead of `zone`.
                      
                      # bad
                      Time.now
                      Time.parse('2015-03-02 19:05:37')
                      
                      # good
                      Time.zone.now
                      Time.zone.parse('2015-03-02 19:05:37')
                      
                      # good
                      Time.current
                      Time.at(timestamp).in_time_zone

                      Useless private access modifier.
                      Open

                        private
                      Severity: Minor
                      Found in lib/utilities/dates.rb by rubocop

                      This cop checks for redundant access modifiers, including those with no code, those which are repeated, and leading public modifiers in a class or module body. Conditionally-defined methods are considered as always being defined, and thus access modifiers guarding such methods are not redundant.

                      Example:

                      class Foo
                        public # this is redundant (default access is public)
                      
                        def method
                        end
                      
                        private # this is not redundant (a method is defined)
                        def method2
                        end
                      
                        private # this is redundant (no following methods are defined)
                      end

                      Example:

                      class Foo
                        # The following is not redundant (conditionally defined methods are
                        # considered as always defining a method)
                        private
                      
                        if condition?
                          def method
                          end
                        end
                      
                        protected # this is not redundant (method is defined)
                      
                        define_method(:method2) do
                        end
                      
                        protected # this is redundant (repeated from previous modifier)
                      
                        [1,2,3].each do |i|
                          define_method("foo#{i}") do
                          end
                        end
                      
                        # The following is redundant (methods defined on the class'
                        # singleton class are not affected by the public modifier)
                        public
                      
                        def self.method3
                        end
                      end

                      Example:

                      # Lint/UselessAccessModifier:
                      #   ContextCreatingMethods:
                      #     - concerning
                      require 'active_support/concern'
                      class Foo
                        concerning :Bar do
                          def some_public_method
                          end
                      
                          private
                      
                          def some_private_method
                          end
                        end
                      
                        # this is not redundant because `concerning` created its own context
                        private
                      
                        def some_other_private_method
                        end
                      end

                      Example:

                      # Lint/UselessAccessModifier:
                      #   MethodCreatingMethods:
                      #     - delegate
                      require 'active_support/core_ext/module/delegation'
                      class Foo
                        # this is not redundant because `delegate` creates methods
                        private
                      
                        delegate :method_a, to: :method_b
                      end

                      Do not use Time.new without zone. Use one of Time.zone.local, Time.current, Time.new.in_time_zone, Time.new.utc, Time.new.getlocal, Time.new.xmlschema, Time.new.iso8601, Time.new.jisx0301, Time.new.rfc3339, Time.new.httpdate, Time.new.to_i, Time.new.to_f instead.
                      Open

                          Time.new(year, month, day)
                      Severity: Minor
                      Found in lib/utilities/dates.rb by rubocop

                      This cop checks for the use of Time methods without zone.

                      Built on top of Ruby on Rails style guide (https://github.com/rubocop-hq/rails-style-guide#time) and the article http://danilenko.org/2012/7/6/rails_timezones/

                      Two styles are supported for this cop. When EnforcedStyle is 'strict' then only use of Time.zone is allowed.

                      When EnforcedStyle is 'flexible' then it's also allowed to use Time.intimezone.

                      Example: EnforcedStyle: strict

                      # `strict` means that `Time` should be used with `zone`.
                      
                      # bad
                      Time.now
                      Time.parse('2015-03-02 19:05:37')
                      
                      # bad
                      Time.current
                      Time.at(timestamp).in_time_zone
                      
                      # good
                      Time.zone.now
                      Time.zone.parse('2015-03-02 19:05:37')

                      Example: EnforcedStyle: flexible (default)

                      # `flexible` allows usage of `in_time_zone` instead of `zone`.
                      
                      # bad
                      Time.now
                      Time.parse('2015-03-02 19:05:37')
                      
                      # good
                      Time.zone.now
                      Time.zone.parse('2015-03-02 19:05:37')
                      
                      # good
                      Time.current
                      Time.at(timestamp).in_time_zone

                      Use 2 (not 4) spaces for indentation.
                      Open

                                Date.valid_date?(date[:end_date_year].to_i, date[:end_date_month].to_i, 1) &&
                      Severity: Minor
                      Found in lib/utilities/dates.rb by rubocop

                      This cop checks for indentation that doesn't use the specified number of spaces.

                      See also the IndentationConsistency cop which is the companion to this one.

                      Example:

                      # bad
                      class A
                       def test
                        puts 'hello'
                       end
                      end
                      
                      # good
                      class A
                        def test
                          puts 'hello'
                        end
                      end

                      Example: IgnoredPatterns: ['^\s*module']

                      # bad
                      module A
                      class B
                        def test
                        puts 'hello'
                        end
                      end
                      end
                      
                      # good
                      module A
                      class B
                        def test
                          puts 'hello'
                        end
                      end
                      end

                      Do not use Time.now without zone. Use one of Time.zone.now, Time.current, Time.now.in_time_zone, Time.now.utc, Time.now.getlocal, Time.now.xmlschema, Time.now.iso8601, Time.now.jisx0301, Time.now.rfc3339, Time.now.httpdate, Time.now.to_i, Time.now.to_f instead.
                      Open

                              tny = Time.now.year
                      Severity: Minor
                      Found in lib/utilities/dates.rb by rubocop

                      This cop checks for the use of Time methods without zone.

                      Built on top of Ruby on Rails style guide (https://github.com/rubocop-hq/rails-style-guide#time) and the article http://danilenko.org/2012/7/6/rails_timezones/

                      Two styles are supported for this cop. When EnforcedStyle is 'strict' then only use of Time.zone is allowed.

                      When EnforcedStyle is 'flexible' then it's also allowed to use Time.intimezone.

                      Example: EnforcedStyle: strict

                      # `strict` means that `Time` should be used with `zone`.
                      
                      # bad
                      Time.now
                      Time.parse('2015-03-02 19:05:37')
                      
                      # bad
                      Time.current
                      Time.at(timestamp).in_time_zone
                      
                      # good
                      Time.zone.now
                      Time.zone.parse('2015-03-02 19:05:37')

                      Example: EnforcedStyle: flexible (default)

                      # `flexible` allows usage of `in_time_zone` instead of `zone`.
                      
                      # bad
                      Time.now
                      Time.parse('2015-03-02 19:05:37')
                      
                      # good
                      Time.zone.now
                      Time.zone.parse('2015-03-02 19:05:37')
                      
                      # good
                      Time.current
                      Time.at(timestamp).in_time_zone

                      There are no issues that match your filters.

                      Category
                      Status