hakumi_components 0.1.18.pre → 0.1.19.pre

data/app/components/hakumi_components/progress/component.rb

@@ -1,61 +1,66 @@
+# typed: strict
 # frozen_string_literal: true
 
 module HakumiComponents
   module Progress
     class Component < HakumiComponents::BaseComponent
-      TYPES = [ :line, :circle, :dashboard ].freeze
-      STATUSES = [ :normal, :success, :exception, :active ].freeze
-      LINE_SIZES = [ :small, :default ].freeze
-      LINECAPS = [ :round, :square, :butt ].freeze
-      CIRCLE_STEP_GAP = 2
-
-      def self.extract_controller_locals(params)
-        {
-          percent: parse_number(params[:percent]),
-          success_percent: parse_number(params[:success_percent]),
-          type: params[:type]&.to_sym,
-          status: params[:status]&.to_sym,
-          show_info: params.key?(:show_info) ? ActiveModel::Type::Boolean.new.cast(params[:show_info]) : nil,
-          size: parse_size(params[:size]),
-          stroke_width: parse_number(params[:stroke_width]),
-          stroke_color: parse_stroke_color(params[:stroke_color]),
-          trail_color: params[:trail_color],
-          stroke_linecap: params[:stroke_linecap]&.to_sym,
-          steps: params[:steps].presence&.to_i,
-          gap_degree: parse_number(params[:gap_degree]),
-          gap_position: params[:gap_position]&.to_sym,
-          format: params[:format],
-          info_tooltip: params[:info_tooltip],
-          info_tooltip_threshold: parse_number(params[:info_tooltip_threshold]),
-          info_tooltip_options: params[:info_tooltip_options]
-        }
-      end
-
-      def self.parse_number(value)
-        return nil if value.nil?
-        return value if value.is_a?(Numeric)
-
-        value.to_f if value.to_s.strip != ""
+      extend T::Sig
+
+      ProgressValue = T.type_alias { Numeric }
+      ProgressOption = T.type_alias { Types::HtmlKey }
+      InfoTooltipInput = T.type_alias { T.nilable(T.any(Types::HtmlKey, T::Boolean)) }
+      DisplaySize = T.type_alias { T.nilable(BaseComponent::SizeValue) }
+      StrokeGradient = T.type_alias { T::Hash[String, String] }
+      StrokeColorInput = T.type_alias { T.nilable(T.any(String, Types::DataAttributes, StrokeGradient)) }
+      StrokeColor = T.type_alias { T.nilable(T.any(String, StrokeGradient)) }
+      FormatProc = T.type_alias do
+        T.proc.params(
+          percent: ProgressValue,
+          success_percent: T.nilable(ProgressValue)
+        ).returns(String)
+      end
+      FormatValue = T.type_alias { T.nilable(T.any(Types::Renderable, FormatProc)) }
+      TooltipMode = T.type_alias { T.nilable(Symbol) }
+      TooltipOptionsMap = T.type_alias { T::Hash[Types::HtmlKey, Types::HtmlPrimitive] }
+      StepStateValue = T.type_alias { Types::HtmlPrimitive }
+      StepState = T.type_alias { T::Hash[Symbol, StepStateValue] }
+      SizeInput = T.type_alias { DisplaySize }
+      TYPES = T.let(%i[line circle dashboard].freeze, T::Array[Symbol])
+      STATUSES = T.let(%i[normal success exception active].freeze, T::Array[Symbol])
+      LINE_SIZES = T.let(%i[small default].freeze, T::Array[Symbol])
+      LINECAPS = T.let(%i[round square butt].freeze, T::Array[Symbol])
+
+      sig do
+        params(
+          params: BaseComponent::ControllerOptions
+        ).returns(Types::HtmlAttributes)
       end
