geo_pattern 1.3.2 → 1.5.0

data/spec/color_preset_spec.rb

@@ -0,0 +1,55 @@
+# frozen_string_literal: true
+
+require "spec_helper"
+
+RSpec.describe ColorPreset do
+  subject(:preset) { ColorPreset.new(**options) }
+  let(:options) do
+    {
+      base_color: "#0f0f0f"
+    }
+  end
+
+  it { expect(preset).not_to be nil }
+
+  describe "#base_color" do
+    it { expect(preset.base_color).to eq "#0f0f0f" }
+  end
+
+  describe "#color" do
+    context "when set" do
+      let(:options) do
+        {
+          base_color: "#0f0f0f",
+          color: "#1f1f1f"
+        }
+      end
+
+      it { expect(preset.color).to eq "#1f1f1f" }
+    end
+  end
+
+  describe "#mode?" do
+    context "when nil" do
+      let(:options) do
+        {
+          base_color: "#0f0f0f",
+          color: nil
+        }
+      end
+
+      it { expect(preset).to be_mode :base_color }
+    end
+
+    context "when defined" do
+      let(:options) do
+        {
+          base_color: "#0f0f0f",
+          color: "#1f1f1f"
+        }
+      end
+
+      it { expect(preset).to be_mode :color }
+    end
+  end
+end

data/spec/color_spec.rb

@@ -0,0 +1,17 @@
+# frozen_string_literal: true
+
+require "spec_helper"
+
+RSpec.describe GeoPattern::Color do
+  subject(:color) { described_class.new(color_string) }
+  let(:color_string) { "#ff00ff" }
+  let(:seed) { instance_double("GeoPattern::Seed") }
+
+  describe "#to_svg" do
+    it { expect(color.to_svg).to eq "rgb(255, 0, 255)" }
+  end
+
+  describe "#to_html" do
+    it { expect(color.to_html).to eq color_string }
+  end
+end

data/spec/geo_pattern_spec.rb

@@ -1,44 +1,116 @@
-# encoding: utf-8
-require 'spec_helper'
+# frozen_string_literal: true
+
+require "spec_helper"
 
 RSpec.describe GeoPattern do
-  let(:string) { 'Mastering Markdown' }
+  subject(:pattern) { GeoPattern.generate(input) }
+  let(:input) { "Mastering Markdown" }
+  let(:color) { "#ffcc00" }
+  let(:rgb_base_color) { PatternHelpers.html_to_rgb_for_string(seed, color) }
+  let(:seed) { instance_double("GeoPattern::Seed") }
 
-  context '.generate' do
-    it 'generates a pattern for a string' do
-      pattern = GeoPattern.generate(string)
-      expect(pattern).not_to be_nil
-    end
+  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)
+  end
 
-    it 'is always the same' do
-      pattern1 = GeoPattern.generate(string)
-      pattern2 = GeoPattern.generate(string)
+  it { expect(pattern).not_to be_nil }
 
-      expect(pattern1.svg_string).to eq pattern2.svg_string
+  describe ".generate" do
+    context "when invoked with the same input it returns the same output" do
+      let(:other_pattern) { GeoPattern.generate(input) }
+      it { expect(pattern.to_svg).to eq other_pattern.to_svg }
     end
 
-    it 'sets background color with adjusting hue and saturation based on string' do
-      html_base_color = '#fc0'
-      rgb_base_color  = html_to_rgb_for_string(string, html_base_color)
-      pattern         = GeoPattern.generate(string, base_color: html_base_color)
+    context "when an invalid option is given" do
+      subject(:pattern) { GeoPattern.generate(input, **args) }
+      let(:args) { {unknown: true} }
 
-      expect(pattern.svg_string).to include(rgb_base_color)
+      it { expect { pattern }.to raise_error ArgumentError }
     end
 
-    it 'sets background color' do
-      html_base_color = '#fc0'
-      rgb_base_color  = html_to_rgb(html_base_color)
-      pattern         = GeoPattern.generate(string, color: html_base_color)
+    context "set background color of generated pattern" do
+      let(:new_color) { "#ffcc00" }
+
+      context "when a base color is set" do
+        subject(:pattern) { GeoPattern.generate(input, base_color: color) }
+        let(:new_color) { "#04fbf6" }
 
-      expect(pattern.svg_string).to include(rgb_base_color)
+        it { expect(pattern.background.color.to_html).to eq(new_color) }
+      end
+
+      context "when a color is set" do
+        subject(:pattern) { GeoPattern.generate(input, color: color) }
+
+        it { expect(pattern.background.color.to_html).to eq(new_color) }
+      end
     end
 
