geo_pattern 1.3.2 → 1.5.0

data/lib/geo_pattern/structure_generators/tessellation_generator.rb

@@ -0,0 +1,105 @@
+# frozen_string_literal: true
+
+module GeoPattern
+  module StructureGenerators
+    class TessellationGenerator < BaseGenerator
+      private
+
+      attr_reader :side_length, :hex_height, :hex_width, :triangle_height, :triangle, :tile_width, :tile_height
+
+      def after_initialize
+        # 3.4.6.4 semi-regular tessellation
+        @side_length = map(hex_val(0, 1), 0, 15, 5, 40)
+        @hex_height = side_length * Math.sqrt(3)
+        @hex_width = side_length * 2
+        @triangle_height = side_length / 2 * Math.sqrt(3)
+        @triangle = build_rotated_triangle_shape(side_length, triangle_height)
+        @tile_width = side_length * 3 + triangle_height * 2
+        @tile_height = (hex_height * 2) + (side_length * 2)
+
+        self.height = tile_height
+        self.width = tile_width
+      end
+
+      def generate_structure
+        20.times do |i|
+          val = hex_val(i, 1)
+          opacity = opacity(val)
+          fill = fill_color(val)
+
+          styles = {
+            "stroke" => stroke_color,
+            "stroke-opacity" => stroke_opacity,
+            "fill" => fill,
+            "fill-opacity" => opacity,
+            "stroke-width" => 1
+          }
+
+          case i
+          when 0 # all 4 corners
+            svg.rect(-side_length / 2, -side_length / 2, side_length, side_length, styles)
+            svg.rect(tile_width - side_length / 2, -side_length / 2, side_length, side_length, styles)
+            svg.rect(-side_length / 2, tile_height - side_length / 2, side_length, side_length, styles)
+            svg.rect(tile_width - side_length / 2, tile_height - side_length / 2, side_length, side_length, styles)
+          when 1 # center / top square
+            svg.rect(hex_width / 2 + triangle_height, hex_height / 2, side_length, side_length, styles)
+          when 2 # side squares
+            svg.rect(-side_length / 2, tile_height / 2 - side_length / 2, side_length, side_length, styles)
+            svg.rect(tile_width - side_length / 2, tile_height / 2 - side_length / 2, side_length, side_length, styles)
+          when 3 # center / bottom square
+            svg.rect(hex_width / 2 + triangle_height, hex_height * 1.5 + side_length, side_length, side_length, styles)
+          when 4 # left top / bottom triangle
+            svg.polyline(triangle, styles.merge("transform" => "translate(#{side_length / 2}, #{-side_length / 2}) rotate(0, #{side_length / 2}, #{triangle_height / 2})"))
+            svg.polyline(triangle, styles.merge("transform" => "translate(#{side_length / 2}, #{tile_height - -side_length / 2}) rotate(0, #{side_length / 2}, #{triangle_height / 2}) scale(1, -1)"))
+          when 5 # right top / bottom triangle
+            svg.polyline(triangle, styles.merge("transform" => "translate(#{tile_width - side_length / 2}, #{-side_length / 2}) rotate(0, #{side_length / 2}, #{triangle_height / 2}) scale(-1, 1)"))
+            svg.polyline(triangle, styles.merge("transform" => "translate(#{tile_width - side_length / 2}, #{tile_height + side_length / 2}) rotate(0, #{side_length / 2}, #{triangle_height / 2}) scale(-1, -1)"))
+          when 6 # center / top / right triangle
+            svg.polyline(triangle, styles.merge("transform" => "translate(#{tile_width / 2 + side_length / 2}, #{hex_height / 2})"))
+          when 7 # center / top / left triangle
+            svg.polyline(triangle, styles.merge("transform" => "translate(#{tile_width - tile_width / 2 - side_length / 2}, #{hex_height / 2}) scale(-1, 1)"))
+          when 8 # center / bottom / right triangle
+            svg.polyline(triangle, styles.merge("transform" => "translate(#{tile_width / 2 + side_length / 2}, #{tile_height - hex_height / 2}) scale(1, -1)"))
+          when 9 # center / bottom / left triangle
+            svg.polyline(triangle, styles.merge("transform" => "translate(#{tile_width - tile_width / 2 - side_length / 2}, #{tile_height - hex_height / 2}) scale(-1, -1)"))
+          when 10 # left / middle triangle
+            svg.polyline(triangle, styles.merge("transform" => "translate(#{side_length / 2}, #{tile_height / 2 - side_length / 2})"))
+          when 11 # right / middle triangle
+            svg.polyline(triangle, styles.merge("transform" => "translate(#{tile_width - side_length / 2}, #{tile_height / 2 - side_length / 2}) scale(-1, 1)"))
+          when 12 # left / top square
+            svg.rect(0, 0, side_length, side_length,
+              styles.merge("transform" => "translate(#{side_length / 2}, #{side_length / 2}) rotate(-30, 0, 0)"))
+          when 13 # right / top square
+            svg.rect(0, 0, side_length, side_length,
+              styles.merge("transform" => "scale(-1, 1) translate(#{-tile_width + side_length / 2}, #{side_length / 2}) rotate(-30, 0, 0)"))
+          when 14 # left / center-top square
+            svg.rect(0, 0, side_length, side_length,
+              styles.merge("transform" => "translate(#{side_length / 2}, #{tile_height / 2 - side_length / 2 - side_length}) rotate(30, 0, #{side_length})"))
+          when 15 # right / center-top square
+            svg.rect(0, 0, side_length, side_length,
+              styles.merge("transform" => "scale(-1, 1) translate(#{-tile_width + side_length / 2}, #{tile_height / 2 - side_length / 2 - side_length}) rotate(30, 0, #{side_length})"))
+          when 16 # left / center-top square
+            svg.rect(0, 0, side_length, side_length,
+              styles.merge("transform" => "scale(1, -1) translate(#{side_length / 2}, #{-tile_height + tile_height / 2 - side_length / 2 - side_length}) rotate(30, 0, #{side_length})"))
+          when 17 # right / center-bottom square
+            svg.rect(0, 0, side_length, side_length,
+              styles.merge("transform" => "scale(-1, -1) translate(#{-tile_width + side_length / 2}, #{-tile_height + tile_height / 2 - side_length / 2 - side_length}) rotate(30, 0, #{side_length})"))
+          when 18 # left / bottom square
+            svg.rect(0, 0, side_length, side_length,
+              styles.merge("transform" => "scale(1, -1) translate(#{side_length / 2}, #{-tile_height + side_length / 2}) rotate(-30, 0, 0)"))
+          when 19 # right / bottom square
+            svg.rect(0, 0, side_length, side_length,
+              styles.merge("transform" => "scale(-1, -1) translate(#{-tile_width + side_length / 2}, #{-tile_height + side_length / 2}) rotate(-30, 0, 0)"))
+          end
+        end
+
+        svg
+      end
+
+      def build_rotated_triangle_shape(side_length, width)
+        half_height = side_length / 2
+        "0, 0, #{width}, #{half_height}, 0, #{side_length}, 0, 0"
+      end
+    end
+  end
+end

