rcharts 0.1.0

data/app/helpers/rcharts/graph_helper/element.rb

@@ -0,0 +1,65 @@
+# frozen_string_literal: true
+
+module RCharts
+  module GraphHelper
+    # = \Element
+    #
+    # The base class for all elements to inherit from. Elements are designed for cases where a tag helper alone
+    # would be unwieldy because of the complexity of determining content or attribute values e.g. for SVG positioning
+    # attributes like <tt>x</tt> and <tt>y</tt>.
+    #
+    # To ensure rendering yields a predictable result every time, don't mutate element state as part of the rendering
+    # process. If you need to track and mutate state, use ElementBuilder instead, which is designed for this situation.
+    #
+    # By default, rendering an element produces no content. Subclasses should implement their own private #tags method
+    # to return actual content when rendered. All helpers and objects accessible in the parent view context are also
+    # accessible within #tags, so you can use tag helpers and other helpers to build markup.
+    #
+    # To pass a value to an element, first declare an attribute using the ActiveModel::Attributes API
+    # and then pass the value to the element's initializer (or use one of the other methods to set attributes).
+    # Already declared attributes are #id, #class_names (with writer alias #class=), #data, and #aria.
+    class Element
+      include ActiveModel::API
+      include ActiveModel::Attributes
+
+      class_attribute :view_context
+
+      delegate :render, :tag, to: :view_context
+      delegate_missing_to :view_context
+
+      ##
+      # :attr_accessor: id
+      attribute :id, :string
+
+      ##
+      # :attr_accessor:
+      attribute :class_names
+
+      ##
+      # :attr_writer: class
+
+      ##
+      # :attr_accessor:
+      attribute :data, default: -> { {} }
+
+      ##
+      # :attr_accessor:
+      attribute :aria, default: -> { {} }
+
+      alias class= class_names= # :nodoc:
+
+      def render_in(view_context, &)
+        with view_context: do
+          tags(&)
+        end
+      end
+
+      private
+
+      # :doc:
+      def tags
+        ''.html_safe
+      end
+    end
+  end
+end

data/app/helpers/rcharts/graph_helper/element_builder.rb

@@ -0,0 +1,42 @@
+# frozen_string_literal: true
+
+module RCharts
+  module GraphHelper
+    # = \Element Builder
+    #
+    # Like form builders, but for elements. Concrete builders should inherit from this class.
+    # Use this when you need to provide a way for users to choose between different options at rendering time and track
+    # rendering state (e.g. to do with iteration).
+    #
+    # Rendering a builder shouldn't itself render anything. Instead, rendering the builder with a block means that,
+    # just as with a form builder, the block will be called with an instance of the builder.
+    # That means within the block, users can then call methods on the builder, which may output markup to the buffer.
+    # If you need a container element, like the <tt><form></tt> associated with a form builder,
+    # keep that separate from the builder.
+    #
+    # The builder is the place to store information about the state of rendering independent of particular elements.
+    # One example is iteration, where users may need to be able to specify different markup for each individual item
+    # in the collection. You can allow this by rendering a builder with each object in the collection, declaring
+    # an index attribute on the builder to allow different behavior according to the position of the item:
+    #   MyElementBuilder < RCharts::GraphHelper::ElementBuilder
+    #     attribute :index, :integer
+    #   end
+    #
+    # Like elements, builders set and delegate to the view context.
+    class ElementBuilder
+      include ActiveModel::API
+      include ActiveModel::Attributes
+
+      class_attribute :view_context
+
+      delegate :render, :tag, to: :view_context
+      delegate_missing_to :view_context
+
+      def render_in(view_context, &)
+        with view_context: do
+          block_given? ? yield(self) : ''.html_safe
+        end
+      end
+    end
+  end
+end

data/app/helpers/rcharts/graph_helper/graph/axes.rb

@@ -0,0 +1,41 @@
+# frozen_string_literal: true
+
+module RCharts
+  module GraphHelper
+    module Graph
+      class Axes # :nodoc:
+        delegate :[], to: :axes
+
+        def initialize(graphable = {}, axis_options = {})
+          @axes = Options.new(graphable.keys, axis_options).to_h do |name, axes|
+            [name, axes.collect { |index, options| build_axis(graphable:, name:, index:, **options) }]
+          end
+        end
+
+        def fetch(name, index = 0)
+          axes.fetch(name) { raise ArgumentError, "Unknown axis #{name}" }
+              .fetch(index) { raise ArgumentError, "Unknown index #{index} for axis #{name}" }
+        end
+
+        def discrete
+          fetch(:x).then { it.discrete? && it } || axes.values.flatten.find(&:discrete?) || fetch(:x)
+        end
+
+        def continuous
+          fetch(:y).then { !it.discrete? && it } || axes.values.flatten.find { !it.discrete? } || fetch(:y)
+        end
+
+        private
+
+        attr_reader :axes
+
+        def build_axis(graphable:, name:, index:, **options)
+          discrete = case options[:values_method].to_proc.call(graphable).first
+                     when String, Symbol then :categorical
+                     end
+          Axis.new(graphable:, name:, index:, discrete:, **options)
+        end
+      end
+    end
+  end
+end

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

