rcharts 0.1.0 → 0.1.1

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA256:
-  metadata.gz: 256aeff9d84f681b225b1a35cd613367c65e2406caf8ba1815214e690dc462a1
-  data.tar.gz: a2de1b9873a98beaa5e7d0cec25042a8a59d36ed6998d9f8005f48f9eb20e4c3
+  metadata.gz: 15185c259bd39b4d6a998939a98356bf1513693e521ed693cb80907f8aab593e
+  data.tar.gz: acdb9c9f5f0d2c8336b22e78f7f49f3868485b112bb652e854f34bfeacdcd3f3
 SHA512:
-  metadata.gz: 531cd70794162b29f5b87c79ef64ea87ceb43f6b60d5f2967dfff5cbb723d9315084615bb353324fdc80c25d3f6dffea42913ac1254dd48ff89aba0b49cd80c2
-  data.tar.gz: 907ab23d72f376f6c8f15584ce4e54bf0386d7e2d85affb9fa0576ec01374866c04db8bd0a1c1afad98ede4b94f7ddfc6f698bad1e65889fdc866d38b9786aff
+  metadata.gz: 5a8e3de34d0ec122623157e9f6334c46185403b93949d541e7184841e0ded9e7479dd7b09961c26c51e71c0eceed39e72cd24974252ab42bb937c03c11dac8a7
+  data.tar.gz: 4c83d7996aedaab2a5442c1b299ed020d5c8ff2e5ebdf16646e5d0304a12591ff2f9d6c2c245e917cd1dd4141599e1cdbeed567efcb050d65244c65d5c7cbfe2

data/app/helpers/rcharts/graph_helper/graph/axis/caster.rb

@@ -5,6 +5,8 @@ module RCharts
     module Graph
       class Axis
         class Caster # :nodoc:
+          EPOCH_OFFSET = Time.at(0, in: 'Z').to_date.jd
+
           def initialize(value)
             @value = value
           end
@@ -16,7 +18,7 @@ module RCharts
           def downcast
             case value
             when Time then value.to_i
-            when Date then value.jd + value.day_fraction
+            when Date then julian_days.to_i
             else value
             end
           end
@@ -28,13 +30,26 @@ module RCharts
           def upcast(raw)
             case value
             when ActiveSupport::TimeWithZone then value.time_zone.at(raw)
-            when Time then Time.at(raw, in: value_zone)
-            when DateTime then DateTime.jd(0, 0, 0, 0, value.offset, value.start) + raw
-            when Date then Date.jd(raw, value.start)
+            when Time then value.class.at(raw, in: value_zone)
+            when Date then upcast_date(raw)
             else raw
             end
           end
 
+          def upcast_date(raw)
+            raw.seconds.in_days.divmod(1).then do |days, fraction|
+              value.class.jd(EPOCH_OFFSET + days, *datetime_args, value.start) + fraction
+            end
+          end
+
+          def datetime_args
+            [0, 0, 0, value.offset] if value.is_a?(DateTime)
+          end
+
+          def julian_days
+            ((value.jd - EPOCH_OFFSET) + (value.day_fraction - value.try(:offset).to_f)).days
+          end
+
           def value_zone
             value.zone.try { ActiveSupport::TimeZone[it] } || value.utc_offset
           end

data/app/helpers/rcharts/graph_helper/graph/axis/domain.rb

