red-palette 0.1.0

checksums.yaml

@@ -0,0 +1,7 @@
+---
+SHA256:
+  metadata.gz: 72542b2d2b866247433dcdd20f7dcd233e7c5cc8c55b16c13079f370a9092d3a
+  data.tar.gz: 9cf3c3427e80a3a25b33f6a880f009c5a039f30d2b573a7cfd50d322eec3c260
+SHA512:
+  metadata.gz: 3914868d96a9f88a85c7e22bcde72596db87998a45f3e44bacda5c1ff635046302709711719b53ab912b87dd2569ba8e5b20b32f9a5b5960ac68697fbf56eee5
+  data.tar.gz: 60c4a27bdce6bb0bf5e1455ddbdbc1437857e8fb7ed799a6e62e8c2cc486579ac51bb38f32235c50fc49e853d64fa6ab245bde1a9aea6d8bd6fc54d3b1523e7e

data/.yardopts

@@ -0,0 +1,6 @@
+--output-dir doc/reference/en
+--markup markdown
+--markup-provider kramdown
+lib/**/*.rb
+-
+doc/text/**/*

data/Gemfile

@@ -0,0 +1,3 @@
+source "https://rubygems.org/"
+
+gemspec

data/LICENSE.txt

@@ -0,0 +1,7 @@
+Copyright 2019 Kenta Murata <mrkn@mrkn.jp>
+
+Permission is hereby granted, free of charge, to any person obtaining a copy of this software and associated documentation files (the "Software"), to deal in the Software without restriction, including without limitation the rights to use, copy, modify, merge, publish, distribute, sublicense, and/or sell copies of the Software, and to permit persons to whom the Software is furnished to do so, subject to the following conditions:
+
+The above copyright notice and this permission notice shall be included in all copies or substantial portions of the Software.
+
+THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM, OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE SOFTWARE.

data/README.md