-    it 'uses the specified generator' do
+    context "specify the pattern" do
+      subject(:pattern) { GeoPattern.generate(input, patterns: chosen_pattern) }
+
+      let(:chosen_pattern) { :sine_waves }
+
+      context "when the deprecated generator option is used" do
+        subject(:pattern) { GeoPattern.generate(input, generator: chosen_pattern) }
+        subject(:other_pattern) { GeoPattern.generate(input, patterns: chosen_pattern) }
+
+        it { expect { pattern.to_svg }.to output(/deprecated/).to_stderr }
+        it { silence(:stderr) { expect(pattern.to_svg).to eq other_pattern.to_svg } }
+      end
+
+      context "when multiple patterns are selected" do
+        let(:chosen_pattern) { %i[sine_waves xes] }
+
+        it { expect(pattern.structure.name).to eq(:sine_waves).or eq(:xes) }
+      end
+
+      context "when an old style pattern was chosen via class name" do
+        it_behaves_like "an old style pattern", ChevronPattern, :chevrons
+        it_behaves_like "an old style pattern", ConcentricCirclesPattern, :concentric_circles
+        it_behaves_like "an old style pattern", DiamondPattern, :diamonds
+        it_behaves_like "an old style pattern", HexagonPattern, :hexagons
+        it_behaves_like "an old style pattern", MosaicSquaresPattern, :mosaic_squares
+        it_behaves_like "an old style pattern", NestedSquaresPattern, :nested_squares
+        it_behaves_like "an old style pattern", OctagonPattern, :octagons
+        it_behaves_like "an old style pattern", OverlappingCirclesPattern, :overlapping_circles
+        it_behaves_like "an old style pattern", OverlappingRingsPattern, :overlapping_rings
+        it_behaves_like "an old style pattern", PlaidPattern, :plaid
+        it_behaves_like "an old style pattern", PlusSignPattern, :plus_signs
+        it_behaves_like "an old style pattern", SineWavePattern, :sine_waves
+        it_behaves_like "an old style pattern", SquarePattern, :squares
+        it_behaves_like "an old style pattern", TessellationPattern, :tessellation
+        it_behaves_like "an old style pattern", TrianglePattern, :triangles
+        it_behaves_like "an old style pattern", XesPattern, :xes
+      end
+
+      context "when an valid pattern was chosen" do
+        it_behaves_like "a chosen pattern", :chevrons
+        it_behaves_like "a chosen pattern", :concentric_circles
+        it_behaves_like "a chosen pattern", :diamonds
+        it_behaves_like "a chosen pattern", :hexagons
+        it_behaves_like "a chosen pattern", :mosaic_squares
+        it_behaves_like "a chosen pattern", :nested_squares
+        it_behaves_like "a chosen pattern", :octagons
+        it_behaves_like "a chosen pattern", :overlapping_circles
+        it_behaves_like "a chosen pattern", :overlapping_rings
+        it_behaves_like "a chosen pattern", :plaid
+        it_behaves_like "a chosen pattern", :plus_signs
+        it_behaves_like "a chosen pattern", :sine_waves
+        it_behaves_like "a chosen pattern", :squares
+        it_behaves_like "a chosen pattern", :tessellation
+        it_behaves_like "a chosen pattern", :triangles
+        it_behaves_like "a chosen pattern", :xes
+      end
 
-      pattern1 = GeoPattern.generate(string, generator: GeoPattern::SineWavePattern)
-      pattern2  = GeoPattern.generate(string)
+      context "when invalid patterns were chosen" do
+        InvalidPatternClass = Class.new # rubocop:disable Lint/ConstantDefinitionInBlock
 
-      expect(pattern1.svg_string).not_to eq pattern2.svg_string
+        it_behaves_like "an invalid pattern", InvalidPatternClass
+        it_behaves_like "an invalid pattern", "invalid_pattern"
+        it_behaves_like "an invalid pattern", :invalid_pattern
+        it_behaves_like "an invalid pattern", [:sine_waves, "invalid_pattern"]
+      end
     end
   end
 end

data/spec/helpers_spec.rb

