geo_pattern 1.3.2 → 1.4.0

data/lib/geo_pattern/pattern.rb

@@ -0,0 +1,84 @@
+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
+      $stderr.puts '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
+      $stderr.puts '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
+      $stderr.puts '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,52 @@
 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)
+      $stderr.puts '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
-      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})"})
+      @background_generator = BackgroundGenerators::SolidGenerator.new(seed, color_preset)
+      @structure_generator  = begin
+                                generator_klass = pattern_sieve.fetch
+                                generator_klass.new(seed, pattern_preset)
+                              end
     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,46 @@
 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
+    def map(value, v_min, v_max, d_min, d_max) # v for value, d for desired
       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
+
+      if (sat_offset % 2 == 0)
+        base_color.saturation = base_color.saturation + sat_offset
+      else
+        base_color.saturation = 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(%d, %d, %d)', r, g, b)
+    end
+
+    module_function :hex_val, :map, :html_to_rgb, :html_to_rgb_for_string, :generate_rgb_string
   end
 end

data/lib/geo_pattern/pattern_preset.rb

@@ -0,0 +1,23 @@
+module GeoPattern
+  class PatternPreset
+    private
+
+    attr_accessor :options
+
+    public
+
+    def initialize(options)
+      @options = options
+    end
+
+    [:fill_color_dark, :fill_color_light, :stroke_color, :stroke_opacity, :opacity_min, :opacity_max].each do |m|
+      define_method m do
+        options[m]
+      end
+    end
+
+    def update(opts)
+      options.merge! opts
+    end
+  end
+end

data/lib/geo_pattern/pattern_sieve.rb

@@ -0,0 +1,36 @@
+module GeoPattern
+  class PatternSieve
+    private
+
+    attr_reader :pattern_store, :requested_patterns, :seed, :available_patterns, :index
+
+    public
+
+    def initialize(requested_patterns, seed, pattern_store = PatternStore.new)
+      @requested_patterns = requested_patterns
+      @seed               = seed
+      @pattern_store      = pattern_store
+
+      @available_patterns = determine_available_patterns
+      @index              = determine_index
+    end
+
+    def fetch
+      available_patterns[index]
+    end
+
+    private
+
+    def determine_index
+      [seed.to_i(20, 1), available_patterns.length - 1].min
+    end
+
+    def determine_available_patterns
+      patterns = Array(requested_patterns).compact
+
+      return pattern_store.all if patterns.empty?
+
+      patterns.map { |p| pattern_store[p] }.compact
+    end
+  end
+end

data/lib/geo_pattern/pattern_store.rb

@@ -0,0 +1,63 @@
+module GeoPattern
+  # rubocop:disable Style/ConstantName
+  ChevronPattern            = :chevrons
+  ConcentricCirclesPattern  = :concentric_circles
+  DiamondPattern            = :diamonds
+  HexagonPattern            = :hexagons
+  MosaicSquaresPattern      = :mosaic_squares
+  NestedSquaresPattern      = :nested_squares
+  OctagonPattern            = :octagons
+  OverlappingCirclesPattern = :overlapping_circles
+  OverlappingRingsPattern   = :overlapping_rings
+  PlaidPattern              = :plaid
+  PlusSignPattern           = :plus_signs
+  SineWavePattern           = :sine_waves
+  SquarePattern             = :squares
+  TessellationPattern       = :tessellation
+  TrianglePattern           = :triangles
+  XesPattern                = :xes
+  # rubocop:enable Style/ConstantName
+
+  class PatternStore
+    private
+
+    attr_reader :store
+
+    public
+
+    def initialize
+      @store = {
+        chevrons: StructureGenerators::ChevronsGenerator,
+        concentric_circles: StructureGenerators::ConcentricCirclesGenerator,
+        diamonds: StructureGenerators::DiamondsGenerator,
+        hexagons: StructureGenerators::HexagonsGenerator,
+        mosaic_squares: StructureGenerators::MosaicSquaresGenerator,
+        nested_squares: StructureGenerators::NestedSquaresGenerator,
+        octagons: StructureGenerators::OctagonsGenerator,
+        overlapping_circles: StructureGenerators::OverlappingCirclesGenerator,
+        overlapping_rings: StructureGenerators::OverlappingRingsGenerator,
+        plaid: StructureGenerators::PlaidGenerator,
+        plus_signs: StructureGenerators::PlusSignsGenerator,
+        sine_waves: StructureGenerators::SineWavesGenerator,
+        squares: StructureGenerators::SquaresGenerator,
+        tessellation: StructureGenerators::TessellationGenerator,
+        triangles: StructureGenerators::TrianglesGenerator,
+        xes: StructureGenerators::XesGenerator
+      }
+    end
+
+    def [](pattern)
+      $stderr.puts 'String pattern references are deprecated as of 1.3.0' if pattern.is_a?(String)
+
+      store[pattern.to_s.to_sym]
+    end
+
+    def all
+      store.values
+    end
+
+    def known?(pattern)
+      store.key?(pattern.to_s.to_sym)
+    end
+  end
+end