data/lib/geo_pattern/structure_generators/triangles_generator.rb

@@ -0,0 +1,64 @@
+# frozen_string_literal: true
+
+module GeoPattern
+  module StructureGenerators
+    class TrianglesGenerator < BaseGenerator
+      private
+
+      attr_reader :scale, :side_length, :triangle_height, :triangle
+
+      def after_initialize
+        @scale = hex_val(0, 1)
+        @side_length = map(scale, 0, 15, 15, 80)
+        @triangle_height = side_length / 2 * Math.sqrt(3)
+        @triangle = build_triangle_shape(side_length, triangle_height)
+
+        self.width = side_length * 3
+        self.height = triangle_height * 6
+      end
+
+      def generate_structure
+        i = 0
+        6.times do |y|
+          6.times do |x|
+            val = hex_val(i, 1)
+            opacity = opacity(val)
+            fill = fill_color(val)
+
+            styles = {
+              "fill" => fill,
+              "fill-opacity" => opacity,
+              "stroke" => stroke_color,
+              "stroke-opacity" => stroke_opacity
+            }
+
+            rotation = if y % 2 == 0
+              (x % 2 == 0) ? 180 : 0
+            else
+              (x % 2 != 0) ? 180 : 0
+            end
+
+            svg.polyline(triangle, styles.merge(
+              "transform" => "translate(#{x * side_length * 0.5 - side_length / 2}, #{triangle_height * y}) rotate(#{rotation}, #{side_length / 2}, #{triangle_height / 2})"
+            ))
+
+            # Add an extra one at top-right, for tiling.
+            if x == 0
+              svg.polyline(triangle, styles.merge(
+                "transform" => "translate(#{6 * side_length * 0.5 - side_length / 2}, #{triangle_height * y}) rotate(#{rotation}, #{side_length / 2}, #{triangle_height / 2})"
+              ))
+            end
+            i += 1
+          end
+        end
+
+        svg
+      end
+
+      def build_triangle_shape(side_length, height)
+        half_width = side_length / 2
+        "#{half_width}, 0, #{side_length}, #{height}, 0, #{height}, #{half_width}, 0"
+      end
+    end
+  end
+end