@@ -0,0 +1,67 @@
+# frozen_string_literal: true
+
+require "spec_helper"
+
+RSpec.describe Helpers do
+  describe ".underscore" do
+    subject { described_class.underscore string }
+
+    context "when string is empty" do
+      let(:string) { "" }
+
+      it { is_expected.to eq "" }
+    end
+
+    context "when string is in snakecase" do
+      let(:string) { "HelloWorld" }
+
+      it { is_expected.to eq "hello_world" }
+    end
+
+    context "when string is in snakecase at some places" do
+      let(:string) { "helloWorld" }
+
+      it { is_expected.to eq "hello_world" }
+    end
+  end
+
+  describe ".demodulize" do
+    subject { described_class.demodulize string }
+
+    context "when constant" do
+      before :each do
+        stub_const("HelloWorld", Class.new)
+      end
+
+      let(:string) { HelloWorld }
+
+      it { is_expected.to eq "HelloWorld" }
+    end
+
+    context "when string" do
+      context "is empty" do
+        let(:string) { "" }
+
+        it { is_expected.to eq "" }
+      end
+
+      context "starts with ::" do
+        let(:string) { "::Class" }
+
+        it { is_expected.to eq "Class" }
+      end
+
+      context "has :: in betweend" do
+        let(:string) { "HelloWorld::Class" }
+
+        it { is_expected.to eq "Class" }
+      end
+
+      context "when no namespaces is given" do
+        let(:string) { "HelloWorld" }
+
+        it { is_expected.to eq "HelloWorld" }
+      end
+    end
+  end
+end

data/spec/pattern_preset_spec.rb

@@ -0,0 +1,43 @@
+# frozen_string_literal: true
+
+require "spec_helper"
+
+RSpec.describe PatternPreset do
+  subject(:preset) { PatternPreset.new(options) }
+  let(:options) do
+    {
+      fill_color_dark: "#222",
+      fill_color_light: "#ddd",
+      stroke_color: "#000",
+      stroke_opacity: 0.02,
+      opacity_min: 0.02,
+      opacity_max: 0.15
+    }
+  end
+
+  it { expect(preset).not_to be nil }
+
+  describe "#fill_color_dark" do
+    it { expect(preset.fill_color_dark).to eq "#222" }
+  end
+
+  describe "#fill_color_light" do
+    it { expect(preset.fill_color_light).to eq "#ddd" }
+  end
+
+  describe "#stroke_color" do
+    it { expect(preset.stroke_color).to eq "#000" }
+  end
+
+  describe "#stroke_opacity" do
+    it { expect(preset.stroke_opacity).to eq 0.02 }
+  end
+
+  describe "#opacity_min" do
+    it { expect(preset.opacity_min).to eq 0.02 }
+  end
+
+  describe "#opacity_max" do
+    it { expect(preset.opacity_max).to eq 0.15 }
+  end
+end

data/spec/pattern_sieve_spec.rb

@@ -0,0 +1,68 @@
+# frozen_string_literal: true
+
+require "spec_helper"
+
+RSpec.describe PatternSieve do
+  subject(:sieve) { PatternSieve.new(requested_patterns, seed, store) }
+
+  before :each do
+    stub_const("Pattern1", Class.new)
+    stub_const("Pattern2", Class.new)
+  end
+
+  let(:store) { instance_double("GeoPattern::PatternStore") }
+  let(:available_patterns) { [Pattern1, Pattern2] }
+  let(:requested_patterns) { %i[pattern1 pattern2] }
+  let(:seed) { instance_double("GeoPattern::Seed") }
+
+  before :each do
+    allow(seed).to receive(:to_i).with(20, 1).and_return(1)
+    allow(store).to receive(:[])
+  end
+
+  # Minimum valid object test
+  it { expect(sieve).not_to be_nil }
+
+  describe "#fetch" do
+    context "when requested_patterns is empty" do
+      let(:requested_patterns) { nil }
+
+      before :each do
+        expect(store).to receive(:all).and_return(available_patterns)
+        expect(store).not_to receive(:[])
+      end
+
+      it { expect(sieve.fetch).to eq Pattern2 }
+    end
+
+    context "when a valid pattern is requested" do
+      let(:requested_patterns) { [:pattern1] }
+
+      before :each do
+        expect(store).to receive(:[]).with(:pattern1).and_return(Pattern1)
+      end
+
+      it { expect(sieve.fetch).to eq Pattern1 }
+    end
+
+    context "when an invalid pattern is requested" do
+      let(:requested_patterns) { [:patternX] }
+
+      before :each do
+        allow(store).to receive(:[]).with(:patternX).and_return(nil)
+      end
+
+      it { expect(sieve.fetch).to be nil }
+    end
+
+    context "when a requested pattern is nil" do
+      let(:requested_patterns) { [:pattern1, nil, :pattern2] }
+
+      before :each do
+        expect(store).not_to receive(:[]).with(nil)
+      end
+
+      it { sieve.fetch }
+    end
+  end
+end

data/spec/pattern_spec.rb