@@ -0,0 +1,45 @@
+# frozen_string_literal: true
+
+module RCharts
+  module GraphHelper
+    module Graph
+      class Axis
+        class Caster # :nodoc:
+          def initialize(value)
+            @value = value
+          end
+
+          def casting
+            upcast(yield downcast)
+          end
+
+          def downcast
+            case value
+            when Time then value.to_i
+            when Date then value.jd + value.day_fraction
+            else value
+            end
+          end
+
+          private
+
+          attr_reader :value
+
+          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)
+            else raw
+            end
+          end
+
+          def value_zone
+            value.zone.try { ActiveSupport::TimeZone[it] } || value.utc_offset
+          end
+        end
+      end
+    end
+  end
+end

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

@@ -0,0 +1,66 @@
+# frozen_string_literal: true
+
+module RCharts
+  module GraphHelper
+    module Graph
+      class Axis
+        module Positioning # :nodoc:
+          extend ActiveSupport::Concern
+          include Ticks
+
+          included do
+            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)))
+            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)
+
+              adjusted_minimum + (index * tick_interval)
+            end
+
+            def length_between(min, max)
+              return position_for(0 - max) - position_for(0 - min) if max.negative?
+
+              (position_for(max) - position_for(min))
+            end
+
+            def position_for(value)
+              return values.flatten.index(value).try { position_at(it) } if discrete == :categorical
+              return 0 if adjusted_maximum == adjusted_minimum
+
+              downcasted_position_for(value)
+            end
+
+            private
+
+            def downcasted_position_for(value)
+              ((Caster.new(value).downcast.to_f - casted_adjusted_minimum) / casted_range) * 100
+            end
+
+            def casted_range
+              casted_adjusted_maximum - casted_adjusted_minimum
+            end
+
+            def casted_adjusted_maximum
+              Caster.new(adjusted_maximum).downcast
+            end
+
+            def casted_adjusted_minimum
+              Caster.new(adjusted_minimum).downcast
+            end
+          end
+        end
+      end
+    end
+  end
+end

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

@@ -0,0 +1,66 @@
+# frozen_string_literal: true
+
+module RCharts
+  module GraphHelper
+    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 } }
+
+          extend ActiveSupport::Concern
+
+          included do
+            def tick_count
+              return values_count.pred if discrete?
+
+              ((maximum - adjusted_minimum) / tick_interval).ceil
+            end
+
+            def adjusted_minimum
+              @adjusted_minimum ||= Caster.new(minimum).casting { (it / tick_interval).floor * tick_interval }
+            end
+
+            private
+
+            def interval
+              ((maximum + adjustment_for_empty_interval) - (minimum - adjustment_for_empty_interval)) / 10.0
+            end
+
+            def adjustment_for_empty_interval
+              return 0 if minimum != maximum
+
+              (maximum.nil? || maximum.zero? ? 1.0 : (maximum.abs * 0.1)) * 0.5
+            end
+
+            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
+            end
+
+            def tick_base
+              10**BigDecimal(Math.log10(interval).floor)
+            end
+
+            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
+    end
+  end
+end

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

@@ -0,0 +1,86 @@
+# frozen_string_literal: true
+
+module RCharts
+  module GraphHelper
+    module Graph
+      class Axis # :nodoc:
+        include ActiveModel::API
+        include ActiveModel::Attributes
+
+        include Ticks
+        include Positioning
+
+        attribute :name, :'rcharts/symbol'
+        attribute :index, :integer
+        attribute :graphable
+        attribute :values_method, default: :values
+        attribute :minimum
+        attribute :maximum
+        attribute :discrete
+        attribute :stacked, :boolean, default: false
+
+        alias stacked? stacked
+
+        def discrete?
+          discrete.present?
+        end
+
+        def categorical?
+          discrete == :categorical
+        end
+
+        def horizontal?
+          name == :x
+        end
+
+        def vertical?
+          name == :y
+        end
+
+        private
+
+        delegate :count, to: :values, prefix: true, private: true
+
+        def minimum
+          super || (self.minimum = minima.min) || 0
+        end
+
+        def maximum
+          super || (self.maximum = maxima.max) || 0
+        end
+
+        def minmax
+          [minimum, maximum]
+        end
+
+        def keys
+          graphable.keys
+        end
+
+        def values
+          @values ||= graphable.then(&values_method).collect { it.is_a?(Hash) ? it.values : Array.wrap(it) }
+        end
+
+        def minima
+          values.filter_map do |value|
+            value.reject { it.try(:positive?) }
+                 .compact
+                 .presence
+                 .try(&(stacked? ? :sum : :min))
+                 .then { it || value.compact.min }
+          end
+        end
+
+        def maxima
+          values.filter_map do |value|
+            value.reject { it.try(:negative?) }
+                 .compact
+                 .presence
+                 .try(&(stacked? ? :sum : :max))
+                 .then { it || value.compact.max }
+          end
+        end
+      end
+    end
+  end
+end

