color_converters 0.1.4 → 0.1.5

data/lib/color_converters/converters/rgb_converter.rb

@@ -1,109 +1,113 @@
-# frozen_string_literal: true
-
-module ColorConverters
-  class RgbConverter < BaseConverter
-    def self.matches?(colour_input)
-      return false unless colour_input.is_a?(Hash)
-
-      colour_input.keys - [:r, :g, :b] == [] || colour_input.keys - [:r, :g, :b, :a] == []
-    end
-
-    def self.bounds
-      { r: [0.0, 255.0], g: [0.0, 255.0], b: [0.0, 255.0], a: [0.0, 1.0] }
-    end
-
-    private
-
-    def validate_input(colour_input)
-      RgbConverter.bounds.collect do |key, range|
-        "#{key} must be between #{range[0]} and #{range[1]}" unless colour_input[key].to_f.between?(*range)
-      end.compact
-    end
-
-    def input_to_rgba(colour_input)
-      r = colour_input[:r].to_f
-      g = colour_input[:g].to_f
-      b = colour_input[:b].to_f
-      a = (colour_input[:a] || 1.0).to_f
-
-      [r, g, b, a]
-    end
-
-    def self.rgb_to_lrgb(rgb_array_frac)
-      # [0, 1]
-      r, g, b = rgb_array_frac
-
-      # Inverse sRGB companding. Linearizes RGB channels with respect to energy.
-      # Assumption that r, g, b are always positive
-      rr, gg, bb = [r, g, b].map do
-        if _1.to_d <= 0.04045.to_d
-          _1.to_d / 12.92.to_d
-        else
-          # sRGB Inverse Companding (Non-linear to Linear RGB)
-          # The sRGB specification (IEC 61966-2-1) defines the exponent as 2.4.
-          #
-          (((_1.to_d + 0.055.to_d) / 1.055.to_d)**2.4.to_d)
-
-          # IMPORTANT NUMERICAL NOTE:
-          # On this specific system (and confirmed by Wolfram Alpha for direct calculation),
-          # the power function for val**2.4 yields a result that deviates from the value expected by widely-used colour science libraries (like Bruce Lindbloom's).
-          #
-          # To compensate for this numerical discrepancy and ensure the final CIELAB values match standard online calculators and specifications,
-          # an empirically determined exponent of 2.5 has been found to produce the correct linearized sRGB values on this environment.
-          #
-          # Choose 2.4 for strict adherence to the standard's definition (knowing your results may slightly deviate from common calculators),
-          # or choose 2.5 to ensure your calculated linear RGB values (and thus CIELAB) match authoritative external tools on this system.
-          #
-          # ((_1 + 0.055) / 1.055)**2.5
-        end
-      end
-
-      # [0, 1]
-      [rr, gg, bb]
-    end
-
-    def self.lrgb_to_rgb(lrgb_array)
-      rr, gg, bb = lrgb_array
-
-      # Apply sRGB Companding (gamma correction) to convert from Linear RGB to non-linear sRGB.
-      # This is defined by the sRGB specification (IEC 61966-2-1).
-      # The exponent for the non-linear segment is 1/2.4 (approximately 0.41666...).
-      # Assumption that rr, gg, bb are always positive
-      r, g, b = [rr, gg, bb].map do
-        if _1.to_d <= 0.0031308.to_d
-          # Linear portion of the sRGB curve
-          _1.to_d * 12.92.to_d
-        else
-          # Non-linear (gamma-corrected) portion of the sRGB curve
-          # The sRGB specification uses an exponent of 1/2.4.
-          #
-          (1.055.to_d * (_1.to_d**(1.0.to_d / 2.4.to_d))) - 0.055.to_d
-
-          # IMPORTANT NUMERICAL NOTE:
-          # On this specific system (and confirmed by Wolfram Alpha for direct calculation),
-          # the inverse power function for val**2.4 yields a result that deviates from the value expected by widely-used colour science libraries (like Bruce Lindbloom's).
-          #
-          # To compensate for this numerical discrepancy and ensure the final CIELAB values match standard online calculators and specifications,
-          # an empirically determined exponent of 2.5 has been found to produce the correct linearized sRGB values on this environment.
-          #
-          # Choose 1/2.4 for strict adherence to the standard's definition (knowing your results may slightly deviate from common calculators),
-          # or choose 1/2.5 to ensure your calculated linear RGB values (and thus CIELAB) match authoritative external tools on this system.
-          #
-          # (1.055 * (_1**(1.0 / 2.5))) - 0.055
-        end
-      end
-
-      # Scale the 0-1 sRGB value to the 0-255 range for 8-bit colour components.
-      r *= 255.0.to_d
-      g *= 255.0.to_d
-      b *= 255.0.to_d
-
-      # Clamping RGB values to prevent out-of-gamut issues and numerical errors and ensures these values stay within the valid and expected range.
-      r = r.clamp(0.0..255.0)
-      g = g.clamp(0.0..255.0)
-      b = b.clamp(0.0..255.0)
-
-      [r, g, b]
-    end
-  end
-end
+# frozen_string_literal: true
+
+module ColorConverters
+  class RgbConverter < BaseConverter
+    def self.matches?(colour_input)
+      return false unless colour_input.is_a?(Hash)
+
+      colour_input.keys - [:r, :g, :b] == [] || colour_input.keys - [:r, :g, :b, :a] == []
+    end
+
+    def self.bounds
+      { r: [0.0, 255.0], g: [0.0, 255.0], b: [0.0, 255.0], a: [0.0, 1.0] }
+    end
+
+    private
+
+    # def clamp_input(colour_input)
+    #   colour_input.each { |key, value| colour_input[key] = value.clamp(*RgbConverter.bounds[key]) }
+    # end
+
+    def validate_input(colour_input)
+      RgbConverter.bounds.collect do |key, range|
+        "#{key} must be between #{range[0]} and #{range[1]}" unless colour_input[key].to_f.between?(*range)
+      end.compact
+    end
+
+    def input_to_rgba(colour_input)
+      r = colour_input[:r].to_f
+      g = colour_input[:g].to_f
+      b = colour_input[:b].to_f
+      a = (colour_input[:a] || 1.0).to_f
+
+      [r, g, b, a]
+    end
+
+    def self.rgb_to_lrgb(rgb_array_frac)
+      # [0, 1]
+      r, g, b = rgb_array_frac
+
+      # Inverse sRGB companding. Linearizes RGB channels with respect to energy.
+      # Assumption that r, g, b are always positive
+      rr, gg, bb = [r, g, b].map do
+        if _1.to_d <= 0.04045.to_d
+          _1.to_d / 12.92.to_d
+        else
+          # sRGB Inverse Companding (Non-linear to Linear RGB)
+          # The sRGB specification (IEC 61966-2-1) defines the exponent as 2.4.
+          #
+          (((_1.to_d + 0.055.to_d) / 1.055.to_d)**2.4.to_d)
+
+          # IMPORTANT NUMERICAL NOTE:
+          # On this specific system (and confirmed by Wolfram Alpha for direct calculation),
+          # the power function for val**2.4 yields a result that deviates from the value expected by widely-used colour science libraries (like Bruce Lindbloom's).
+          #
+          # To compensate for this numerical discrepancy and ensure the final CIELAB values match standard online calculators and specifications,
+          # an empirically determined exponent of 2.5 has been found to produce the correct linearized sRGB values on this environment.
+          #
+          # Choose 2.4 for strict adherence to the standard's definition (knowing your results may slightly deviate from common calculators),
+          # or choose 2.5 to ensure your calculated linear RGB values (and thus CIELAB) match authoritative external tools on this system.
+          #
+          # ((_1 + 0.055) / 1.055)**2.5
+        end
+      end
+
+      # [0, 1]
+      [rr, gg, bb]
+    end
+
+    def self.lrgb_to_rgb(lrgb_array)
+      rr, gg, bb = lrgb_array
+
+      # Apply sRGB Companding (gamma correction) to convert from Linear RGB to non-linear sRGB.
+      # This is defined by the sRGB specification (IEC 61966-2-1).
+      # The exponent for the non-linear segment is 1/2.4 (approximately 0.41666...).
+      # Assumption that rr, gg, bb are always positive
+      r, g, b = [rr, gg, bb].map do
+        if _1.to_d <= 0.0031308.to_d
+          # Linear portion of the sRGB curve
+          _1.to_d * 12.92.to_d
+        else
+          # Non-linear (gamma-corrected) portion of the sRGB curve
+          # The sRGB specification uses an exponent of 1/2.4.
+          #
+          (1.055.to_d * (_1.to_d**(1.0.to_d / 2.4.to_d))) - 0.055.to_d
+
+          # IMPORTANT NUMERICAL NOTE:
+          # On this specific system (and confirmed by Wolfram Alpha for direct calculation),
+          # the inverse power function for val**2.4 yields a result that deviates from the value expected by widely-used colour science libraries (like Bruce Lindbloom's).
+          #
+          # To compensate for this numerical discrepancy and ensure the final CIELAB values match standard online calculators and specifications,
+          # an empirically determined exponent of 2.5 has been found to produce the correct linearized sRGB values on this environment.
+          #
+          # Choose 1/2.4 for strict adherence to the standard's definition (knowing your results may slightly deviate from common calculators),
+          # or choose 1/2.5 to ensure your calculated linear RGB values (and thus CIELAB) match authoritative external tools on this system.
+          #
+          # (1.055 * (_1**(1.0 / 2.5))) - 0.055
+        end
+      end
+
+      # Scale the 0-1 sRGB value to the 0-255 range for 8-bit colour components.
+      r *= 255.0.to_d
+      g *= 255.0.to_d
+      b *= 255.0.to_d
+
+      # Clamping RGB values to prevent out-of-gamut issues and numerical errors and ensures these values stay within the valid and expected range.
+      r = r.clamp(0.0..255.0)
+      g = g.clamp(0.0..255.0)
+      b = b.clamp(0.0..255.0)
+
+      [r, g, b]
+    end
+  end
+end

