geo_pattern 1.3.2 → 1.5.0

data/geo_pattern.gemspec

@@ -1,23 +1,25 @@
-# coding: utf-8
-lib = File.expand_path('../lib', __FILE__)
+# frozen_string_literal: true
+
+lib = File.expand_path("lib", __dir__)
 $LOAD_PATH.unshift(lib) unless $LOAD_PATH.include?(lib)
-require 'geo_pattern/version'
+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       = %q{Generate SVG beautiful patterns}
-  spec.description   = %q{Generate SVG beautiful patterns}
-  spec.homepage      = 'https://github.com/jasonlong/geo_pattern'
-  spec.license       = 'MIT'
+  spec.name = "geo_pattern"
+  spec.version = GeoPattern::VERSION
+  spec.authors = ["Jason Long"]
+  spec.email = ["jason@jasonlong.me"]
+  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.require_paths = ["lib"]
 
-  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.6"
 
-  spec.add_dependency 'color', '~> 1.5'
-  spec.add_development_dependency 'bundler', '~> 1.5'
+  spec.add_dependency "color", "~> 1.5"
+  spec.add_development_dependency "bundler", "~> 2.2"
 end

data/lib/geo_pattern/background.rb

@@ -0,0 +1,27 @@
+# frozen_string_literal: true
+
+module GeoPattern
+  class Background
+    include Roles::ComparableMetadata
+
+    extend Forwardable
+
+    attr_reader :image, :preset, :color, :generator
+
+    def_delegators :@preset, :base_color
+
+    def initialize(options)
+      @image = options[:image]
+      @preset = options[:preset]
+      @color = options[:color]
+      @generator = options[:generator]
+
+      raise ArgumentError, "Argument color is missing" if @color.nil?
+      raise ArgumentError, "Argument image is missing" if @image.nil?
+      raise ArgumentError, "Argument preset is missing" if @preset.nil?
+      raise ArgumentError, "Argument generator is missing" if @generator.nil?
+    end
+
+    def_comparators :base_color, :color
+  end
+end

data/lib/geo_pattern/background_generators/solid_generator.rb

@@ -0,0 +1,54 @@
+# frozen_string_literal: true
+
+module GeoPattern
+  # Generating backgrounds
+  module BackgroundGenerators
+    # Generating a solid background
+    class SolidGenerator
+      include Roles::NamedGenerator
+
+      private
+
+      attr_reader :color, :seed, :preset
+
+      public
+
+      # New generator
+      #
+      # @param [Seed] seed
+      #   The seed used during generation the background
+      #
+      # @param [ColorPreset] preset
+      #   A preset of values which are used during generating the background
+      def initialize(seed, preset)
+        @color = color_for(seed, preset)
+        @preset = preset
+      end
+
+      # Generate the background for pattern
+      #
+      # @param [#background=] pattern
+      #   The pattern for which the background should be generated
+      def generate(pattern)
+        pattern.background = Background.new(image: generate_background, preset: preset, color: color, generator: self.class)
+
+        self
+      end
+
+      private
+
+      def generate_background
+        svg = SvgImage.new
+        svg.rect(0, 0, "100%", "100%", "fill" => color.to_svg)
+
+        svg
+      end
+
+      def color_for(seed, preset)
+        return ColorGenerators::BaseColorGenerator.new(preset.base_color, seed).generate if preset.mode? :base_color
+
+        ColorGenerators::SimpleGenerator.new(preset.color).generate
+      end
+    end
+  end
+end

data/lib/geo_pattern/color.rb

@@ -0,0 +1,27 @@
+# frozen_string_literal: true
+
+module GeoPattern
+  class Color
+    private
+
+    attr_accessor :color
+
+    public
+
+    def initialize(html_color)
+      @color = ::Color::RGB.from_html html_color
+    end
+
+    def to_svg
+      r = (color.r * 255).round
+      g = (color.g * 255).round
+      b = (color.b * 255).round
+
+      format("rgb(%<r>d, %<g>d, %<b>d)", r: r, g: g, b: b)
+    end
+
+    def to_html
+      color.html
+    end
+  end
+end