@@ -0,0 +1,84 @@
+# frozen_string_literal: true
+
+module RCharts
+  module GraphHelper
+    module Graph
+      class Axis
+        class Domain # :nodoc:
+          FLOOR_ALIGNMENT = { ...(2.days.to_i) => -> { it.beginning_of_day },
+                              (2.days.to_i)...(2.weeks.to_i) => -> { it.beginning_of_week },
+                              (2.weeks.to_i)...(2.months.to_i) => -> { it.beginning_of_month },
+                              (2.months.to_i)...(4.months.to_i) => -> { it.beginning_of_quarter },
+                              (4.months.to_i)...(10.months.to_i) => -> { it.beginning_of_year.advance(months: it.month < 7 ? 0 : 6) },
+                              (10.months.to_i)... => -> { it.beginning_of_year } }.freeze
+          MODES = %i[exact rounded].freeze
+
+          def initialize(minimum:, maximum:, tick_interval:, mode:)
+            @minimum = minimum
+            @maximum = maximum
+            @tick_interval = tick_interval
+            @mode = mode.presence_in(MODES) || raise(ArgumentError, "mode must be one of #{MODES.collect(&:inspect).join(', ')}")
+          end
+
+          def domain_minimum
+            return minimum if exact?
+
+            adjusted_minimum
+          end
+
+          def domain_maximum
+            return maximum if exact?
+
+            adjusted_maximum
+          end
+
+          def exact?
+            mode == :exact
+          end
+
+          def rounded?
+            mode == :rounded
+          end
+
+          private
+
+          attr_reader :minimum, :maximum, :tick_interval, :mode
+
+          def adjusted_minimum
+            @adjusted_minimum ||= calculate_adjusted_minimum
+          end
+
+          def calculate_adjusted_minimum
+            return minimum if tick_interval.zero?
+            return calendar_boundary_for(minimum, tick_interval) if temporal_data?
+
+            Caster.new(minimum).casting { (it / tick_interval).floor * tick_interval }
+          end
+
+          def adjusted_maximum
+            @adjusted_maximum ||= adjusted_minimum + (tick_count * tick_interval)
+          end
+
+          def tick_count
+            @tick_count ||= tick_interval.zero? ? 0 : (tick_count_range / tick_interval).ceil
+          end
+
+          def tick_count_range
+            temporal_data? ? (maximum.to_time - adjusted_minimum.to_time).abs : (maximum - adjusted_minimum).to_f
+          end
+
+          def temporal_data?
+            minimum.acts_like?(:time) || minimum.acts_like?(:date)
+          end
+
+          def calendar_boundary_for(value, interval)
+            FLOOR_ALIGNMENT.detect { |range, _| range.cover?(interval) }
+                           .last
+                           .call(value.to_time)
+                           .then { value.acts_like?(:date) ? it.to_date : it }
+          end
+        end
+      end
+    end
+  end
+end

data/app/helpers/rcharts/graph_helper/graph/axis/positioning.rb

@@ -5,6 +5,18 @@ module RCharts
     module Graph
       class Axis
         module Positioning # :nodoc:
+          QUANTIZATION = { ...(5.days) => :adjusted_minimum,
+                           (5.days)...(2.weeks) => :week_start,
+                           (2.weeks)...(2.months) => :month_start,
+                           (2.months)...(4.months) => :quarter_start,
+                           (4.months)...(10.months) => :half_year_start,
+                           (10.months)... => :year_start }.freeze
+          ROUNDING = { ...(1.day) => -> { it },
+                       (1.day)...(7.days) => -> { it.in_days.round.days },
+                       (7.days)...(1.month) => -> { it.in_weeks.round.weeks },
+                       (1.month)...(1.year) => -> { it.in_months.round.months },
+                       (1.year)... => -> { it.in_years.round.years } }.freeze
+
           extend ActiveSupport::Concern
           include Ticks
 
@@ -12,20 +24,16 @@ module RCharts
             def ticks
               return {} unless values.any?
 
-              @ticks ||= tick_count.succ.times.to_h { [position_at(it), value_at(it)] }
-            end
-
-            def position_at(index)
-              return if index > tick_count
-
-              ((index * (100.0 / (tick_count.nonzero? || 1))) + tick_offset.to_f) * (100 / (100 + (2 * tick_offset.to_f)))
+              @ticks ||= Array.new(tick_count.succ) { value_at(it) }
+                              .reject { it.nil? || it > adjusted_maximum }
+                              .index_by { position_for(it) }
             end
 
             def value_at(index)
               return if index > tick_count || index.negative? || values.empty?
-              return values.dig(index, 0) if discrete || values.dig(0, 0).is_a?(String)
+              return values.dig(index, 0) if discrete
 