-
-      def self.parse_size(value)
-        return nil if value.nil?
-        return value if value.is_a?(Numeric)
-
-        return value.to_sym if value.is_a?(String) && LINE_SIZES.include?(value.to_sym)
-
-        value.to_i if value.to_s.strip != ""
-      end
-
-      def self.parse_stroke_color(value)
-        return nil if value.nil?
-
-        return value.to_unsafe_h if value.respond_to?(:to_unsafe_h)
-        return value if value.is_a?(Hash)
-
-        value
+      def self.extract_controller_locals(params)
+        ControllerLocalsParser.call(params)
+      end
+
+      sig do
+        params(
+          percent: ProgressValue,
+          success_percent: T.nilable(ProgressValue),
+          type: ProgressOption,
+          status: T.nilable(ProgressOption),
+          show_info: T::Boolean,
+          size: DisplaySize,
+          stroke_width: T.nilable(ProgressValue),
+          stroke_color: StrokeColorInput,
+          trail_color: T.nilable(String),
+          stroke_linecap: ProgressOption,
+          steps: T.nilable(Integer),
+          gap_degree: T.nilable(ProgressValue),
+          gap_position: T.nilable(ProgressOption),
+          format: FormatValue,
+          info_tooltip: InfoTooltipInput,
+          info_tooltip_threshold: ProgressValue,
+          info_tooltip_options: T.nilable(TooltipOptionsMap),
+          html_options: Types::HtmlAttributeValue
+        ).void
       end
-
       def initialize(
         percent: 0,
         success_percent: nil,
@@ -73,32 +78,35 @@ module HakumiComponents
         format: nil,
         info_tooltip: :auto,
         info_tooltip_threshold: 20,
-        info_tooltip_options: {},
+        info_tooltip_options: nil,
         **html_options
       )
-        @type = type
-        @status = status
-        @show_info = show_info.nil? ? true : show_info
-        @size = size
-        @stroke_width = stroke_width
-        @stroke_color = stroke_color
-        @trail_color = trail_color
-        @stroke_linecap = stroke_linecap
-        @steps = steps
-        @gap_degree = gap_degree
-        @gap_position = gap_position
-        @format = format
-        @html_options = html_options
-        @info_tooltip_mode = normalize_info_tooltip(info_tooltip)
-        @info_tooltip_threshold = info_tooltip_threshold
-        @info_tooltip_options = normalize_tooltip_options(info_tooltip_options)
-
-        @percent = clamp_percent(percent)
-        @success_percent = success_percent.nil? ? nil : clamp_percent(success_percent)
+        @type = T.let(type.to_sym, Symbol)
+        @status = T.let(status&.to_sym, T.nilable(Symbol))
+        @show_info = T.let(cast_boolean(show_info) != false, T::Boolean)
+        @size = T.let(normalize_size(size), DisplaySize)
+        @stroke_width = T.let(stroke_width&.to_f, T.nilable(Float))
+        @stroke_color = T.let(normalize_stroke_color(stroke_color), StrokeColor)
+        @trail_color = T.let(trail_color&.strip&.presence, T.nilable(String))
+        @stroke_linecap = T.let(stroke_linecap.to_sym, Symbol)
+        @steps = T.let(steps, T.nilable(Integer))
+        @gap_degree = T.let(gap_degree&.to_f, T.nilable(Float))
+        @gap_position = T.let(gap_position&.to_sym, T.nilable(Symbol))
+        @format = T.let(format, FormatValue)
+        @html_options = T.let(html_options, Types::HtmlAttributes)
+        @info_tooltip_mode = T.let(normalize_info_tooltip(info_tooltip), TooltipMode)
+        @info_tooltip_threshold = T.let(info_tooltip_threshold.to_f, Float)
+        @info_tooltip_options = T.let(normalize_tooltip_options(info_tooltip_options), Types::HtmlAttributes)
+        @percent = T.let(clamp_percent(percent), ProgressValue)
+        @success_percent = T.let(success_percent.nil? ? nil : clamp_percent(success_percent), T.nilable(ProgressValue))
+        @info_tooltip_policy = T.let(nil, T.nilable(Progress::InfoTooltipPolicy))
+        @status_state = T.let(nil, T.nilable(Progress::StatusState))
+        @attribute_renderer = T.let(nil, T.nilable(Progress::AttributeRenderer))
 
         validate_props!
       end
 