data/lib/geo_pattern/color_generators/base_color_generator.rb

@@ -0,0 +1,57 @@
+# frozen_string_literal: true
+
+module GeoPattern
+  # Color generators
+  module ColorGenerators
+    # Generate color based on Base Color and seed
+    class BaseColorGenerator
+      private
+
+      attr_reader :creator, :seed, :color
+
+      public
+
+      # New
+      #
+      # @param [String] color
+      #   HTML color string, #0a0a0a
+      def initialize(color, seed, creator = Color)
+        @color = color
+        @seed = seed
+        @creator = creator
+      end
+
+      # Generator color
+      def generate
+        creator.new(transform(color, seed))
+      end
+
+      private
+
+      def transform(color, seed)
+        hue_offset = map(seed.to_i(14, 3), 0, 4095, 0, 359)
+        sat_offset = seed.to_i(17, 1)
+        new_color = ::Color::RGB.from_html(color).to_hsl
+        new_color.hue = new_color.hue - hue_offset
+
+        new_color.saturation = if sat_offset % 2 == 0
+          new_color.saturation + sat_offset
+        else
+          new_color.saturation - sat_offset
+        end
+        new_color.html
+      end
+
+      # Ruby implementation of Processing's map function
+      # http://processing.org/reference/map_.html
+      # v for value, d for desired
+      def map(value, v_min, v_max, d_min, d_max)
+        v_value = value.to_f # so it returns float
+
+        v_range = v_max - v_min
+        d_range = d_max - d_min
+        (v_value - v_min) * d_range / v_range + d_min
+      end
+    end
+  end
+end

data/lib/geo_pattern/color_generators/simple_generator.rb

@@ -0,0 +1,29 @@
+# frozen_string_literal: true
+
+module GeoPattern
+  # Color generators
+  module ColorGenerators
+    # Simple one
+    class SimpleGenerator
+      private
+
+      attr_reader :color, :creator
+
+      public
+
+      # New
+      #
+      # @param [String] color
+      #   HTML color string, #0a0a0a
+      def initialize(color, creator = Color)
+        @color = color
+        @creator = creator
+      end
+
+      # Generator color
+      def generate
+        creator.new(color)
+      end
+    end
+  end
+end

data/lib/geo_pattern/color_preset.rb

@@ -0,0 +1,32 @@
+# frozen_string_literal: true
+
+# rubocop:disable Lint/DuplicateMethods
+
+module GeoPattern
+  class ColorPreset
+    attr_accessor :color, :base_color, :mode
+
+    def initialize(color: nil, base_color: nil)
+      @color = color
+      @base_color = base_color
+    end
+
+    # Return mode
+    #
+    # @return [Symbol]
+    #   The color mode
+    def mode
+      if color.nil? || color.empty?
+        :base_color
+      else
+        :color
+      end
+    end
+
+    def mode?(m)
+      mode == m
+    end
+  end
+end
+
+# rubocop:enable Lint/DuplicateMethods

data/lib/geo_pattern/errors.rb

@@ -0,0 +1,9 @@
+# frozen_string_literal: true
+
+module GeoPattern
+  # user errors
+  class UserError < StandardError; end
+
+  # raised if an invalid pattern is requested
+  class InvalidPatternError < UserError; end
+end

data/lib/geo_pattern/geo_pattern_task.rb