@@ -0,0 +1,23 @@
+# Red Palette
+
+![](https://github.com/red-data-tools/red-palette/workflows/CI/badge.svg)
+
+## Description
+
+Red Palette provides features for dealing with palette.
+
+## Install
+
+```console
+$ gem install red-palette
+```
+
+## Usage
+
+To be described later.
+
+See the [documentation](https://rubydoc.info/gems/red-colors) for now.
+
+## License
+
+The MIT license. See [`LICENSE.txt`](LICENSE.txt) for details.

data/Rakefile

@@ -0,0 +1,19 @@
+require "rubygems"
+require "bundler/gem_helper"
+
+base_dir = File.join(File.dirname(__FILE__))
+
+helper = Bundler::GemHelper.new(base_dir)
+def helper.version_tag
+  version
+end
+
+helper.install
+spec = helper.gemspec
+
+desc "Run tests"
+task :test do
+  ruby("test/run.rb")
+end
+
+task default: :test

data/lib/palette.rb

@@ -0,0 +1,133 @@
+require "colors"
+require "numo/narray"
+
+require_relative "palette/constants"
+require_relative "palette/colors"
+require_relative "palette/statistics"
+
+class Palette
+  include Constants
+
+  # Return a list of colors defining a color palette
+  #
+  # @param palette [nil, String, Palette]
+  #   Name of palette or nil to return current palette.
+  #   If a Palette is given, input colors are used but
+  #   possibly cycled and desaturated.
+  # @param n_colors [Integer, nil]
+  #   Number of colors in the palette.
+  #   If `nil`, the default will depend on how `palette` is specified.
+  #   Named palettes default to 6 colors, but grabbing the current palette
+  #   or passing in a list of colors will not change the number of colors
+  #   unless this is specified.  Asking for more colors than exist in the
+  #   palette cause it to cycle.
+  # @param desaturate_factor [Float, nil]
+  #   Propotion to desaturate each color by.
+  #
+  # @return [Palette]
+  #   Color palette.  Behaves like a list.
+  def initialize(palette=nil, n_colors=nil, desaturate_factor: nil)
+    case
+    when palette.nil?
+      @name = nil
+      palette = Colors::ColorData::DEFAULT_COLOR_CYCLE
+      n_colors ||= palette.length
+    else
+      palette = normalize_palette_name(palette)
+      case palette
+      when String
+        @name = palette
+        # Use all colors in a qualitative palette or 6 of another kind
+        n_colors ||= QUAL_PALETTE_SIZES.fetch(palette, 6)
+        case @name
+        when SEABORN_PALETTES.method(:has_key?)
+          palette = self.class.seaborn_colors(@name)
+        when "hls", "HLS", "hsl", "HSL"
+          palette = self.class.hsl_colors(n_colors)
+        when "husl", "HUSL"
+          palette = self.class.husl_colors(n_colors)
+        when /\Ach:/
+          # Cubehelix palette with params specified in string
+          args, kwargs = parse_cubehelix_args(palette)
+          palette = self.class.cubehelix_colors(n_colors, *args, **kwargs)
+        else
+          begin
+            palette = self.class.matplotlib_colors(palette, n_colors)
+          rescue ArgumentError
+            raise ArgumentError,
+                  "#{palette} is not a valid palette name"
+          end
+        end
+      else
+        n_colors ||= palette.length
+      end
+    end
+    if desaturate_factor
+      palette = palette.map {|c| Colors.desaturate(c, desaturate_factor) }
+    end
+
+    # Always return as many colors as we asked for
+    @colors = palette.cycle.take(n_colors).freeze
+    @desaturate_factor = desaturate_factor
+  end
+
+  attr_reader :name, :colors, :desaturate_factor
+
+  def n_colors
+    @colors.length
+  end
+
+  # Two palettes are equal if they have the same colors, even if they have
+  # the different names and different desaturate factors.
+  def ==(other)
+    case other
+    when Palette
+      colors == other.colors
+    else
+      super
+    end
+  end
+
+  def [](i)
+    @palette[i % n_colors]
+  end
+
+  def to_ary
+    @palette.dup
+  end
+
+  private def normalize_palette_name(palette)
+    case palette
+    when String
+      palette
+    when Symbol
+      palette.to_s
+    else
+      palette.to_str
+    end
+  rescue NoMethodError, TypeError
+    palette
+  end
+
+  class << self
+    attr_reader :default
+
+    def default=(args)
+      @default = case args
+                 when Palette
+                   args
+                 when Array
+                   case args[0]
+                   when Array
+                     Palette.new(*args)
+                   else
+                     Palette.new(args)
+                   end
+                 else
+                   Palette.new(args)
+                 end
+    end
+  end
+
+  self.default = Palette.new("deep").freeze
+end

data/lib/palette/colors.rb

@@ -0,0 +1,60 @@
+class Palette
+  def self.seaborn_colors(name)
+    SEABORN_PALETTES[name].map do |hex_string|
+      Colors::RGB.parse(hex_string)
+    end
+  end
+
+  # Get a set of evenly spaced colors in HSL hue space.
+  #
+  # @param n_colors [Integer]
+  #   The number of colors in the palette
+  # @param h [Numeric]
+  #   The hue value of the first color in degree
+  # @param s [Numeric]
+  #   The saturation value of the first color (between 0 and 1)
+  # @param l [Numeric]
+  #   The lightness value of the first color (between 0 and 1)
+  #
+  # @return [Array<Colors::HSL>]
+  #   The array of colors
+  def self.hsl_colors(n_colors=6, h: 3.6r, s: 0.65r, l: 0.6r)
+    hues = Numo::DFloat.linspace(0, 1, n_colors + 1)[0...-1]
+    hues.inplace + (h/360r).to_f
+    hues.inplace % 1
+    hues.inplace - Numo::Int32.cast(hues)
+    (0...n_colors).map {|i| Colors::HSL.new(hues[i]*360r, s, l) }
+  end
+
+  # Get a set of evenly spaced colors in HUSL hue space.
+  #
+  # @param n_colors [Integer]
+  #   The number of colors in the palette
+  # @param h [Numeric]
+  #   The hue value of the first color in degree
+  # @param s [Numeric]
+  #   The saturation value of the first color (between 0 and 1)
+  # @param l [Numeric]
+  #   The lightness value of the first color (between 0 and 1)
+  #
+  # @return [Array<Colors::HSL>]
+  #   The array of colors
+  def self.husl_colors(n_colors=6, h: 3.6r, s: 0.9r, l: 0.65r)
+    hues = Numo::DFloat.linspace(0, 1, n_colors + 1)[0...-1]
+    hues.inplace + (h/360r).to_f
+    hues.inplace % 1
+    hues.inplace * 359
+    (0...n_colors).map {|i| Colors::HUSL.new(hues[i], s, l) }
+  end
+
+  def self.cubehelix_colors(n_colors, start=0, rot=0.4r, gamma=1.0r, hue=0.8r,
+                             light=0.85r, dark=0.15r, reverse=false, as_cmap: false)
+    raise NotImplementedError,
+          "Cubehelix palette has not been implemented"
+  end
+
+  def self.matplotlib_colors(name, n_colors=6)
+    raise NotImplementedError,
+          "Matplotlib's colormap emulation has not been implemented"
+  end
+end

data/lib/palette/constants.rb

@@ -0,0 +1,51 @@
+class Palette
+  module Constants
+    SEABORN_PALETTES = {
+      "deep" => ["#4C72B0", "#DD8452", "#55A868", "#C44E52", "#8172B3",
+                 "#937860", "#DA8BC3", "#8C8C8C", "#CCB974", "#64B5CD"].freeze,
+      "deep6" => ["#4C72B0", "#55A868", "#C44E52",
+                  "#8172B3", "#CCB974", "#64B5CD"].freeze,
+      "muted" => ["#4878D0", "#EE854A", "#6ACC64", "#D65F5F", "#956CB4",
+                  "#8C613C", "#DC7EC0", "#797979", "#D5BB67", "#82C6E2"].freeze,
+      "muted6" => ["#4878D0", "#6ACC64", "#D65F5F",
+                   "#956CB4", "#D5BB67", "#82C6E2"].freeze,
+      "pastel" => ["#A1C9F4", "#FFB482", "#8DE5A1", "#FF9F9B", "#D0BBFF",
+                   "#DEBB9B", "#FAB0E4", "#CFCFCF", "#FFFEA3", "#B9F2F0"].freeze,
+      "pastel6" => ["#A1C9F4", "#8DE5A1", "#FF9F9B",
+                    "#D0BBFF", "#FFFEA3", "#B9F2F0"].freeze,
+      "bright" => ["#023EFF", "#FF7C00", "#1AC938", "#E8000B", "#8B2BE2",
+                   "#9F4800", "#F14CC1", "#A3A3A3", "#FFC400", "#00D7FF"].freeze,
+      "bright6" => ["#023EFF", "#1AC938", "#E8000B",
+                    "#8B2BE2", "#FFC400", "#00D7FF"].freeze,
+      "dark" => ["#001C7F", "#B1400D", "#12711C", "#8C0800", "#591E71",
+                 "#592F0D", "#A23582", "#3C3C3C", "#B8850A", "#006374"].freeze,
+      "dark6" => ["#001C7F", "#12711C", "#8C0800",
+                  "#591E71", "#B8850A", "#006374"].freeze,
+      "colorblind" => ["#0173B2", "#DE8F05", "#029E73", "#D55E00", "#CC78BC",
+                       "#CA9161", "#FBAFE4", "#949494", "#ECE133", "#56B4E9"].freeze,
+      "colorblind6" => ["#0173B2", "#029E73", "#D55E00",
+                        "#CC78BC", "#ECE133", "#56B4E9"].freeze
+    }.freeze
+
+    MPL_QUAL_PALS = {
+      "tab10" => 10,
+      "tab20" => 20,
+      "tab20b" => 20,
+      "tab20c" => 20,
+      "Set1" => 9,
+      "Set2" => 8,
+      "Set3" => 12,
+      "Accent" => 8,
+      "Paired" => 12,
+      "Pastel1" => 9,
+      "Pastel2" => 8,
+      "Dark2" => 8,
+    }.freeze
+
+    QUAL_PALETTE_SIZES = MPL_QUAL_PALS.dup
+    SEABORN_PALETTES.each do |k, v|
+      QUAL_PALETTE_SIZES[k] = v.length
+    end
+    QUAL_PALETTE_SIZES.freeze
+  end
+end

data/lib/palette/statistics.rb

@@ -0,0 +1,29 @@
+class Palette
+  module Statistics
+    begin
+      require "enumerable/statistics"
+
+      def self.mean(enum)
+        enum.mean
+      end
+
+      def self.stdev(enum, population: false)
+        enum.stdev(population: population)
+      end
+    rescue LoadError
+      def self.mean(enum)
+        xs = enum.to_a
+        xs.sum / xs.length.to_f
+      end
+
+      def self.stdev(enum, population: false)
+        xs = enum.to_a
+        n = xs.length
+        mean = xs.sum.to_f / n
+        ddof = population ? 0 : 1
+        var = xs.map {|x| (x - mean)**2 }.sum / (n - ddof)
+        Math.sqrt(var)
+      end
+    end
+  end
+end

data/lib/palette/version.rb

@@ -0,0 +1,3 @@
+class Palette
+  VERSION = "0.1.0"
+end

data/red-palette.gemspec

@@ -0,0 +1,43 @@
+clean_white_space = lambda do |entry|
+  entry.gsub(/(\A\n+|\n+\z)/, '') + "\n"
+end
+
+$LOAD_PATH.unshift(File.join(File.dirname(__FILE__), "lib"))
+require "palette/version"
+
+Gem::Specification.new do |spec|
+  spec.name = "red-palette"
+  spec.version = Palette::VERSION
+  spec.homepage = "https://github.com/red-data-tools/red-palette"
+  spec.authors = ["Kenta Murata"]
+  spec.email = ["mrkn@mrkn.jp"]
+
+  readme = File.read("README.md")
+  readme.force_encoding("UTF-8")
+  entries = readme.split(/^\#\#\s(.*)$/)
+  clean_white_space.call(entries[entries.index("Description") + 1])
+  description = clean_white_space.call(entries[entries.index("Description") + 1])
+  spec.summary, spec.description, = description.split(/\n\n+/, 3)
+  spec.license = "MIT"
+  spec.files = [
+    "README.md",
+    "LICENSE.txt",
+    "Rakefile",
+    "Gemfile",
+    "#{spec.name}.gemspec",
+  ]
+  spec.files += [".yardopts"]
+  spec.files += Dir.glob("lib/**/*.rb")
+  spec.files += Dir.glob("image/*.*")
+  spec.files += Dir.glob("doc/text/*")
+  spec.test_files += Dir.glob("test/**/*")
+
+  spec.add_dependency("red-colors")
+  spec.add_dependency("numo-narray")
+
+  spec.add_development_dependency("bundler")
+  spec.add_development_dependency("rake")
+  spec.add_development_dependency("test-unit")
+  spec.add_development_dependency("yard")
+  spec.add_development_dependency("kramdown")
+end

data/test/helper.rb

@@ -0,0 +1,13 @@
+$LOAD_PATH.unshift File.expand_path('../../lib', __FILE__)
+require 'palette'
+require 'test/unit'
+
+module TestHelper
+  def assert_near(c1, c2, eps=1e-8)
+    assert_equal(c1.class, c2.class)
+    c1.components.zip(c2.components).each do |x1, x2|
+      x1, x2 = [x1, x2].map(&:to_f)
+      assert { (x1 - x2).abs < eps }
+    end
+  end
+end

data/test/palette_test.rb

@@ -0,0 +1,150 @@
+class PaletteTest < Test::Unit::TestCase
+  include TestHelper
+
+  sub_test_case(".default") do
+    test("the initial value") do
+      assert_equal(Palette.new("deep"), Palette.default)
+    end
+  end
+
+  test(".default=") do
+    begin
+      save = Palette.default
+      palette = Palette.new("colorblind")
+      Palette.default = palette
+      assert_same(palette, Palette.default)
+    ensure
+      Palette.default = save
+    end
+  end
+
+  test("array palette") do
+    palette = Palette.new(["red", "green", "blue"])
+    assert_equal(nil, palette.name)
+    assert_equal(3, palette.n_colors)
+    assert_equal(["red", "green", "blue"], palette.colors)
+  end
+
+  sub_test_case("seaborn's named palette") do
+    test("deep") do
+      palette = Palette.new("deep")
+      assert_equal("deep", palette.name)
+      assert_equal(Palette::QUAL_PALETTE_SIZES["deep"],
+                   palette.n_colors)
+      assert_equal(Palette::SEABORN_PALETTES["deep"].map {|c|
+                     Colors::RGB.parse(c)
+                   },
+                   palette.colors)
+    end
+
+    test("pastel6") do
+      palette = Palette.new("pastel6")
+      assert_equal("pastel6", palette.name)
+      assert_equal(Palette::QUAL_PALETTE_SIZES["pastel6"],
+                   palette.n_colors)
+      assert_equal(Palette::SEABORN_PALETTES["pastel6"].map {|c|
+                     Colors::RGB.parse(c)
+                   },
+                   palette.colors)
+    end
+  end
+
+  test("HSL color palette") do
+    assert_equal(6,
+                 Palette.new("hsl").n_colors)
+  end
+
+  test("HUSL color palette") do
+    omit("Not implemented yet")
+    assert_equal(6,
+                 Palette.new("husl").n_colors)
+  end
+
+  test(".hsl_colors") do
+    palette1 = Palette.hsl_colors(6, h: 0)
+    palette2 = Palette.hsl_colors(6, h: 360/2r)
+    palette2 = palette2[3..-1] + palette2[0...3]
+    palette1.zip(palette2).each do |c1, c2|
+      assert_in_delta(c1.h, c2.h, 1e-6)
+      assert_in_delta(c1.s, c2.s, 1e-6)
+      assert_in_delta(c1.l, c2.l, 1e-6)
+    end
+
+    palette_dark = Palette.hsl_colors(5, l: 0.2)
+    palette_bright = Palette.hsl_colors(5, l: 0.8)
+    palette_dark.zip(palette_bright).each do |c1, c2|
+      s1 = c1.to_rgb.components.sum
+      s2 = c2.to_rgb.components.sum
+      assert do
+        s1 < s2
+      end
+    end
+
+    palette_flat = Palette.hsl_colors(5, s: 0.1)
+    palette_bold = Palette.hsl_colors(5, s: 0.9)
+    palette_flat.zip(palette_bold).each do |c1, c2|
+      s1 = Palette::Statistics.stdev(c1.to_rgb.components, population: true).to_f
+      s2 = Palette::Statistics.stdev(c2.to_rgb.components, population: true).to_f
+      assert do
+        s1 < s2
+      end
+    end
+  end
+
+  test(".husl_colors") do
+    palette1 = Palette.husl_colors(6, h: 0)
+    palette2 = Palette.husl_colors(6, h: 360/2r)
+    palette2 = palette2[3..-1] + palette2[0...3]
+    palette1.zip(palette2).each do |c1, c2|
+      assert_in_delta(c1.h, c2.h, 1e-6)
+      assert_in_delta(c1.s, c2.s, 1e-6)
+      assert_in_delta(c1.l, c2.l, 1e-6)
+    end
+
+    palette_dark = Palette.husl_colors(5, l: 0.2)
+    palette_bright = Palette.husl_colors(5, l: 0.8)
+    palette_dark.zip(palette_bright).each do |c1, c2|
+      s1 = c1.to_rgb.components.sum
+      s2 = c2.to_rgb.components.sum
+      assert do
+        s1 < s2
+      end
+    end
+
+    palette_flat = Palette.husl_colors(5, s: 0.1)
+    palette_bold = Palette.husl_colors(5, s: 0.9)
+    palette_flat.zip(palette_bold).each do |c1, c2|
+      s1 = Palette::Statistics.stdev(c1.to_rgb.components)
+      s2 = Palette::Statistics.stdev(c2.to_rgb.components)
+      assert do
+        s1 < s2
+      end
+    end
+  end
+
+  test(".cubehelix_colors") do
+    omit("Not implemented yet")
+  end
+
+  sub_test_case(".matplotlib_colors") do
+    test("Set3") do
+      omit("Not implemented yet")
+      palette = Palette.new("Set3")
+      assert_equal("Set3", palette.name)
+      assert_equal(Palette::QUAL_PALETTE_SIZES["Set3"],
+                   palette.n_colors)
+      assert_equal(Palette::SEABORN_PALETTES["Set3"].map {|c|
+                     Colors::RGB.parse(c)
+                   },
+                   palette.colors)
+    end
+  end
+
+  test("desaturation feature") do
+    desaturated_colors = Palette.new(["#ff0000", "#00ff0099"], desaturate_factor: 0.8).colors
+    assert_near(Colors::HSL.new(0, 0.8r, 0.5r).to_rgb,
+                desaturated_colors[0])
+    assert_near(Colors::HSLA.new(120r, 0.8r, 0.5r, 0x99/255r).to_rgba,
+                desaturated_colors[1])
+  end
+end

data/test/run.rb

@@ -0,0 +1,17 @@
+#!/usr/bin/env ruby
+
+# TODO
+# $VERBOSE = true
+
+require "pathname"
+
+base_dir = Pathname(__dir__).parent.expand_path
+
+lib_dir = base_dir + "lib"
+test_dir = base_dir + "test"
+
+$LOAD_PATH.unshift(lib_dir.to_s)
+
+require_relative "helper"
+
+exit(Test::Unit::AutoRunner.run(true, test_dir.to_s))

metadata

@@ -0,0 +1,158 @@
+--- !ruby/object:Gem::Specification
+name: red-palette
+version: !ruby/object:Gem::Version
+  version: 0.1.0
+platform: ruby
+authors:
+- Kenta Murata
+autorequire: 
+bindir: bin
+cert_chain: []
+date: 2020-01-18 00:00:00.000000000 Z
+dependencies:
+- !ruby/object:Gem::Dependency
+  name: red-colors
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - ">="
+      - !ruby/object:Gem::Version
+        version: '0'
+  type: :runtime
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - ">="
+      - !ruby/object:Gem::Version
+        version: '0'
+- !ruby/object:Gem::Dependency
+  name: numo-narray
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - ">="
+      - !ruby/object:Gem::Version
+        version: '0'
+  type: :runtime
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - ">="
+      - !ruby/object:Gem::Version
+        version: '0'
+- !ruby/object:Gem::Dependency
+  name: bundler
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - ">="
+      - !ruby/object:Gem::Version
+        version: '0'
+  type: :development
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - ">="
+      - !ruby/object:Gem::Version
+        version: '0'
+- !ruby/object:Gem::Dependency
+  name: rake
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - ">="
+      - !ruby/object:Gem::Version
+        version: '0'
+  type: :development
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - ">="
+      - !ruby/object:Gem::Version
+        version: '0'
+- !ruby/object:Gem::Dependency
+  name: test-unit
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - ">="
+      - !ruby/object:Gem::Version
+        version: '0'
+  type: :development
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - ">="
+      - !ruby/object:Gem::Version
+        version: '0'
+- !ruby/object:Gem::Dependency
+  name: yard
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - ">="
+      - !ruby/object:Gem::Version
+        version: '0'
+  type: :development
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - ">="
+      - !ruby/object:Gem::Version
+        version: '0'
+- !ruby/object:Gem::Dependency
+  name: kramdown
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - ">="
+      - !ruby/object:Gem::Version
+        version: '0'
+  type: :development
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - ">="
+      - !ruby/object:Gem::Version
+        version: '0'
+description: ''
+email:
+- mrkn@mrkn.jp
+executables: []
+extensions: []
+extra_rdoc_files: []
+files:
+- ".yardopts"
+- Gemfile
+- LICENSE.txt
+- README.md
+- Rakefile
+- lib/palette.rb
+- lib/palette/colors.rb
+- lib/palette/constants.rb
+- lib/palette/statistics.rb
+- lib/palette/version.rb
+- red-palette.gemspec
+- test/helper.rb
+- test/palette_test.rb
+- test/run.rb
+homepage: https://github.com/red-data-tools/red-palette
+licenses:
+- MIT
+metadata: {}
+post_install_message: 
+rdoc_options: []
+require_paths:
+- lib
+required_ruby_version: !ruby/object:Gem::Requirement
+  requirements:
+  - - ">="
+    - !ruby/object:Gem::Version
+      version: '0'
+required_rubygems_version: !ruby/object:Gem::Requirement
+  requirements:
+  - - ">="
+    - !ruby/object:Gem::Version
+      version: '0'
+requirements: []
+rubygems_version: 3.1.2
+signing_key: 
+specification_version: 4
+summary: Red Palette provides features for dealing with palette.
+test_files:
+- test/helper.rb
+- test/palette_test.rb
+- test/run.rb