+      sig { returns(Types::HtmlAttributes) }
       def wrapper_attributes
         merge_attributes(
           {
@@ -114,208 +122,76 @@ module HakumiComponents
         )
       end
 
+      sig { returns(Types::RenderedContent) }
       def formatted_info
         return nil unless show_info?
+
         info_text
       end
 
+      sig { returns(T::Boolean) }
       def show_info?
         @show_info
       end
 
+      sig { returns(T::Boolean) }
       def inline_info?
         show_info? && !wrap_with_tooltip?
       end
 
+      sig { returns(T::Boolean) }
       def wrap_with_tooltip?
-        return false unless tooltip_enabled?
-
-        case @info_tooltip_mode
-        when :always
-          true
-        when :auto
-          circle? && circle_size <= info_tooltip_threshold_value
-        else
-          false
-        end
+        info_tooltip_policy.wrap?
       end
 
+      sig { returns(Types::HtmlAttributes) }
       def tooltip_component_options
-        options = (@info_tooltip_options || {}).dup
-        options[:title] ||= tooltip_label
+        options = T.let(@info_tooltip_options.dup, Types::HtmlAttributes)
+        options[:title] = tooltip_label unless options.key?(:title)
         options
       end
 
+      sig { returns(Integer) }
       def info_tooltip_threshold_value
-        (@info_tooltip_threshold || 20).to_i
+        @info_tooltip_threshold.to_i
       end
 
+      sig { returns(String) }
       def tooltip_label
-        info = show_info? ? formatted_info : nil
-        info.presence || "#{@percent.to_i}%"
+        info_value.tooltip_label
       end
 
+      sig { returns(T::Boolean) }
       def tooltip_enabled?
-        @info_tooltip_mode && @info_tooltip_mode != false
+        info_tooltip_policy.enabled?
       end
 
+      sig { returns(T::Boolean) }
       def line?
         @type == :line
       end
 
+      sig { returns(T::Boolean) }
       def circle?
         @type == :circle
       end
 
+      sig { returns(T::Boolean) }
       def dashboard?
         @type == :dashboard
       end
 
+      sig { returns(T::Boolean) }
       def steps?
-        @steps.to_i.positive?
-      end
-
-      def line_style
-        build_inline_style(
-          "--hakumi-progress-stroke-width" => "#{line_stroke_width}px",
-          "--hakumi-progress-trail-color" => @trail_color
-        )
-      end
-
-      def line_bar_style
-        styles = { "width" => "#{@percent}%" }
-        if gradient?
-          styles["background"] = gradient_css
-        elsif @stroke_color.present?
-          styles["background-color"] = @stroke_color
-        end
-        build_inline_style(styles)
-      end
-
-      def line_success_style
-        build_inline_style("width" => "#{@success_percent}%")
-      end
-
-      def line_steps
-        return [] unless line? && steps?
-
-        total = @steps.to_i
-        progress_units = (@percent / 100.0) * total
-        (0...total).map do |index|
-          active = progress_units > index
-          current = index == progress_units.floor && progress_units < total
-          {
-            active: active,
-            current: current,
-            width: "#{(100.0 / total).round(2)}%",
-            custom_color: steps_custom_color
-          }
-        end
-      end
-
-      def circle_size
-        return @size.to_i if @size.is_a?(Numeric)
-
-        120
-      end
-
-      def circle_inner_style
-        build_inline_style(
-          "width" => "#{circle_size}px",
-          "height" => "#{circle_size}px"
-        )
-      end
-
-      def circle_trail_attributes
-        return {} if circle_steps?
-
-        {
-          class: "hakumi-progress-circle-trail",
-          cx: 50,
-          cy: 50,
-          r: circle_radius,
-          fill: "none",
-          stroke: "var(--hakumi-progress-trail-color, var(--color-border-secondary))",
-          "stroke-width": circle_stroke_width,
-          "stroke-dasharray": circle_trail_dasharray,
-          "stroke-dashoffset": circle_dashoffset,
-          transform: circle_transform
-        }
-      end
-
-      def circle_path_attributes
-        return {} if circle_steps?
-
-        attrs = {
-          class: "hakumi-progress-circle-path",
-          cx: 50,
-          cy: 50,
-          r: circle_radius,
-          fill: "none",
-          "stroke-linecap": @stroke_linecap,
-          "stroke-width": circle_stroke_width,
-          "stroke-dasharray": circle_path_dasharray,
-          "stroke-dashoffset": circle_dashoffset,
-          transform: circle_transform
-        }
-
-        attrs[:style] = build_inline_style("stroke" => circle_stroke) if circle_stroke
-        attrs
-      end
-
-      def circle_trail_style
-        build_inline_style("--hakumi-progress-trail-color" => @trail_color)
-      end
-
-      def circle_gradient_attributes
-        gradient_stops
-      end
-
-      def gradient_id
-        @gradient_id ||= generate_id("hakumi-progress-gradient")
-      end
-
-      def circle_stroke
-        return "url(##{gradient_id})" if gradient?
-        return @stroke_color if @stroke_color.present?
-
-        nil
-      end
-
-      def gradient?
-        @stroke_color.is_a?(Hash)
-      end
-
-      def gradient_css
-        data = gradient_stops
-        return nil unless data
-
-        "linear-gradient(#{data[:direction]}, #{gradient_stop_list(data[:stops])})"
-      end
-
-      def gradient_svg_direction
-        data = gradient_stops
-        return { x1: "0%", y1: "0%", x2: "100%", y2: "0%" } unless data
-
-        direction = data[:direction]
-        case direction
-        when "to left"
-          { x1: "100%", y1: "0%", x2: "0%", y2: "0%" }
-        when "to bottom"
-          { x1: "0%", y1: "0%", x2: "0%", y2: "100%" }
-        when "to top"
-          { x1: "0%", y1: "100%", x2: "0%", y2: "0%" }
-        else
-          { x1: "0%", y1: "0%", x2: "100%", y2: "0%" }
-        end
+        !@steps.nil? && @steps.positive?
       end
 
+      sig { returns(Symbol) }
       def status
-        return @status if @status
-
-        @percent >= 100 ? :success : :normal
+        status_state.value
       end
 
+      sig { returns(Types::DataAttributes) }
       def data_attributes
         {
           controller: "hakumi--progress",
@@ -323,32 +199,71 @@ module HakumiComponents
           "hakumi--progress-percent-value": @percent,
           "hakumi--progress-success-percent-value": @success_percent,
           "hakumi--progress-status-value": status,
-          "hakumi--progress-status-explicit-value": @status.present?,
+          "hakumi--progress-status-explicit-value": status_state.explicit?,
           "hakumi--progress-steps-value": @steps,
           "hakumi--progress-gap-degree-value": @gap_degree,
-          "hakumi--progress-gap-position-value": circle_gap_position,
-          "hakumi--progress-stroke-width-value": stroke_width_value,
+          "hakumi--progress-gap-position-value": attribute_renderer.circle_gap_position,
+          "hakumi--progress-stroke-width-value": attribute_renderer.stroke_width_value,
           "hakumi--progress-show-info-value": show_info?,
           "hakumi--progress-custom-info-value": custom_info?
-        }
+        }.compact
+      end
+
+      sig { returns(T::Boolean) }
+      def success_segment?
+        success = @success_percent
+        !success.nil? && success.positive?
       end
 
       private
 