data/lib/geo_pattern/structure_generators/xes_generator.rb

@@ -0,0 +1,74 @@
+# frozen_string_literal: true
+
+module GeoPattern
+  module StructureGenerators
+    class XesGenerator < BaseGenerator
+      private
+
+      attr_reader :square_size, :x_shape, :x_size
+
+      def after_initialize
+        @square_size = map(hex_val(0, 1), 0, 15, 10, 25)
+        @x_shape = build_plus_shape(square_size) # rotated later
+        @x_size = square_size * 3 * 0.943
+
+        self.height = self.width = x_size * 3
+      end
+
+      def generate_structure
+        i = 0
+        6.times do |y|
+          6.times do |x|
+            val = hex_val(i, 1)
+            opacity = opacity(val)
+            dy = (x % 2 == 0) ? y * x_size - x_size * 0.5 : y * x_size - x_size * 0.5 + x_size / 4
+            fill = fill_color(val)
+
+            styles = {
+              "fill" => fill,
+              "style" => {
+                "opacity" => opacity
+              }
+            }
+
+            svg.group(x_shape, styles.merge(
+              "transform" => "translate(#{x * x_size / 2 - x_size / 2},#{dy - y * x_size / 2}) rotate(45, #{x_size / 2}, #{x_size / 2})"
+            ))
+
+            # Add an extra column on the right for tiling.
+            if x == 0
+              svg.group(x_shape, styles.merge(
+                "transform" => "translate(#{6 * x_size / 2 - x_size / 2},#{dy - y * x_size / 2}) rotate(45, #{x_size / 2}, #{x_size / 2})"
+              ))
+            end
+
+            # Add an extra row on the bottom that matches the first row, for tiling.
+            if y == 0
+              dy = (x % 2 == 0) ? 6 * x_size - x_size / 2 : 6 * x_size - x_size / 2 + x_size / 4
+              svg.group(x_shape, styles.merge(
+                "transform" => "translate(#{x * x_size / 2 - x_size / 2},#{dy - 6 * x_size / 2}) rotate(45, #{x_size / 2}, #{x_size / 2})"
+              ))
+            end
+
+            # These can hang off the bottom, so put a row at the top for tiling.
+            if y == 5
+              svg.group(x_shape, styles.merge(
+                "transform" => "translate(#{x * x_size / 2 - x_size / 2},#{dy - 11 * x_size / 2}) rotate(45, #{x_size / 2}, #{x_size / 2})"
+              ))
+            end
+
+            # Add an extra one at top-right and bottom-right, for tiling.
+            if x == 0 && y == 0
+              svg.group(x_shape, styles.merge(
+                "transform" => "translate(#{6 * x_size / 2 - x_size / 2},#{dy - 6 * x_size / 2}) rotate(45, #{x_size / 2}, #{x_size / 2})"
+              ))
+            end
+            i += 1
+          end
+        end
+
+        svg
+      end
+    end
+  end
+end

data/lib/geo_pattern/svg_image.rb