@@ -0,0 +1,74 @@
+# frozen_string_literal: true
+
+require "spec_helper"
+
+RSpec.describe Pattern do
+  subject(:pattern) { Pattern.new(svg_image) }
+
+  let(:svg_image) { instance_double("GeoPattern::SvgImage") }
+  let(:svg_image_content) { fixtures_path("generated_patterns/sine_waves.svg").read.chomp }
+  let(:background) { instance_double("GeoPattern::Background") }
+  let(:background_image) { instance_double("GeoPattern::SvgImage") }
+  let(:background_body) { %(<rect x="0" y="0" width="100%" height="100%" fill="rgb(121, 131, 76)"  />) }
+  let(:structure) { instance_double("GeoPattern::Structure") }
+  let(:structure_image) { instance_double("GeoPattern::SvgImage") }
+  let(:structure_body) { %(<path d="M0 53 C 28.0 0, 52.0 0, 80 53 S 132.0 106, 160 53 S 212.0 0, 240.0, 53" fill="none" stroke="#222" style="opacity:0.046;stroke-width:6px;" transform="translate(-40, -79.5)"  />) }
+
+  it { expect(pattern).not_to be_nil }
+
+  before :each do
+    allow(svg_image).to receive(:to_s).and_return svg_image_content
+    allow(svg_image).to receive(:height=).and_return 100
+    allow(svg_image).to receive(:width=).and_return 100
+
+    allow(background).to receive(:image).and_return background_image
+
+    allow(structure).to receive(:image).and_return structure_image
+  end
+
+  describe "#to_s" do
+    before :each do
+      allow(svg_image).to receive(:to_s).and_return(svg_image_content)
+    end
+
+    it { expect(pattern.to_s).to eq svg_image_content }
+  end
+
+  describe "#to_base64" do
+    before :each do
+      allow(svg_image).to receive(:to_s).and_return(svg_image_content)
+    end
+
+    it { expect(pattern.to_base64).to include "PHN2ZyB4bWxuc" }
+  end
+
+  describe "#to_data_uri" do
+    before :each do
+      allow(svg_image).to receive(:to_s).and_return(svg_image_content)
+    end
+
+    it { expect(pattern.to_data_uri).to include "PHN2ZyB4bWxuc" }
+  end
+
+  describe "#generate_me" do
+    context "when a background is added" do
+      let(:generator) { instance_double("GeoPattern::BackgroundGenerator") }
+
+      before :each do
+        expect(generator).to receive(:generate).with(pattern)
+      end
+
+      it do
+        pattern.generate_me(generator)
+      end
+    end
+  end
+
+  describe "#include?" do
+    it do
+      expect(svg_image).to receive(:include?)
+
+      pattern.include? ""
+    end
+  end
+end

data/spec/pattern_store_spec.rb

@@ -0,0 +1,49 @@
+# frozen_string_literal: true
+
+require "spec_helper"
+
+RSpec.describe PatternStore do
+  subject(:pattern_store) { PatternStore.new }
+
+  it { expect(pattern_store).not_to be_nil }
+
+  describe "#[]" do
+    context "when a known pattern is requested" do
+      context "as string" do
+        let(:pattern_name) { "xes" }
+        it_behaves_like "a known pattern name"
+      end
+
+      context "as klass" do
+        let(:pattern_name) { XesPattern }
+        it_behaves_like "a known pattern name"
+      end
+
+      context "as symbol" do
+        let(:pattern_name) { :xes }
+        it_behaves_like "a known pattern name"
+      end
+    end
+
+    context "when an unknown pattern is requested" do
+      context "as string" do
+        let(:pattern_name) { "unknown" }
+        it_behaves_like "an unknown pattern name"
+      end
+
+      context "as klass" do
+        let(:pattern_name) do
+          stub_const("UnknownPattern", Class.new)
+          UnknownPattern
+        end
+
+        it_behaves_like "an unknown pattern name"
+      end
+
+      context "as symbol" do
+        let(:pattern_name) { :unknown }
+        it_behaves_like "an unknown pattern name"
+      end
+    end
+  end
+end

data/spec/pattern_validator_spec.rb

@@ -0,0 +1,30 @@
+# frozen_string_literal: true
+
+require "spec_helper"
+
+RSpec.describe PatternValidator do
+  subject(:validator) { PatternValidator.new(store) }
+  let(:store) { instance_double("GeoPattern::PatternStore") }
+  let(:patterns) { [] }
+
+  # Minimum valid object test
+  it { expect(validator).not_to be_nil }
+
+  describe "#validate" do
+    context "when valid pattern is validated" do
+      before :each do
+        allow(store).to receive(:known?).with("pattern1").and_return(true)
+      end
+
+      it { expect { validator.validate(%w[pattern1]) }.not_to raise_error }
+    end
+
+    context "when invalid pattern is validated" do
+      before :each do
+        allow(store).to receive(:known?).with("pattern1").and_return(false)
+      end
+
+      it { expect { validator.validate(%w[pattern1]) }.to raise_error InvalidPatternError }
+    end
+  end
+end