+      sig { returns(Types::RenderedContent) }
       def info_text
-        return content if content.present?
+        info_value.text
+      end
 
-        if @format.respond_to?(:call)
-          value = @format.call(@percent, @success_percent)
-          return render_value(value)
-        end
+      sig { returns(Progress::InfoTooltipPolicy) }
+      def info_tooltip_policy
+        policy = @info_tooltip_policy
+        return policy unless policy.nil?
+
+        policy = Progress::InfoTooltipPolicy.new(
+          mode: @info_tooltip_mode,
+          type: @type,
+          circle_size: attribute_renderer.circle_size,
+          threshold: info_tooltip_threshold_value
+        )
+        @info_tooltip_policy = policy
+      end
+
+      sig { returns(Progress::InfoValue) }
+      def info_value
+        Progress::InfoValue.new(
+          percent: @percent,
+          success_percent: @success_percent,
+          content: content,
+          format_value: @format,
+          rendered_format: rendered_info_format
+        )
+      end
 
-        rendered_format = render_value(@format)
-        return rendered_format if rendered_format.present?
+      sig { returns(T.untyped) }
+      def rendered_info_format
+        return nil if @format.nil? || @format.is_a?(Proc)
 
-        "#{@percent.to_i}%"
+        render_value(@format)
       end
 
+      sig { returns(Progress::StatusState) }
+      def status_state
+        state = @status_state
+        return state unless state.nil?
+
+        state = Progress::StatusState.new(percent: @percent, explicit_status: @status)
+        @status_state = state
+      end
+
+      sig { void }
       def validate_props!
         validate_inclusion!(:type, TYPES)
         validate_inclusion!(:status, STATUSES)