@@ -0,0 +1,61 @@
+# frozen_string_literal: true
+
+require "geo_pattern"
+require "geo_pattern/rake_task"
+
+module GeoPattern
+  # GeoPatternTask
+  #
+  # @see Rakefile
+  class GeoPatternTask < RakeTask
+    # @!attribute [r] data
+    #   The data which should be used to generate patterns
+    attr_reader :data
+
+    # @!attribute [r] allowed_patterns
+    #   The the patterns which are allowed to be used
+    attr_reader :allowed_patterns
+
+    # Create a new geo pattern task
+    #
+    # @param [Hash] data
+    #   The data which should be used to generate patterns
+    #
+    # @param [Array] allowed_patterns
+    #   The allowed_patterns
+    #
+    # @see RakeTask
+    #   For other arguments accepted
+    def initialize(opts = {})
+      super
+
+      raise ArgumentError, :data if @options[:data].nil?
+
+      @data = @options[:data]
+      @allowed_patterns = @options[:allowed_patterns]
+    end
+
+    # @private
+    def run_task(_verbose)
+      data.each do |path, string|
+        opts = {}
+        path = File.expand_path(path)
+
+        if string.is_a?(Hash)
+          input = string[:input]
+          opts[:patterns] = string[:patterns] if string.key? :patterns
+          opts[:color] = string[:color] if string.key? :color
+          opts[:base_color] = string[:base_color] if string.key? :base_color
+        else
+          raise "Invalid data structure for Rake Task"
+        end
+
+        pattern = GeoPattern.generate(input, opts)
+
+        logger.info "Creating pattern at \"#{path}\"."
+        FileUtils.mkdir_p File.dirname(path)
+        File.write(path, pattern.to_svg)
+      end
+    end
+  end
+end

data/lib/geo_pattern/helpers.rb

@@ -1,7 +1,56 @@
+# frozen_string_literal: true
+
 module GeoPattern
   module Helpers
     def require_files_matching_pattern(pattern)
-      Dir.glob(pattern).each { |f| require_relative f }
+      Dir.glob(pattern).sort.each { |f| require_relative f }
     end
+
+    # Makes an underscored, lowercase form from the expression in the string.
+    #
+    # @see ActiveSupport
+    #   It's MIT-Licensed
+    #
+    def underscore(camel_cased_word)
+      return camel_cased_word unless /[A-Z-]/.match?(camel_cased_word)
+
+      word = camel_cased_word.to_s.dup
+
+      word.gsub!(/([A-Z\d]+)([A-Z][a-z])/, '\1_\2')
+      word.gsub!(/([a-z\d])([A-Z])/, '\1_\2')
+
+      word.downcase!
+
+      word
+    end
+
+    # Removes the module part from the expression in the string.
+    #
+    # @see ActiveSupport
+    #   It's MIT-Licensed
+    #
+    # @exmple Use demodulize
+    #
+    #   'ActiveRecord::CoreExtensions::String::Inflections'.demodulize # => "Inflections"
+    #   'Inflections'.demodulize                                       # => "Inflections"
+    #   '::Inflections'.demodulize                                     # => "Inflections"
+    #   ''.demodulize                                                  # => ""
+    #
+    # See also +deconstantize+.
+    def demodulize(path)
+      path = path.to_s
+
+      if (i = path.rindex("::"))
+        path[(i + 2)..]
+      else
+        path
+      end
+    end
+
+    def build_arguments(*methods)
+      methods.flatten.map { |m| [m, "#{m}?"] }.flatten
+    end
+
+    module_function :underscore, :demodulize, :build_arguments, :require_files_matching_pattern
   end
 end

data/lib/geo_pattern/pattern.rb