-              adjusted_minimum + (index * tick_interval)
+              quantized_adjusted_minimum + (index * rounded_tick_interval)
             end
 
             def length_between(min, max)
@@ -41,22 +49,67 @@ module RCharts
               downcasted_position_for(value)
             end
 
+            def position_at(index)
+              return if index > tick_count
+
+              (tick_offset.to_f + raw_position_at(index))
+            end
+
             private
 
+            def raw_position_at(index)
+              index * (100.0 / ((categorical? ? values_count.nonzero? : tick_count.nonzero?) || 1))
+            end
+
             def downcasted_position_for(value)
-              ((Caster.new(value).downcast.to_f - casted_adjusted_minimum) / casted_range) * 100
+              ((Caster.new(value).downcast.to_f - Caster.new(adjusted_minimum).downcast) / casted_range) * 100
             end
 
             def casted_range
-              casted_adjusted_maximum - casted_adjusted_minimum
+              Caster.new(adjusted_maximum).downcast - Caster.new(adjusted_minimum).downcast
             end
 
-            def casted_adjusted_maximum
-              Caster.new(adjusted_maximum).downcast
+            def rounded_tick_interval
+              return tick_interval unless temporal_data?
+
+              ROUNDING.detect { |range, _value| range.cover?(tick_interval) }
+                      .last
+                      .call(tick_interval)
+            end
+
+            def quantized_adjusted_minimum
+              return adjusted_minimum unless temporal_data?
+
+              QUANTIZATION.detect { |range, _value| range.cover?(tick_interval) }
+                          .last
+                          .then { send(it) }
+                          .then { tick_interval < 1.day ? it.to_time : it }
+            end
+
+            def week_start
+              adjusted_minimum.days_to_week_start.zero? ? adjusted_minimum.beginning_of_week : adjusted_minimum.next_week
+            end
+
+            def month_start
+              adjusted_minimum.mday == 1 ? adjusted_minimum.beginning_of_month : adjusted_minimum.next_month.beginning_of_month
+            end
+
+            def quarter_start
+              if adjusted_minimum.yday == adjusted_minimum.beginning_of_quarter.yday
+                adjusted_minimum.beginning_of_quarter
+              else
+                adjusted_minimum.next_quarter.beginning_of_quarter
+              end
+            end
+
+            def half_year_start
+              return adjusted_minimum if adjusted_minimum.month.modulo(6) == 1 && adjusted_minimum.mday == 1
+
+              adjusted_minimum.beginning_of_year.advance(months: adjusted_minimum.month < 7 ? 6 : 12)
             end
 
-            def casted_adjusted_minimum
-              Caster.new(adjusted_minimum).downcast
+            def year_start
+              adjusted_minimum.yday == 1 ? adjusted_minimum.beginning_of_year : adjusted_minimum.next_year.beginning_of_year
             end
           end
         end

data/app/helpers/rcharts/graph_helper/graph/axis/ticks.rb

@@ -5,27 +5,56 @@ module RCharts
     module Graph
       class Axis
         module Ticks # :nodoc:
-          INTERVAL_FACTORS = [1, 2, 5, 10, 30].freeze
-          INTERVAL_BASES = ActiveSupport::Duration::PARTS_IN_SECONDS
-          ALL_INTERVALS = INTERVAL_BASES.values.flat_map { |base| INTERVAL_FACTORS.collect { base * it } }
+          DECIMAL_INTERVALS = [1, 2, 2.5, 5, 10].freeze
+          TEMPORAL_INTERVALS = [1.second, 2.seconds, 5.seconds, 10.seconds, 15.seconds, 30.seconds,
+                                1.minute, 2.minutes, 5.minutes, 10.minutes, 15.minutes, 30.minutes,
+                                1.hour, 2.hours, 3.hours, 6.hours, 12.hours,
+                                1.day, 2.days,
+                                1.week, 2.weeks,
+                                1.month, 2.months, 3.months, 6.months,
+                                1.year, 2.years, 5.years, 10.years, 20.years, 50.years, 100.years].freeze
+          TARGET_TICK_COUNT = 10.0
 
           extend ActiveSupport::Concern
 
           included do
             def tick_count
