geo_pattern 1.4.0 → 1.5.0

data/spec/color_generators/simple_generator_spec.rb

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

data/spec/color_preset_spec.rb

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

data/spec/color_spec.rb

@@ -1,15 +1,17 @@
-require 'spec_helper'
+# 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') }
+  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)' }
+  describe "#to_svg" do
+    it { expect(color.to_svg).to eq "rgb(255, 0, 255)" }
   end
 
-  describe '#to_html' do
+  describe "#to_html" do
     it { expect(color.to_html).to eq color_string }
   end
 end

data/spec/geo_pattern_spec.rb

@@ -1,12 +1,13 @@
-# encoding: utf-8
-require 'spec_helper'
+# frozen_string_literal: true
+
+require "spec_helper"
 
 RSpec.describe GeoPattern do
   subject(:pattern) { GeoPattern.generate(input) }
-  let(:input) { 'Mastering Markdown' }
-  let(:color) { '#ffcc00' }
+  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') }
+  let(:seed) { instance_double("GeoPattern::Seed") }
 
   before :each do
     allow(seed).to receive(:to_i).with(14, 3).and_return(2616)
@@ -15,42 +16,42 @@ RSpec.describe GeoPattern do
 
   it { expect(pattern).not_to be_nil }
 
-  describe '.generate' do
-    context 'when invoked with the same input it returns the same output' do
+  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
 
-    context 'when an invalid option is given' do
+    context "when an invalid option is given" do
       subject(:pattern) { GeoPattern.generate(input, **args) }
-      let(:args) { { unknown: true } }
+      let(:args) { {unknown: true} }
 
       it { expect { pattern }.to raise_error ArgumentError }
     end
 
-    context 'set background color of generated pattern' do
-      let(:new_color) { '#ffcc00' }
+    context "set background color of generated pattern" do
+      let(:new_color) { "#ffcc00" }
 
-      context 'when a base color is set' do
+      context "when a base color is set" do
         subject(:pattern) { GeoPattern.generate(input, base_color: color) }
-        let(:new_color) { '#04fbf6' }
+        let(:new_color) { "#04fbf6" }
 
         it { expect(pattern.background.color.to_html).to eq(new_color) }
       end
 
-      context 'when a color is set' do
+      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
 
-    context 'specify the pattern' 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
+      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) }
 
@@ -58,57 +59,57 @@ RSpec.describe GeoPattern do
         it { silence(:stderr) { expect(pattern.to_svg).to eq other_pattern.to_svg } }
       end
 
-      context 'when multiple patterns are selected' do
-        let(:chosen_pattern) { [:sine_waves, :xes] }
+      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
+      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
+      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
 
-      context 'when invalid patterns were chosen' do
-        InvalidPatternClass = Class.new
+      context "when invalid patterns were chosen" do
+        InvalidPatternClass = Class.new # rubocop:disable Lint/ConstantDefinitionInBlock
 
-        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']
+        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

data/spec/helpers_spec.rb

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

data/spec/pattern_preset_spec.rb

@@ -1,12 +1,14 @@
-require 'spec_helper'
+# 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',
+      fill_color_dark: "#222",
+      fill_color_light: "#ddd",
+      stroke_color: "#000",
       stroke_opacity: 0.02,
       opacity_min: 0.02,
       opacity_max: 0.15
@@ -15,27 +17,27 @@ RSpec.describe PatternPreset do
 
   it { expect(preset).not_to be nil }
 
-  describe '#fill_color_dark' do
-    it { expect(preset.fill_color_dark).to eq '#222' }
+  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' }
+  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' }
+  describe "#stroke_color" do
+    it { expect(preset.stroke_color).to eq "#000" }
   end
 
-  describe '#stroke_opacity' do
+  describe "#stroke_opacity" do
     it { expect(preset.stroke_opacity).to eq 0.02 }
   end
 
-  describe '#opacity_min' do
+  describe "#opacity_min" do
     it { expect(preset.opacity_min).to eq 0.02 }
   end
 
-  describe '#opacity_max' do
+  describe "#opacity_max" do
     it { expect(preset.opacity_max).to eq 0.15 }
   end
 end