@@ -0,0 +1,86 @@
+# frozen_string_literal: true
+
+module GeoPattern
+  class Pattern
+    private
+
+    attr_reader :svg_image
+
+    public
+
+    attr_accessor :background, :structure, :height, :width
+
+    def initialize(svg_image = SvgImage.new)
+      @svg_image = svg_image
+    end
+
+    # Check if string is included in pattern
+    #
+    # @param [String] string
+    #   The checked string
+    def include?(string)
+      image.include?(string)
+    end
+
+    # Generate things for the pattern
+    #
+    # @param [#generate) generator
+    #   The generator which should do things with this pattern - e.g. adding
+    #   background or a structure
+    def generate_me(generator)
+      generator.generate self
+    end
+
+    # Convert pattern to svg
+    def to_svg
+      image.to_s
+    end
+    alias_method :to_s, :to_svg
+
+    # Convert to base64
+    def to_base64
+      Base64.strict_encode64(to_svg)
+    end
+
+    # Convert to data uri
+    def to_data_uri
+      "url(data:image/svg+xml;base64,#{to_base64});"
+    end
+
+    # @see #to_data_uri
+    # @deprecated
+    def uri_image
+      warn 'Using "#uri_image" is deprecated as of 1.3.1. Please use "#to_data_uri" instead.'
+
+      to_data_uri
+    end
+
+    # @see #to_svg
+    # @deprecated
+    def svg_string
+      warn 'Using "#svg_string" is deprecated as of 1.3.1. Please use "#to_svg" instead.'
+
+      to_svg
+    end
+
+    # @see #to_base64
+    # @deprecated
+    def base64_string
+      warn 'Using "#base64_string" is deprecated as of 1.3.1. Please use "#to_base64" instead.'
+
+      to_base64
+    end
+
+    private
+
+    def image
+      svg_image.height = height
+      svg_image.width = width
+
+      svg_image << background.image if background
+      svg_image << structure.image if structure
+
+      svg_image
+    end
+  end
+end

data/lib/geo_pattern/pattern_generator.rb

@@ -1,101 +1,54 @@
+# frozen_string_literal: true
+
 module GeoPattern
   class PatternGenerator
-    DEFAULTS = {
-      :base_color => '#933c3c'
-    }
+    private
 
-    PATTERNS = {
-      'chevrons' => ChevronPattern,
-      'concentric_circles' => ConcentricCirclesPattern,
-      'diamonds' => DiamondPattern,
-      'hexagons' => HexagonPattern,
-      'mosaic_squares' => MosaicSquaresPattern,
-      'nested_squares' => NestedSquaresPattern,
-      'octagons' => OctagonPattern,
-      'overlapping_circles' => OverlappingCirclesPattern,
-      'overlapping_rings' => OverlappingRingsPattern,
-      'plaid' => PlaidPattern,
-      'plus_signs' => PlusSignPattern,
-      'sine_waves' => SineWavePattern,
-      'squares' => SquarePattern,
-      'tessellation' => TessellationPattern,
-      'triangles' => TrianglePattern,
-      'xes' => XesPattern,
-    }.freeze
+    attr_reader :background_generator, :structure_generator
 
-    FILL_COLOR_DARK  = "#222"
-    FILL_COLOR_LIGHT = "#ddd"
-    STROKE_COLOR     = "#000"
-    STROKE_OPACITY   = 0.02
-    OPACITY_MIN      = 0.02
-    OPACITY_MAX      = 0.15
+    public
 
-    attr_reader :opts, :hash, :svg
+    def initialize(string, generator: nil, patterns: nil, base_color: nil, color: nil)
+      warn "Using generator key is deprecated as of 1.3.1" if generator
 
-    def initialize(string, opts={})
-      @opts = DEFAULTS.merge(opts)
-      @hash = Digest::SHA1.hexdigest string
-      @svg  = SVG.new
+      requested_patterns = (Array(generator) | Array(patterns)).flatten.compact
 
-      generate_background
-      generate_pattern
-    end
+      pattern_preset = PatternPreset.new(
+        fill_color_dark: "#222",
+        fill_color_light: "#ddd",
+        stroke_color: "#000",
+        stroke_opacity: 0.02,
+        opacity_min: 0.02,
+        opacity_max: 0.15
+      )
 
-    def svg_string
-      svg.to_s
-    end
-    alias_method :to_s, :svg_string
+      color_preset = ColorPreset.new(
+        base_color: "#933c3c"
+      )
+      color_preset.color = color if color
+      color_preset.base_color = base_color if base_color
 
-    def base64_string
-      Base64.strict_encode64(svg_string)
-    end
+      seed = Seed.new(string)
 
-    def uri_image
-      "url(data:image/svg+xml;base64,#{base64_string});"
-    end
+      pattern_validator = PatternValidator.new
+      pattern_validator.validate(requested_patterns)
 