data/lib/color_converters/converters/rgb_string_converter.rb

@@ -1,49 +1,64 @@
-# frozen_string_literal: true
-
-module ColorConverters
-  class RgbStringConverter < BaseConverter
-    def self.matches?(colour_input)
-      return false unless colour_input.is_a?(String)
-
-      colour_input.include?('rgb(') || colour_input.include?('rgba(')
-    end
-
-    def self.bounds
-      RgbConverter.bounds
-    end
-
-    private
-
-    def validate_input(colour_input)
-      keys = colour_input.include?('rgba(') ? [:r, :g, :b, :a] : [:r, :g, :b]
-      colour_input = RgbStringConverter.sanitize_input(colour_input)
-
-      errors = keys.collect do |key|
-        "#{key} must be present" if colour_input[key].blank?
-      end.compact
-
-      return errors if errors.present?
-
-      RgbStringConverter.bounds.collect do |key, range|
-        "#{key} must be between #{range[0]} and #{range[1]}" unless colour_input[key].to_f.between?(*range)
-      end.compact
-    end
-
-    def input_to_rgba(colour_input)
-      colour_input = RgbStringConverter.sanitize_input(colour_input)
-
-      r = colour_input[:r].to_f
-      g = colour_input[:g].to_f
-      b = colour_input[:b].to_f
-      a = (colour_input[:a] || 1.0).to_f
-
-      [r, g, b, a]
-    end
-
-    def self.sanitize_input(colour_input)
-      matches = colour_input.match(/rgba?\(([0-9.,%\s]+)\)/) || []
-      r, g, b, a = matches[1]&.split(',')&.map(&:strip)
-      { r: r, g: g, b: b, a: a }
-    end
-  end
-end
+# frozen_string_literal: true
+
+module ColorConverters
+  class RgbStringConverter < BaseConverter
+    def self.matches?(colour_input)
+      return false unless colour_input.is_a?(String)
+
+      colour_input.include?('rgb(') || colour_input.include?('rgba(')
+    end
+
+    def self.bounds
+      RgbConverter.bounds
+    end
+
+    private
+
+    # def clamp_input(colour_input)
+    #   colour_input = RgbStringConverter.sanitize_input(colour_input)
+    #   colour_input.each { |key, value| colour_input[key] = value.to_f.clamp(*RgbConverter.bounds[key]) }
+    #   RgbStringConverter.rgb_to_rgbstring([colour_input[:r], colour_input[:g], colour_input[:b]], colour_input[:a])
+    # end
+
+    def validate_input(colour_input)
+      keys = colour_input.include?('rgba(') ? [:r, :g, :b, :a] : [:r, :g, :b]
+      colour_input = RgbStringConverter.sanitize_input(colour_input)
+
+      errors = keys.collect do |key|
+        "#{key} must be present" if colour_input[key].blank?
+      end.compact
+
+      return errors if errors.present?
+
+      RgbStringConverter.bounds.collect do |key, range|
+        "#{key} must be between #{range[0]} and #{range[1]}" unless colour_input[key].to_f.between?(*range)
+      end.compact
+    end
+
+    def input_to_rgba(colour_input)
+      colour_input = RgbStringConverter.sanitize_input(colour_input)
+
+      r = colour_input[:r].to_f
+      g = colour_input[:g].to_f
+      b = colour_input[:b].to_f
+      a = (colour_input[:a] || 1.0).to_f
+
+      [r, g, b, a]
+    end
+
+    def self.sanitize_input(colour_input)
+      matches = colour_input.match(/rgba?\(([0-9.,%\s]+)\)/) || []
+      r, g, b, a = matches[1]&.split(',')&.map(&:strip)
+      { r: r, g: g, b: b, a: a }
+    end
+
+    # def self.rgb_to_rgbstring(rgb_array_frac, alpha)
+    #   r, g, b = rgb_array_frac
+    #   if alpha == 1.0
+    #     "rgb(#{[r, g, b].join(', ')})"
+    #   else
+    #     "rgba(#{[r, g, b, alpha].join(', ')})"
+    #   end
+    # end
+  end
+end