data/lib/geo_pattern/pattern_validator.rb

@@ -0,0 +1,27 @@
+module GeoPattern
+  class PatternValidator
+    private
+
+    attr_reader :pattern_store
+
+    public
+
+    def initialize(pattern_store = PatternStore.new)
+      @pattern_store = pattern_store
+    end
+
+    def validate(requested_patterns)
+      message = "Error: At least one of the requested patterns \"#{requested_patterns.join(', ')}\" is invalid"
+
+      fail InvalidPatternError, message unless valid?(requested_patterns)
+
+      self
+    end
+
+    private
+
+    def valid?(requested_patterns)
+      requested_patterns.all? { |p| pattern_store.known? p }
+    end
+  end
+end

data/lib/geo_pattern/rake_task.rb

@@ -0,0 +1,109 @@
+require 'rake'
+require 'rake/tasklib'
+require 'logger'
+
+module GeoPattern
+  # Rake Task
+  #
+  # This task can be used to generate pattern files
+  class RakeTask < ::Rake::TaskLib
+    include ::Rake::DSL if defined?(::Rake::DSL)
+
+    # @!attribute [r] name
+    #   Name of task.
+    attr_reader :name
+
+    # @!attribute [r] description
+    #   A description for the task
+    attr_reader :description
+
+    # @!attribute [r] verbose (true)
+    #   Use verbose output. If this is set to true, the task will print the
+    #   executed spec command to stdout.
+    attr_reader :verbose
+
+    private
+
+    attr_reader :task_arguments, :task_block, :logger, :working_directory
+
+    # Create task instance
+    #
+    # @param [String] description
+    #   A description for the task
+    #
+    # @param [String] name
+    #   The name for the task (including namespace), e.g. namespace1:task1
+    #
+    # @param [Array] arguments
+    #   Arguments for the task. Look
+    #   [here](http://viget.com/extend/protip-passing-parameters-to-your-rake-tasks)
+    #   for a better description on how to use arguments in rake tasks
+    #
+    # @yield
+    #   A block which is called before the "run_task"-method is called. The
+    #   parameters it taskes depends on the number of parameters the block
+    #   can take. If the block is defined which two parameters, it takes two
+    #   parameters from the paramter 'arguments'.
+    def initialize(opts = {}, &task_block)
+      @options = {
+        description: nil,
+        name: GeoPattern::Helpers.underscore(self.class.to_s.split(/::/).slice(-2..-1).join(':').gsub(/Task$/, '')),
+        arguments: [],
+        logger: ::Logger.new($stderr),
+        working_directory: Dir.getwd
+      }.merge opts
+
+      before_initialize
+
+      fail ArgumentError, :description if @options[:description].nil?
+
+      @description       = @options[:description]
+      @task_arguments    = Array(@options[:arguments])
+      @task_block        = task_block
+      @logger            = @options[:logger]
+      @working_directory = @options[:working_directory]
+      @name              = @options[:name]
+
+      after_initialize
+
+      define_task
+    end
+
+    private
+
+    # Run code after initialize
+    def after_initialize; end
+
+    # Run code before initialize
+    def before_initialize; end
+
+    # Define task
+    def define_task
+      desc description unless ::Rake.application.last_comment
+
+      task name, *task_arguments do |_, task_args|
+        RakeFileUtils.__send__(:verbose, verbose) do
+          instance_exec(*[self, task_args].slice(0, task_block.arity), &task_block) if task_block.respond_to? :call
+          run_task verbose
+        end
+      end
+    end
+
+    # Run code if task is executed
+    def run_task(_verbose); end
+
+    public
+
+    # Binding to instance
+    def instance_binding
+      binding
+    end
+
+    # Include module in instance
+    def include(modules)
+      modules = Array(modules)
+
+      modules.each { |m| self.class.include m }
+    end
+  end
+end