@@ -363,202 +278,115 @@ module HakumiComponents
         end
       end
 
+      sig { returns(String) }
       def wrapper_classes
-        modifiers = {
-          @type => true,
-          "status-#{status}" => true,
-          "show-info" => show_info?,
-          "linecap-#{@stroke_linecap}" => true
-        }
-
-        modifiers[:small] = true if line? && @size == :small
-        modifiers[:steps] = true if steps?
+        modifiers = T.let(
+          {
+            @type => true,
+            "status-#{status}" => true,
+            "show-info" => show_info?,
+            "linecap-#{@stroke_linecap}" => true,
+            small: line? && @size == :small,
+            steps: steps?
+          },
+          Types::ClassModifiers
+        )
 
-        class_names("progress", modifiers, [ @html_options[:class] ])
+        component_classes("progress", modifiers, @html_options)
       end
 
+      sig { returns(String) }
       def accessibility_label
-        "Progress #{@percent.to_i}%"
+        "Progress #{percent_label}"
       end
 
+      sig { params(value: ProgressValue).returns(ProgressValue) }
       def clamp_percent(value)
-        value = value.to_f
-        return 0 if value.nan?
-
-        clamped = value.clamp(0, 100)
-        clamped == clamped.to_i ? clamped.to_i : clamped
-      end
-
-      def line_stroke_width
-        return @stroke_width if @stroke_width
-
-        return 6 if @size == :small
-
-        8
-      end
-
-      def steps_custom_color
-        return @stroke_color if @stroke_color.present? && !gradient?
-
-        nil
-      end
-
-      def circle_stroke_width
-        stroke_width_value
-      end
-
-      def circle_radius
-        50 - (circle_stroke_width / 2.0)
-      end
-
-      def circle_total_length
-        2 * Math::PI * circle_radius
-      end
-
-      def circle_gap_degree
-        return @gap_degree if @gap_degree
-
-        dashboard? ? 75 : 0
-      end
-
-      def circle_gap_position
-        return @gap_position if @gap_position
-
-        dashboard? ? :bottom : :top
-      end
-
-      def circle_gap_length
-        circle_total_length * (circle_gap_degree / 360.0)
-      end
-
-      def circle_effective_length
-        circle_total_length - circle_gap_length
-      end
-
-      def circle_path_length
-        circle_effective_length * (@percent / 100.0)
-      end
-
-      def circle_trail_length
-        circle_effective_length
-      end
-
-      def circle_dashoffset
-        format_float(circle_gap_length / 2.0)
-      end
+        numeric = value.to_f
+        return 0 if numeric.nan?
 
-      def circle_path_dasharray
-        "#{format_float(circle_path_length)} #{format_float(circle_total_length)}"
+        clamped = numeric.clamp(0, 100)
+        whole_number?(clamped) ? clamped.to_i : clamped
       end
 
-      def circle_trail_dasharray
-        "#{format_float(circle_trail_length)} #{format_float(circle_total_length)}"
+      sig { returns(T::Boolean) }
+      def custom_info?
+        info_value.custom?
       end
 
-      def circle_transform
-        "rotate(#{circle_rotation} 50 50)"
-      end
+      sig { params(value: InfoTooltipInput).returns(TooltipMode) }
+      def normalize_info_tooltip(value)
+        string_value = value.is_a?(String) ? value.strip.downcase : value
 
-      def circle_rotation
-        case circle_gap_position
-        when :left then 180
-        when :right then 0
-        when :bottom then 90
-        else -90
-        end
-      end
+        return :always if string_value == :always || string_value == "always"
+        return :auto if string_value == :auto || string_value.nil?
 
-      def format_float(value)
-        format("%.2f", value)
+        cast_boolean(value) ? :auto : nil
       end
 
-      def gradient_stops
-        return nil unless gradient?
-
-        raw = @stroke_color.transform_keys(&:to_s)
-        direction = raw.delete("direction") || "to right"
+      sig { params(value: T.nilable(TooltipOptionsMap)).returns(Types::HtmlAttributes) }
+      def normalize_tooltip_options(value)
+        options = T.let({}, Types::HtmlAttributes)
+        return options if value.nil?
 
-        stops = if raw.key?("from") || raw.key?("to")
-          [ [ "0%", raw["from"] ], [ "100%", raw["to"] ] ].compact
-        else
-          raw.map { |key, val| [ key, val ] }
+        value.each do |key, entry_value|
+          options[key.to_sym] = entry_value
         end