data/spec/pattern_sieve_spec.rb

@@ -1,17 +1,19 @@
-require 'spec_helper'
+# 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)
+    stub_const("Pattern1", Class.new)
+    stub_const("Pattern2", Class.new)
   end
 
-  let(:store) { instance_double('GeoPattern::PatternStore') }
+  let(:store) { instance_double("GeoPattern::PatternStore") }
   let(:available_patterns) { [Pattern1, Pattern2] }
-  let(:requested_patterns) { [:pattern1, :pattern2] }
-  let(:seed) { instance_double('GeoPattern::Seed') }
+  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)
@@ -21,8 +23,8 @@ RSpec.describe PatternSieve do
   # Minimum valid object test
   it { expect(sieve).not_to be_nil }
 
-  describe '#fetch' do
-    context 'when requested_patterns is empty' do
+  describe "#fetch" do
+    context "when requested_patterns is empty" do
       let(:requested_patterns) { nil }
 
       before :each do
@@ -33,7 +35,7 @@ RSpec.describe PatternSieve do
       it { expect(sieve.fetch).to eq Pattern2 }
     end
 
-    context 'when a valid pattern is requested' do
+    context "when a valid pattern is requested" do
       let(:requested_patterns) { [:pattern1] }
 
       before :each do
@@ -43,7 +45,7 @@ RSpec.describe PatternSieve do
       it { expect(sieve.fetch).to eq Pattern1 }
     end
 
-    context 'when an invalid pattern is requested' do
+    context "when an invalid pattern is requested" do
       let(:requested_patterns) { [:patternX] }
 
       before :each do
@@ -53,7 +55,7 @@ RSpec.describe PatternSieve do
       it { expect(sieve.fetch).to be nil }
     end
 
-    context 'when a requested pattern is nil' do
+    context "when a requested pattern is nil" do
       let(:requested_patterns) { [:pattern1, nil, :pattern2] }
 
       before :each do

data/spec/pattern_spec.rb

@@ -1,16 +1,18 @@
-require 'spec_helper'
+# 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(: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)\"  />) }
+  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 }
 
@@ -24,7 +26,7 @@ RSpec.describe Pattern do
     allow(structure).to receive(:image).and_return structure_image
   end
 
-  describe '#to_s' do
+  describe "#to_s" do
     before :each do
       allow(svg_image).to receive(:to_s).and_return(svg_image_content)
     end
@@ -32,25 +34,25 @@ RSpec.describe Pattern do
     it { expect(pattern.to_s).to eq svg_image_content }
   end
 
-  describe '#to_base64' do
+  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' }
+    it { expect(pattern.to_base64).to include "PHN2ZyB4bWxuc" }
   end
 
-  describe '#to_data_uri' do
+  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' }
+    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') }
+  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)
@@ -62,11 +64,11 @@ RSpec.describe Pattern do
     end
   end
 
-  describe '#include?' do
+  describe "#include?" do
     it do
       expect(svg_image).to receive(:include?)
 
-      pattern.include? ''
+      pattern.include? ""
     end
   end
 end

data/spec/pattern_store_spec.rb

@@ -1,46 +1,48 @@
-require 'spec_helper'
+# 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'
+  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
+      context "as klass" do
         let(:pattern_name) { XesPattern }
-        it_behaves_like 'a known pattern name'
+        it_behaves_like "a known pattern name"
       end
 
-      context 'as symbol' do
+      context "as symbol" do
         let(:pattern_name) { :xes }
-        it_behaves_like 'a known pattern name'
+        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'
+    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
+      context "as klass" do
         let(:pattern_name) do
-          stub_const('UnknownPattern', Class.new)
+          stub_const("UnknownPattern", Class.new)
           UnknownPattern
         end
 
-        it_behaves_like 'an unknown pattern name'
+        it_behaves_like "an unknown pattern name"
       end
 
-      context 'as symbol' do
+      context "as symbol" do
         let(:pattern_name) { :unknown }
-        it_behaves_like 'an unknown pattern name'
+        it_behaves_like "an unknown pattern name"
       end
     end
   end