-    def generate_background
-      if opts[:color]
-        rgb = Color::RGB.from_html(opts[:color])
-      else
-        hue_offset     = PatternHelpers.map(PatternHelpers.hex_val(hash, 14, 3), 0, 4095, 0, 359)
-        sat_offset     = PatternHelpers.hex_val(hash, 17, 1)
-        base_color     = Color::RGB.from_html(opts[:base_color]).to_hsl
-        base_color.hue = base_color.hue - hue_offset;
+      pattern_sieve = PatternSieve.new(requested_patterns, seed)
 
-        if (sat_offset % 2 == 0)
-          base_color.saturation = base_color.saturation + sat_offset
-        else
-          base_color.saturation = base_color.saturation - sat_offset
-        end
-        rgb = base_color.to_rgb
+      @background_generator = BackgroundGenerators::SolidGenerator.new(seed, color_preset)
+      @structure_generator = begin
+        generator_klass = pattern_sieve.fetch
+        generator_klass.new(seed, pattern_preset)
       end
-      r = (rgb.r * 255).round
-      g = (rgb.g * 255).round
-      b = (rgb.b * 255).round
-      svg.rect(0, 0, "100%", "100%", {"fill" => "rgb(#{r}, #{g}, #{b})"})
     end
 
-    def generate_pattern
-      unless opts[:generator].nil?
-        if opts[:generator].is_a? String
-          generator = PATTERNS[opts[:generator]]
-          puts SVG.as_comment("String pattern references are deprecated as of 1.3.0")
-        elsif opts[:generator] < BasePattern
-          if PATTERNS.values.include? opts[:generator]
-            generator = opts[:generator]
-          else
-            abort("Error: the requested generator is invalid")
-            generator = nil
-          end
-        end
-      end
+    def generate
+      pattern = Pattern.new
 
-      generator ||= PATTERNS.values[[PatternHelpers.hex_val(hash, 20, 1), PATTERNS.length - 1].min]
+      pattern.generate_me background_generator
+      pattern.generate_me structure_generator
 
-      # Instantiate the generator with the needed references
-      # and render the pattern to the svg object
-      generator.new(svg, hash).render_to_svg
+      pattern
     end
   end
 end

data/lib/geo_pattern/pattern_helpers.rb

@@ -1,17 +1,49 @@
+# frozen_string_literal: true
+
 module GeoPattern
   module PatternHelpers
-    def self.hex_val(hash, index, length)
+    def hex_val(hash, index, length)
       hash[index, length || 1].to_i(16)
     end
 
     # Ruby implementation of Processing's map function
     # http://processing.org/reference/map_.html
-    def self.map(value, v_min, v_max, d_min, d_max) # v for value, d for desired
+    # v for value, d for desired
+    def map(value, v_min, v_max, d_min, d_max)
       v_value = value.to_f # so it returns float
 
       v_range = v_max - v_min
       d_range = d_max - d_min
       (v_value - v_min) * d_range / v_range + d_min
     end
+
+    def html_to_rgb(color)
+      generate_rgb_string(::Color::RGB.from_html(color))
+    end
+
+    def html_to_rgb_for_string(seed, base_color)
+      hue_offset = map(seed.to_i(14, 3), 0, 4095, 0, 359)
+      sat_offset = seed.to_i(17, 1)
+      base_color = ::Color::RGB.from_html(base_color).to_hsl
+      base_color.hue = base_color.hue - hue_offset
+
+      base_color.saturation = if sat_offset % 2 == 0
+        base_color.saturation + sat_offset
+      else
+        base_color.saturation - sat_offset
+      end
+
+      generate_rgb_string(base_color.to_rgb)
+    end
+
+    def generate_rgb_string(rgb)
+      r = (rgb.r * 255).round
+      g = (rgb.g * 255).round
+      b = (rgb.b * 255).round
+
+      format("rgb(%<r>d, %<g>d, %<b>d)", r: r, g: g, b: b)
+    end
+
+    module_function :hex_val, :map, :html_to_rgb, :html_to_rgb_for_string, :generate_rgb_string
   end
 end