@@ -0,0 +1,103 @@
+# frozen_string_literal: true
+
+module GeoPattern
+  class SvgImage
+    include Comparable
+
+    private
+
+    attr_reader :svg_string
+
+    public
+
+    attr_reader :height, :width
+
+    def initialize
+      @width = 100
+      @height = 100
+      @svg_string = +""
+    end
+
+    def width=(width)
+      @width = width.floor
+    end
+
+    def height=(height)
+      @height = height.floor
+    end
+
+    # Pattern includes string
+    #
+    # @param [String] string
+    #   The string which should be included in the body of the SvgImage
+    def include?(string)
+      body.include? string
+    end
+
+    def svg_header
+      %(<svg xmlns="http://www.w3.org/2000/svg" width="#{@width}" height="#{@height}">)
+    end
+
+    def svg_closer
+      "</svg>"
+    end
+
+    def to_s
+      svg_header + svg_string + svg_closer
+    end
+
+    def body
+      svg_string
+    end
+
+    def <<(svg)
+      svg_string << svg.body
+    end
+
+    def rect(x, y, width, height, args = {})
+      svg_string << %(<rect x="#{x}" y="#{y}" width="#{width}" height="#{height}" #{write_args(args)} />)
+    end
+
+    def circle(cx, cy, r, args = {})
+      svg_string << %(<circle cx="#{cx}" cy="#{cy}" r="#{r}" #{write_args(args)} />)
+    end
+
+    def path(str, args = {})
+      svg_string << %(<path d="#{str}" #{write_args(args)} />)
+    end
+
+    def polyline(str, args = {})
+      svg_string << %(<polyline points="#{str}" #{write_args(args)} />)
+    end
+
+    def group(elements, args = {})
+      svg_string << %(<g #{write_args(args)}>)
+      elements.each { |e| eval e } # rubocop:disable Security/Eval
+      svg_string << %(</g>)
+    end
+
+    def write_args(args)
+      str = +""
+      args.each do |key, value|
+        if value.is_a?(Hash)
+          str << %(#{key}=")
+          value.each do |k, v|
+            str << %(#{k}:#{v};)
+          end
+          str << %(" )
+        else
+          str << %(#{key}="#{value}" )
+        end
+      end
+      str
+    end
+
+    def self.as_comment(str)
+      "<!-- #{str} -->"
+    end
+
+    def <=>(other)
+      to_s <=> other.to_s
+    end
+  end
+end

data/lib/geo_pattern/version.rb

@@ -1,3 +1,5 @@
+# frozen_string_literal: true
+
 module GeoPattern
-  VERSION = "1.3.2"
+  VERSION = "1.5.0"
 end

data/lib/geo_pattern.rb

@@ -1,34 +1,58 @@
-require 'base64'
-require 'digest/sha1'
-require 'color'
-
-require 'geo_pattern/version'
-require 'geo_pattern/svg'
-require 'geo_pattern/pattern_helpers'
-require 'geo_pattern/helpers'
-
-require 'geo_pattern/pattern/base_pattern'
-require 'geo_pattern/pattern/chevron_pattern'
-require 'geo_pattern/pattern/concentric_circles_pattern'
-require 'geo_pattern/pattern/diamond_pattern'
-require 'geo_pattern/pattern/hexagon_pattern'
-require 'geo_pattern/pattern/mosaic_squares_pattern'
-require 'geo_pattern/pattern/nested_squares_pattern'
-require 'geo_pattern/pattern/octagon_pattern'
-require 'geo_pattern/pattern/overlapping_circles_pattern'
-require 'geo_pattern/pattern/overlapping_rings_pattern'
-require 'geo_pattern/pattern/plaid_pattern'
-require 'geo_pattern/pattern/plus_sign_pattern'
-require 'geo_pattern/pattern/sine_wave_pattern'
-require 'geo_pattern/pattern/square_pattern'
-require 'geo_pattern/pattern/tessellation_pattern'
-require 'geo_pattern/pattern/triangle_pattern'
-require 'geo_pattern/pattern/xes_pattern'
-
-require 'geo_pattern/pattern_generator'
+# frozen_string_literal: true
+
+require "base64"
+require "digest/sha1"
+require "color"
+require "forwardable"
+
+require "geo_pattern/version"
+
+require "geo_pattern/roles/named_generator"
+require "geo_pattern/roles/comparable_metadata"
+
+require "geo_pattern/errors"
+require "geo_pattern/color"
+require "geo_pattern/svg_image"
+require "geo_pattern/pattern_helpers"
+require "geo_pattern/helpers"
+require "geo_pattern/pattern_store"
+require "geo_pattern/pattern_validator"
+require "geo_pattern/pattern_sieve"
+require "geo_pattern/pattern"
+require "geo_pattern/seed"
+require "geo_pattern/pattern_preset"
+require "geo_pattern/color_preset"
+
+require "geo_pattern/structure"
+require "geo_pattern/background"
+
+require "geo_pattern/color_generators/simple_generator"
+require "geo_pattern/color_generators/base_color_generator"
+
+require "geo_pattern/background_generators/solid_generator"
+
+require "geo_pattern/structure_generators/base_generator"
+require "geo_pattern/structure_generators/chevrons_generator"
+require "geo_pattern/structure_generators/concentric_circles_generator"
+require "geo_pattern/structure_generators/diamonds_generator"
+require "geo_pattern/structure_generators/hexagons_generator"
+require "geo_pattern/structure_generators/mosaic_squares_generator"
+require "geo_pattern/structure_generators/nested_squares_generator"
+require "geo_pattern/structure_generators/octagons_generator"
+require "geo_pattern/structure_generators/overlapping_circles_generator"
+require "geo_pattern/structure_generators/overlapping_rings_generator"
+require "geo_pattern/structure_generators/plaid_generator"
+require "geo_pattern/structure_generators/plus_signs_generator"
+require "geo_pattern/structure_generators/sine_waves_generator"
+require "geo_pattern/structure_generators/squares_generator"
+require "geo_pattern/structure_generators/tessellation_generator"
+require "geo_pattern/structure_generators/triangles_generator"
+require "geo_pattern/structure_generators/xes_generator"
+
+require "geo_pattern/pattern_generator"
 
 module GeoPattern
-  def self.generate(string=Time.now, opts={})
-    GeoPattern::PatternGenerator.new(string.to_s, opts)
+  def self.generate(string = Time.now, opts = {})
+    GeoPattern::PatternGenerator.new(string.to_s, **opts).generate
   end
 end

data/script/bootstrap

@@ -0,0 +1,30 @@
+#!/bin/bash
+
+set -e
+
+info_msg="\e[0;32m[INFO]\e[0;30m"
+error_msg="\e[0;31mFAILED\e[0;30m"
+
+function output_error_log {
+  [[ -f error.log ]] && ( cat error.log >&2; rm error.log)
+}
+
+echo -ne "$info_msg Checking if ruby installed? "
+which 'ruby' >/dev/null 2>error.log || ( echo -e "$error_msg\n\nCould not find \`ruby\`. Please install ruby or add it to PATH"; output_error_log; exit 1 )
+echo OK
+
+echo -en "$info_msg rubygem \"rake\" "
+gem install rake >/dev/null 2>error.log || ( echo -e "$error_msg\n\nAn error occurred during installation of rake. Run \`gem install rake\` yourself."; output_error_log; exit 1 )
+echo OK
+
+if [ -n "$CI" ]; then
+  echo -e "$info_msg Bootstrapping in CI mode"
+  rake_task='bootstrap:ci'
+else
+  echo -e "$info_msg Bootstrapping in normal mode"
+  rake_task='bootstrap'
+fi
+
+echo -en "$info_msg Running rake task \"$rake_task\" "
+rake --trace $rake_task >error.log 2>&1 || ( echo -e "$error_msg\n\nAn error occurred during run of rake-task \"$rake_task\". Run \`rake $rake_task\` yourself."; output_error_log; exit 1 )
+echo OK

data/script/console

@@ -0,0 +1,9 @@
+#!/usr/bin/env ruby
+# frozen_string_literal: true
+
+$LOAD_PATH << File.expand_path("../lib", __dir__)
+
+require "pry"
+require "geo_pattern"
+
+Pry.start

data/script/test

@@ -0,0 +1,21 @@
+#!/bin/bash
+
+set -e
+
+function output_error_log {
+  [[ -f error.log ]] && ( cat error.log >&2; rm error.log)
+}
+
+info_msg="\e[0;32m[INFO]\e[0;30m"
+error_msg="\e[0;31mFAILED\e[0;30m"
+
+if [ -n "$CI" ]; then
+  echo -e "$info_msg Testing in CI mode"
+  rake_task='test:ci'
+else
+  echo -e "$info_msg Testing in normal mode"
+  rake_task='test'
+fi
+
+echo -en "$info_msg Running rake task \"$rake_task\" "
+bundle exec rake --trace $rake_task

data/spec/background_generators/solid_generator_spec.rb

@@ -0,0 +1,52 @@
+# frozen_string_literal: true
+
+require "spec_helper"
+
+RSpec.describe BackgroundGenerators::SolidGenerator do
+  subject(:generator) { described_class.new(seed, preset) }
+
+  let(:seed) { instance_double("GeoPattern::Seed") }
+  let(:preset) { instance_double("GeoPattern::ColorPreset") }
+  let(:pattern) { instance_double("GeoPattern::Pattern") }
+  let(:background_metadata) { instance_double("GeoPattern::BackgroundMetadata") }
+
+  let(:color) { "#aaaaaa" }
+  let(:base_color) { "#bbbbbb" }
+  let(:base_color_should_be_used) { true }
+
+  before :each do
+    allow(seed).to receive(:to_i).with(14, 3).and_return(2616)
+    allow(seed).to receive(:to_i).with(17, 1).and_return(3)
+
+    allow(preset).to receive(:mode?).with(:base_color).and_return(base_color_should_be_used)
+    allow(preset).to receive(:color).and_return(color)
+    allow(preset).to receive(:base_color).and_return(base_color)
+  end
+
+  it { is_expected.not_to be_nil }
+
+  describe "#generate" do
+    context "when base color is given" do
+      let(:generated_color) { %w[187 187 187] }
+
+      before :each do
+        expect(pattern).to receive(:background=).with(have_image_with_rgb_color(generated_color))
+      end
+
+      it { generator.generate(pattern) }
+    end
+
+    context "when color is given" do
+      let(:base_color_should_be_used) { false }
+      let(:generated_color) { %w[170 170 170] }
+
+      before :each do
+        expect(pattern).to receive(:background=).with(have_image_with_rgb_color(generated_color))
+      end
+
+      it { generator.generate(pattern) }
+    end
+
+    it_behaves_like "a named generator", :solid
+  end
+end

data/spec/background_spec.rb

@@ -0,0 +1,27 @@
+# frozen_string_literal: true
+
+require "spec_helper"
+
+RSpec.describe Background do
+  subject(:metadata) { described_class.new(image: svg_image, preset: preset, generator: generator, color: color) }
+
+  let(:svg_image) { instance_double("GeoPattern::SvgImage") }
+  let(:svg_image_content) { fixtures_path("generated_patterns/sine_waves.svg").read.chomp }
+  let(:preset) { instance_double("GeoPattern::ColorPreset") }
+  let(:generator) { stub_const("GeoPattern::BackgroundGenerators::SolidGenerator", Class.new) }
+
+  let(:color) { "#aaaaaa" }
+  let(:base_color) { "#bbbbbb" }
+
+  it { is_expected.not_to be_nil }
+
+  before :each do
+    allow(preset).to receive(:color).and_return(color)
+    allow(preset).to receive(:base_color).and_return(base_color)
+  end
+
+  it_behaves_like "a metadata argument", :color
+  it_behaves_like "a metadata argument", :generator
+  it_behaves_like "a forwarded metadata argument", :base_color
+  it_behaves_like "a forwarded metadata argument", :color
+end

data/spec/color_generators/base_color_generator_spec.rb

@@ -0,0 +1,33 @@
+# frozen_string_literal: true
+
+require "spec_helper"
+
+RSpec.describe ColorGenerators::BaseColorGenerator do
+  subject(:generator) { described_class.new(color_string, seed) }
+
+  let(:seed) { instance_double("GeoPattern::Seed") }
+  let(:seed_value1) { 2616 }
+  let(:seed_value2) { 2 }
+
+  let(:color_string) { "#ff00ff" }
+
+  it { is_expected.not_to be_nil }
+
+  before :each do
+    allow(seed).to receive(:to_i).with(14, 3).and_return(seed_value1)
+    allow(seed).to receive(:to_i).with(17, 1).and_return(seed_value2)
+  end
+
+  describe "#generate" do
+    let(:color) { generator.generate }
+
+    context "when sat offset is % 2 == 0" do
+      it { expect(color.to_svg).to eq "rgb(210, 255, 0)" }
+    end
+
+    context "when sat offset is not % 2 == 0" do
+      let(:seed_value2) { 3 }
+      it { expect(color.to_svg).to eq "rgb(207, 251, 4)" }
+    end
+  end
+end

data/spec/color_generators/simple_generator_spec.rb

@@ -0,0 +1,14 @@
+# frozen_string_literal: true
+
+RSpec.describe ColorGenerators::SimpleGenerator do
+  subject(:generator) { described_class.new(color_string) }
+
+  let(:color_string) { "#ff00ff" }
+
+  it { is_expected.not_to be_nil }
+
+  describe "#generate" do
+    let(:color) { generator.generate }
+    it { expect(color.to_svg).to eq "rgb(255, 0, 255)" }
+  end
+end