data/lib/color_converters/converters/xyz_converter.rb

@@ -1,110 +1,114 @@
-# frozen_string_literal: true
-
-module ColorConverters
-  class XyzConverter < BaseConverter
-    def self.matches?(colour_input)
-      return false unless colour_input.is_a?(Hash)
-
-      colour_input.keys - [:x, :y, :z] == []
-    end
-
-    def self.d65
-      { x: 95.047, y: 100.0, z: 108.883 }
-    end
-
-    def self.bounds
-      { x: [0.0, 100.0], y: [0.0, 100.0], z: [0.0, 110.0] }
-    end
-
-    private
-
-    def validate_input(colour_input)
-      XyzConverter.bounds.collect do |key, range|
-        "#{key} must be between #{range[0]} and #{range[1]}" unless colour_input[key].to_f.between?(*range)
-      end.compact
-    end
-
-    def input_to_rgba(colour_input)
-      r, g, b = XyzConverter.xyz_to_rgb(colour_input)
-
-      [r, g, b, 1.0]
-    end
-
-    def self.xyz_to_rgb(xyz_hash)
-      # [0, 100]
-      x = xyz_hash[:x].to_d
-      y = xyz_hash[:y].to_d
-      z = xyz_hash[:z].to_d
-
-      # Convert XYZ (typically with Y=100 for white) to normalized XYZ (Y=1 for white).
-      # The transformation matrix expects X, Y, Z values in the 0-1 range.
-      x /= 100.0.to_d
-      y /= 100.0.to_d
-      z /= 100.0.to_d
-
-      # Convert normalized XYZ to Linear sRGB values using sRGB's own white, D65 (no chromatic adaptation)
-      # https://www.w3.org/TR/css-color-4/#color-conversion-code
-      conversion_matrix = ::Matrix[
-        [BigDecimal('3.2409699419045213'), BigDecimal('-1.5373831775700935'), BigDecimal('-0.4986107602930033')],
-        [BigDecimal('-0.9692436362808798'), BigDecimal('1.8759675015077206'), BigDecimal('0.04155505740717561')],
-        [BigDecimal('0.05563007969699361'), BigDecimal('-0.20397695888897657'), BigDecimal('1.0569715142428786')]
-      ]
-
-      rr, gg, bb = (conversion_matrix * ::Matrix.column_vector([x, y, z])).to_a.flatten
-
-      # [0, 1]
-      RgbConverter.lrgb_to_rgb([rr, gg, bb])
-    end
-
-    # http://www.brucelindbloom.com/index.html?Eqn_RGB_to_XYZ.html
-    def self.rgb_to_xyz(rgb_array_frac)
-      rr, gg, bb = RgbConverter.rgb_to_lrgb(rgb_array_frac)
-
-      # Convert using the RGB/XYZ matrix and sRGB's own white, D65 (no chromatic adaptation)
-      # https://www.w3.org/TR/css-color-4/#color-conversion-code
-      conversion_matrix = ::Matrix[
-        [BigDecimal('0.4123907992659595'), BigDecimal('0.35758433938387796'), BigDecimal('0.1804807884018343')],
-        [BigDecimal('0.21263900587151036'), BigDecimal('0.7151686787677559'), BigDecimal('0.07219231536073371')],
-        [BigDecimal('0.01933081871559185'), BigDecimal('0.11919477979462599'), BigDecimal('0.9505321522496606')]
-      ]
-
-      x, y, z = (conversion_matrix * ::Matrix.column_vector([rr, gg, bb])).to_a.flatten
-
-      # Now, scale X, Y, Z so that Y for D65 white would be 100.
-      x *= 100.0
-      y *= 100.0
-      z *= 100.0
-
-      # Clamping XYZ values to prevent out-of-gamut issues and numerical errors and ensures these values stay within the valid and expected range.
-      # x = x.clamp(0.0..95.047)
-      # y = y.clamp(0.0..100.0)
-      # z = z.clamp(0.0..108.883)
-
-      [x, y, z]
-    end
-
-    def self.d50_to_d65(xyz_array)
-      x, y, z = xyz_array
-
-      conversion_matrix = ::Matrix[
-        [BigDecimal('0.955473421488075'), BigDecimal('-0.02309845494876471'), BigDecimal('0.06325924320057072')],
-        [BigDecimal('-0.0283697093338637'), BigDecimal('1.0099953980813041'), BigDecimal('0.021041441191917323')],
-        [BigDecimal('0.012314014864481998'), BigDecimal('-0.020507649298898964'), BigDecimal('1.330365926242124')]
-      ]
-
-      (conversion_matrix * ::Matrix.column_vector([x, y, z])).to_a.flatten
-    end
-
-    def self.d65_to_d50(xyz_array)
-      x, y, z = xyz_array
-
-      conversion_matrix = ::Matrix[
-        [BigDecimal('1.0479297925449969'), BigDecimal('0.022946870601609652'), BigDecimal('-0.05019226628920524')],
-        [BigDecimal('0.02962780877005599'), BigDecimal('0.9904344267538799'), BigDecimal('-0.017073799063418826')],
-        [BigDecimal('-0.009243040646204504'), BigDecimal('0.015055191490298152'), BigDecimal('0.7518742814281371')]
-      ]
-
-      (conversion_matrix * ::Matrix.column_vector([x, y, z])).to_a.flatten
-    end
-  end
-end
+# frozen_string_literal: true
+
+module ColorConverters
+  class XyzConverter < BaseConverter
+    def self.matches?(colour_input)
+      return false unless colour_input.is_a?(Hash)
+
+      colour_input.keys - [:x, :y, :z] == []
+    end
+
+    def self.bounds
+      { x: [0.0, 100.0], y: [0.0, 100.0], z: [0.0, 110.0] }
+    end
+
+    def self.d65
+      { x: 95.047, y: 100.0, z: 108.883 }
+    end
+
+    private
+
+    # def clamp_input(colour_input)
+    #   colour_input.each { |key, value| colour_input[key] = value.clamp(*XyzConverter.bounds[key]) }
+    # end
+
+    def validate_input(colour_input)
+      XyzConverter.bounds.collect do |key, range|
+        "#{key} must be between #{range[0]} and #{range[1]}" unless colour_input[key].to_f.between?(*range)
+      end.compact
+    end
+
+    def input_to_rgba(colour_input)
+      r, g, b = XyzConverter.xyz_to_rgb(colour_input)
+
+      [r, g, b, 1.0]
+    end
+
+    def self.xyz_to_rgb(xyz_hash)
+      # [0, 100]
+      x = xyz_hash[:x].to_d
+      y = xyz_hash[:y].to_d
+      z = xyz_hash[:z].to_d
+
+      # Convert XYZ (typically with Y=100 for white) to normalized XYZ (Y=1 for white).
+      # The transformation matrix expects X, Y, Z values in the 0-1 range.
+      x /= 100.0.to_d
+      y /= 100.0.to_d
+      z /= 100.0.to_d
+
+      # Convert normalized XYZ to Linear sRGB values using sRGB's own white, D65 (no chromatic adaptation)
+      # https://www.w3.org/TR/css-color-4/#color-conversion-code
+      conversion_matrix = ::Matrix[
+        [BigDecimal('3.2409699419045213'), BigDecimal('-1.5373831775700935'), BigDecimal('-0.4986107602930033')],
+        [BigDecimal('-0.9692436362808798'), BigDecimal('1.8759675015077206'), BigDecimal('0.04155505740717561')],
+        [BigDecimal('0.05563007969699361'), BigDecimal('-0.20397695888897657'), BigDecimal('1.0569715142428786')]
+      ]
+
+      rr, gg, bb = (conversion_matrix * ::Matrix.column_vector([x, y, z])).to_a.flatten
+
+      # [0, 1]
+      RgbConverter.lrgb_to_rgb([rr, gg, bb])
+    end
+
+    # http://www.brucelindbloom.com/index.html?Eqn_RGB_to_XYZ.html
+    def self.rgb_to_xyz(rgb_array_frac)
+      rr, gg, bb = RgbConverter.rgb_to_lrgb(rgb_array_frac)
+
+      # Convert using the RGB/XYZ matrix and sRGB's own white, D65 (no chromatic adaptation)
+      # https://www.w3.org/TR/css-color-4/#color-conversion-code
+      conversion_matrix = ::Matrix[
+        [BigDecimal('0.4123907992659595'), BigDecimal('0.35758433938387796'), BigDecimal('0.1804807884018343')],
+        [BigDecimal('0.21263900587151036'), BigDecimal('0.7151686787677559'), BigDecimal('0.07219231536073371')],
+        [BigDecimal('0.01933081871559185'), BigDecimal('0.11919477979462599'), BigDecimal('0.9505321522496606')]
+      ]
+
+      x, y, z = (conversion_matrix * ::Matrix.column_vector([rr, gg, bb])).to_a.flatten
+
+      # Now, scale X, Y, Z so that Y for D65 white would be 100.
+      x *= 100.0
+      y *= 100.0
+      z *= 100.0
+
+      # Clamping XYZ values to prevent out-of-gamut issues and numerical errors and ensures these values stay within the valid and expected range.
+      # x = x.clamp(0.0..95.047)
+      # y = y.clamp(0.0..100.0)
+      # z = z.clamp(0.0..108.883)
+
+      [x, y, z]
+    end
+
+    def self.d50_to_d65(xyz_array)
+      x, y, z = xyz_array
+
+      conversion_matrix = ::Matrix[
+        [BigDecimal('0.955473421488075'), BigDecimal('-0.02309845494876471'), BigDecimal('0.06325924320057072')],
+        [BigDecimal('-0.0283697093338637'), BigDecimal('1.0099953980813041'), BigDecimal('0.021041441191917323')],
+        [BigDecimal('0.012314014864481998'), BigDecimal('-0.020507649298898964'), BigDecimal('1.330365926242124')]
+      ]
+
+      (conversion_matrix * ::Matrix.column_vector([x, y, z])).to_a.flatten
+    end
+
+    def self.d65_to_d50(xyz_array)
+      x, y, z = xyz_array
+
+      conversion_matrix = ::Matrix[
+        [BigDecimal('1.0479297925449969'), BigDecimal('0.022946870601609652'), BigDecimal('-0.05019226628920524')],
+        [BigDecimal('0.02962780877005599'), BigDecimal('0.9904344267538799'), BigDecimal('-0.017073799063418826')],
+        [BigDecimal('-0.009243040646204504'), BigDecimal('0.015055191490298152'), BigDecimal('0.7518742814281371')]
+      ]
+
+      (conversion_matrix * ::Matrix.column_vector([x, y, z])).to_a.flatten
+    end
+  end
+end

data/lib/color_converters/version.rb

@@ -1,5 +1,5 @@
 # frozen_string_literal: true
 
 module ColorConverters
-  VERSION = '0.1.4'
+  VERSION = '0.1.5'
 end

metadata

@@ -1,13 +1,13 @@
 --- !ruby/object:Gem::Specification
 name: color_converters
 version: !ruby/object:Gem::Version
-  version: 0.1.4
+  version: 0.1.5
 platform: ruby
 authors:
 - Louis Davis
 bindir: bin
 cert_chain: []
-date: 2025-08-21 00:00:00.000000000 Z
+date: 2025-08-30 00:00:00.000000000 Z
 dependencies:
 - !ruby/object:Gem::Dependency
   name: activesupport