-
-        stops = stops.reject { |_key, val| val.nil? }
-        return nil if stops.empty?
-
-        { direction: direction, stops: stops }
-      end
-
-      def gradient_stop_list(stops)
-        stops.map { |key, color| "#{color} #{key}" }.join(", ")
-      end
-
-      def stroke_width_value
-        return @stroke_width if @stroke_width
-
-        circle? || dashboard? ? 6 : line_stroke_width
+        options
       end
 
-      def custom_info?
-        content.present? || @format.present?
-      end
+      sig { params(value: SizeInput).returns(DisplaySize) }
+      def normalize_size(value)
+        return value if value.nil? || value.is_a?(Integer)
+        return value.to_sym if value.is_a?(String) && LINE_SIZES.include?(value.to_sym)
+        return value if value.is_a?(Symbol) && LINE_SIZES.include?(value)
 
-      def circle_steps?
-        (circle? || dashboard?) && steps?
+        raise ArgumentError, "size must be one of #{LINE_SIZES.inspect} or a numeric value"
       end
 
-      def circle_steps
-        return [] unless circle_steps?
-
-        total = @steps.to_i
-        gap = circle_step_gap
-        effective = circle_effective_length
-        segment_length = (effective - (gap * total)) / total.to_f
-        progress_units = (@percent / 100.0) * total
-
-        (0...total).map do |index|
-          active = progress_units > index
-          current = index == progress_units.floor && progress_units < total
-          offset = circle_dashoffset.to_f + ((segment_length + gap) * index)
-          {
-            index: index,
-            active: active,
-            current: current,
-            dasharray: "#{format_float(segment_length)} #{format_float(circle_total_length)}",
-            dashoffset: format_float(offset),
-            stroke: circle_step_stroke(active)
-          }
-        end
-      end
+      sig { params(value: StrokeColorInput).returns(StrokeColor) }
+      def normalize_stroke_color(value)
+        return nil if value.nil?
+        return value.strip.presence if value.is_a?(String)
 
-      def circle_step_gap
-        CIRCLE_STEP_GAP
+        Progress::StrokeGradientValue.normalize(value)
       end
 
-      def circle_step_stroke(active)
-        return "var(--hakumi-progress-trail-color, var(--color-border-secondary))" unless active
-        return "url(##{gradient_id})" if gradient?
-        return @stroke_color if @stroke_color.present?
+      sig { returns(Progress::AttributeRenderer) }
+      def attribute_renderer
+        renderer = @attribute_renderer
+        return renderer unless renderer.nil?
 
-        nil
+        style_builder = T.let(
+          ->(styles) { build_inline_style(styles) },
+          Progress::AttributeRenderer::StyleBuilder
+        )
+        renderer = Progress::AttributeRenderer.new(
+          type: @type,
+          percent: @percent,
+          success_percent: @success_percent,
+          size: @size,
+          stroke_width: @stroke_width,
+          stroke_color: @stroke_color,
+          trail_color: @trail_color,
+          stroke_linecap: @stroke_linecap,
+          steps: @steps,
+          gap_degree: @gap_degree,
+          gap_position: @gap_position,
+          gradient_id: generate_id("hakumi-progress-gradient"),
+          style_builder: style_builder
+        )
+        @attribute_renderer = renderer
       end
 
-      def normalize_info_tooltip(value)
-        string_value = value.is_a?(String) ? value.strip.downcase : value
-
-        return :always if string_value == :always || string_value == "always"
-        return :auto if string_value == :auto || string_value.nil?
-
-        ActiveModel::Type::Boolean.new.cast(value) ? :auto : false
+      sig { returns(String) }
+      def percent_label
+        info_value.percent_label
       end
 
-      def normalize_tooltip_options(value)
-        options = value || {}
-        options = options.to_unsafe_h if options.respond_to?(:to_unsafe_h)
-        options = options.to_h unless options.is_a?(Hash)
-        options.deep_symbolize_keys! if options.respond_to?(:deep_symbolize_keys)
-        options
+      sig { params(value: ProgressValue).returns(T::Boolean) }
+      def whole_number?(value)
+        (value.to_f % 1.0).zero?
       end
     end
   end