geo_pattern 1.3.2 → 1.4.0

data/spec/color_spec.rb

@@ -0,0 +1,15 @@
+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

@@ -2,43 +2,114 @@
 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) { [: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
 
-      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,65 @@
+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,41 @@
+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,66 @@
+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) { [: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,72 @@
+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,47 @@
+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