geo_pattern 1.4.0 → 1.6.0

data/geo_pattern.gemspec

@@ -1,29 +0,0 @@
-# coding: utf-8
-lib = File.expand_path('../lib', __FILE__)
-$LOAD_PATH.unshift(lib) unless $LOAD_PATH.include?(lib)
-require 'geo_pattern/version'
-
-Gem::Specification.new do |spec|
-  spec.name          = 'geo_pattern'
-  spec.version       = GeoPattern::VERSION
-  spec.authors       = ['Jason Long']
-  spec.email         = ['jlong@github.com']
-  spec.summary       = 'Generate SVG beautiful patterns'
-  spec.description   = 'Generate SVG beautiful patterns'
-  spec.homepage      = 'https://github.com/jasonlong/geo_pattern'
-  spec.license       = 'MIT'
-
-  spec.files         = `git ls-files -z`.split("\x0")
-  spec.executables   = spec.files.grep(%r{^bin/}) { |f| File.basename(f) }
-  spec.test_files    = spec.files.grep(%r{^(test|spec|features)/})
-  spec.require_paths = ['lib']
-
-  spec.required_ruby_version = '~>2'
-
-  spec.add_dependency 'color', '~> 1.5'
-  spec.add_development_dependency 'bundler', '~> 1.5'
-
-  spec.post_install_message = <<-EOS
-Class style pattern names are deprecated as of 1.3.1
-EOS
-end

data/script/bootstrap

@@ -1,30 +0,0 @@
-#!/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

@@ -1,8 +0,0 @@
-#!/usr/bin/env ruby
-
-$LOAD_PATH << File.expand_path('../../lib', __FILE__)
-
-require 'pry'
-require 'geo_pattern'
-
-Pry.start

data/script/test

@@ -1,21 +0,0 @@
-#!/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

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

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

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

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

data/spec/color_preset_spec.rb

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

@@ -1,15 +0,0 @@
-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,115 +0,0 @@
-# encoding: utf-8
-require 'spec_helper'
-
-RSpec.describe GeoPattern do
-  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') }
-
-  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 { expect(pattern).not_to be_nil }
-
-  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
-      subject(:pattern) { GeoPattern.generate(input, **args) }
-      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 'when a base color is set' do
-        subject(:pattern) { GeoPattern.generate(input, base_color: color) }
-        let(:new_color) { '#04fbf6' }
-
-        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
-
-    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
-
-      context 'when invalid patterns were chosen' do
-        InvalidPatternClass = Class.new
-
-        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

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

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

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

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