data/app/helpers/rcharts/graph_helper/graph/calculator.rb

@@ -0,0 +1,91 @@
+# frozen_string_literal: true
+
+module RCharts
+  module GraphHelper
+    module Graph
+      class Calculator # :nodoc:
+        delegate :[], :dig, to: :to_h
+
+        def initialize(values = {})
+          @values = values
+          @chain = []
+          @selections = {}
+        end
+
+        def sum_complete
+          values.transform_values do |value|
+            case value
+            when Hash then value.values.any?(nil) ? nil : value.values.sum
+            when Array then value.any?(nil) ? nil : value.sum
+            else value
+            end
+          end
+        end
+
+        def signed(sign = nil)
+          return self unless sign
+
+          apply sign do
+            values_for_predicate sign == :positive ? :positive? : :negative?
+          end
+        end
+
+        def stacked(exclude_current: false)
+          apply :stacked, exclude_current do
+            collect_sum inclusive: !exclude_current
+          end
+        end
+
+        def to_h
+          keys.index_with do |key|
+            next values if key.nil?
+
+            values.transform_values { it[key] }
+          end
+        end
+
+        protected
+
+        attr_accessor :values, :chain
+
+        def apply!(*operation)
+          selections[[*chain, *operation]] ||= yield if block_given?
+          self.chain = chain.dup
+          chain.append(*operation)
+          self.values = selections[chain]
+        end
+
+        private
+
+        attr_reader :selections
+
+        def apply(*operation, &)
+          selections[[*chain, *operation]] ||= yield if block_given?
+          dup.tap { it.apply!(*operation) }
+        end
+
+        def keys
+          case values.values.first
+          in Hash => value then value.keys
+          in Array => value then (0...value.size).to_a
+          else [nil]
+          end
+        end
+
+        def values_for_predicate(predicate)
+          values.deep_transform_values { it.try(predicate) == false ? nil : it }
+        end
+
+        def collect_sum(inclusive: true)
+          values.transform_values do |value|
+            value.keys.index_with do |key|
+              value.keys.index(key).then do |limit|
+                value.values.slice(inclusive ? 0..limit : 0...limit).compact.presence&.sum
+              end
+            end
+          end
+        end
+      end
+    end
+  end
+end

data/app/helpers/rcharts/graph_helper/graph/composition.rb

@@ -0,0 +1,35 @@
+# frozen_string_literal: true
+
+module RCharts
+  module GraphHelper
+    module Graph
+      class Composition # :nodoc:
+        attr_reader :axes
+
+        delegate :sum_complete, :signed, :stacked, to: :calculator
+        delegate :keys, to: :data
+
+        def initialize(graphable = {}, axis_options = {})
+          @data = graphable
+          @axes = Axes.new(graphable, axis_options)
+        end
+
+        def values
+          @values ||= case data.values.first
+                      in Hash then data
+                      in Array then data.transform_values { it.index_with.with_index { |_, index| index } }
+                      else data.transform_values { { nil => it } }
+                      end
+        end
+
+        private
+
+        attr_reader :data
+
+        def calculator
+          @calculator ||= Calculator.new(data)
+        end
+      end
+    end
+  end
+end

data/app/helpers/rcharts/graph_helper/graph/options.rb

@@ -0,0 +1,33 @@
+# frozen_string_literal: true
+
+module RCharts
+  module GraphHelper
+    module Graph
+      class Options # :nodoc:
+        DEFAULTS = { x: { 0 => { values_method: :keys } }, y: { 0 => { values_method: :values } } }.freeze
+
+        def initialize(keys, options)
+          @keys = keys
+          @options = options
+        end
+
+        def to_h(&)
+          DEFAULTS.deep_merge(normalized_options).to_h(&)
+        end
+
+        private
+
+        attr_reader :keys, :options
+
+        def normalized_options
+          options.transform_values do |value|
+            next value.each_with_index.to_h { |item, index| [index, item] } if value.is_a?(Array)
+            next value if value.is_a?(Hash) && value.keys.first.is_a?(Integer)
+
+            { 0 => value }
+          end
+        end
+      end
+    end
+  end
+end

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

@@ -0,0 +1,8 @@
+# frozen_string_literal: true
+
+module RCharts
+  module GraphHelper
+    module Graph # :nodoc:
+    end
+  end
+end