data/spec/seed_spec.rb

@@ -0,0 +1,16 @@
+# frozen_string_literal: true
+
+require "spec_helper"
+
+RSpec.describe Seed do
+  subject(:seed) { Seed.new(input) }
+  let(:input) { "string" }
+
+  it { expect(seed).not_to be_nil }
+
+  describe "#[]" do
+    context "when use an integer" do
+      it { expect(seed[1]).to be_kind_of String }
+    end
+  end
+end

data/spec/spec_helper.rb

@@ -1,23 +1,19 @@
-# encoding: utf-8
-$LOAD_PATH << File.expand_path('../../lib', __FILE__)
+# frozen_string_literal: true
 
-require 'simplecov'
-SimpleCov.command_name 'rspec'
+$LOAD_PATH << File.expand_path("../lib", __dir__)
+
+require "simplecov"
+SimpleCov.command_name "rspec"
 SimpleCov.start
 
 # Pull in all of the gems including those in the `test` group
-require 'bundler'
+require "bundler"
 Bundler.require :default, :test, :development
 
-require 'geo_pattern'
-
-# Make some helpers available
-include GeoPattern::Helpers
+require "geo_pattern"
 
 # Loading support files
-#::File.expand_path('../support/*.rb', __FILE__)
-require_files_matching_pattern ::File.expand_path('../support/*.rb', __FILE__)
-require_files_matching_pattern ::File.expand_path('../shared_examples/*.rb', __FILE__)
+GeoPattern::Helpers.require_files_matching_pattern ::File.expand_path("support/**/*.rb", __dir__)
 
 # No need to add the namespace to every class tested
-include GeoPattern
+include GeoPattern # rubocop:disable Style/MixinUsage

data/spec/structure_generators/chevrons_generator_spec.rb

@@ -0,0 +1,7 @@
+# frozen_string_literal: true
+
+require "spec_helper"
+
+RSpec.describe StructureGenerators::ChevronsGenerator do
+  it_behaves_like "a structure generator", :chevrons
+end

data/spec/structure_generators/concentric_circles_generator_spec.rb

@@ -0,0 +1,7 @@
+# frozen_string_literal: true
+
+require "spec_helper"
+
+RSpec.describe StructureGenerators::ConcentricCirclesGenerator do
+  it_behaves_like "a structure generator", :concentric_circles
+end

data/spec/structure_generators/diamonds_generator_spec.rb

@@ -0,0 +1,7 @@
+# frozen_string_literal: true
+
+require "spec_helper"
+
+RSpec.describe StructureGenerators::DiamondsGenerator do
+  it_behaves_like "a structure generator", :diamonds
+end

data/spec/structure_generators/hexagons_generator_spec.rb

@@ -0,0 +1,7 @@
+# frozen_string_literal: true
+
+require "spec_helper"
+
+RSpec.describe StructureGenerators::HexagonsGenerator do
+  it_behaves_like "a structure generator", :hexagons
+end

data/spec/structure_generators/mosaic_squares_generator_spec.rb

@@ -0,0 +1,7 @@
+# frozen_string_literal: true
+
+require "spec_helper"
+
+RSpec.describe StructureGenerators::MosaicSquaresGenerator do
+  it_behaves_like "a structure generator", :mosaic_squares
+end

data/spec/structure_generators/nested_squares_generator_spec.rb

@@ -0,0 +1,7 @@
+# frozen_string_literal: true
+
+require "spec_helper"
+
+RSpec.describe StructureGenerators::NestedSquaresGenerator do
+  it_behaves_like "a structure generator", :nested_squares
+end

data/spec/structure_generators/octagons_generator_spec.rb

@@ -0,0 +1,7 @@
+# frozen_string_literal: true
+
+require "spec_helper"
+
+RSpec.describe StructureGenerators::OctagonsGenerator do
+  it_behaves_like "a structure generator", :octagons
+end

data/spec/structure_generators/overlapping_circles_generator_spec.rb

@@ -0,0 +1,7 @@
+# frozen_string_literal: true
+
+require "spec_helper"
+
+RSpec.describe StructureGenerators::OverlappingCirclesGenerator do
+  it_behaves_like "a structure generator", :overlapping_circles
+end