-              return values_count.pred if discrete?
+              return values_count.pred if categorical?
+              return values_count if discrete?
 
-              ((maximum - adjusted_minimum) / tick_interval).ceil
+              (range / tick_interval.to_f).ceil
             end
 
             def adjusted_minimum
-              @adjusted_minimum ||= Caster.new(minimum).casting { (it / tick_interval).floor * tick_interval }
+              @adjusted_minimum ||= domain.domain_minimum
+            end
+
+            def adjusted_maximum
+              @adjusted_maximum ||= domain.domain_maximum
+            end
+
+            def domain
+              @domain ||= Domain.new(minimum:, maximum:, tick_interval: tick_interval.to_f,
+                                     mode: ((values_method == :keys && temporal_data?) || discrete? ? :exact : :rounded))
             end
 
             private
 
             def interval
-              ((maximum + adjustment_for_empty_interval) - (minimum - adjustment_for_empty_interval)) / 10.0
+              interval_range / TARGET_TICK_COUNT
+            end
+
+            def range
+              return (maximum.to_time - adjusted_minimum.to_time).abs if temporal_data?
+
+              maximum - adjusted_minimum
+            end
+
+            def interval_range
+              return (maximum ? 1 : 0) if categorical?
+              return (maximum.to_time - minimum.to_time).abs if temporal_data?
+
+              (maximum + adjustment_for_empty_interval) - (minimum - adjustment_for_empty_interval)
             end
 
             def adjustment_for_empty_interval
@@ -36,15 +65,13 @@ module RCharts
 
             def tick_interval
               return 0 if interval <= 0
-              return ALL_INTERVALS.min_by { (it - interval).abs } if minimum.is_a?(Time)
-
-              tick_base * case (interval / tick_base)
-                          when ..1 then 1
-                          when 1..2 then 2
-                          when 2..2.5 then 2.5
-                          when 2.5..5 then 5
-                          else 10
-                          end
+              return TEMPORAL_INTERVALS.min_by { (it - interval).abs } if temporal_data?
+
+              tick_base * DECIMAL_INTERVALS.min_by { |n| n < (interval / tick_base) ? Float::INFINITY : n }
+            end
+
+            def temporal_data?
+              minimum.acts_like?(:time) || minimum.acts_like?(:date)
             end
 
             def tick_base
@@ -54,10 +81,6 @@ module RCharts
             def tick_offset
               (100.0 / values_count) / 2 if categorical?
             end
-
-            def adjusted_maximum
-              @adjusted_maximum ||= adjusted_minimum + (tick_count * tick_interval)
-            end
           end
         end
       end

data/lib/rcharts/version.rb

@@ -1,6 +1,5 @@
 # frozen_string_literal: true
 
 module RCharts
-  # Fake comment to trigger workflow
-  VERSION = '0.1.0'
+  VERSION = '0.1.1'
 end

metadata

@@ -1,7 +1,7 @@
 --- !ruby/object:Gem::Specification
 name: rcharts
 version: !ruby/object:Gem::Version
-  version: 0.1.0
+  version: 0.1.1
 platform: ruby
 authors:
 - Justin Malčić
@@ -49,6 +49,7 @@ files:
 - app/helpers/rcharts/graph_helper/graph/axes.rb
 - app/helpers/rcharts/graph_helper/graph/axis.rb
 - app/helpers/rcharts/graph_helper/graph/axis/caster.rb
+- app/helpers/rcharts/graph_helper/graph/axis/domain.rb
 - app/helpers/rcharts/graph_helper/graph/axis/positioning.rb
 - app/helpers/rcharts/graph_helper/graph/axis/ticks.rb
 - app/helpers/rcharts/graph_helper/graph/calculator.rb
@@ -101,7 +102,7 @@ required_rubygems_version: !ruby/object:Gem::Requirement
     - !ruby/object:Gem::Version
       version: '0'
 requirements: []
-rubygems_version: 3.6.9
+rubygems_version: 4.0.3
 specification_version: 4
 summary: Responsive SVG charting for Action View.
 test_files: []