geo_pattern 1.3.2 → 1.5.0

data/lib/geo_pattern/pattern_preset.rb

@@ -0,0 +1,25 @@
+# frozen_string_literal: true
+
+module GeoPattern
+  class PatternPreset
+    private
+
+    attr_accessor :options
+
+    public
+
+    def initialize(options)
+      @options = options
+    end
+
+    %i[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,38 @@
+# frozen_string_literal: true
+
+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,65 @@
+# frozen_string_literal: true
+
+module GeoPattern
+  # rubocop:disable Naming/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 Naming/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)
+      warn "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,29 @@
+# frozen_string_literal: true
+
+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"
+
+      raise 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,112 @@
+# frozen_string_literal: true
+
+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
+
+      raise 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
+
+    # 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_description
+
+      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

data/lib/geo_pattern/roles/comparable_metadata.rb

@@ -0,0 +1,37 @@
+# frozen_string_literal: true
+
+module GeoPattern
+  # Roles
+  module Roles
+    # A comparable metadata
+    module ComparableMetadata
+      def self.included(base)
+        base.extend ClassMethods
+      end
+
+      def generator?(value)
+        return false unless value.is_a?(Class) || value.nil?
+        return true if value.nil? && @generator
+
+        return true if value == generator
+
+        false
+      end
+
+      # Class Methods
+      module ClassMethods
+        # Define comparators
+        def def_comparators(*methods)
+          methods.flatten.each do |m|
+            define_method "#{m}?".to_sym do |value|
+              return true if value.nil? && public_send(m)
+              return true if value == public_send(m)
+
+              false
+            end
+          end
+        end
+      end
+    end
+  end
+end

data/lib/geo_pattern/roles/named_generator.rb

@@ -0,0 +1,15 @@
+# frozen_string_literal: true
+
+module GeoPattern
+  module Roles
+    module NamedGenerator
+      def name?(other_name)
+        name == other_name.to_sym
+      end
+
+      def name
+        Helpers.underscore(Helpers.demodulize(self.class).gsub(/Generator/, "")).to_sym
+      end
+    end
+  end
+end

data/lib/geo_pattern/seed.rb

@@ -0,0 +1,23 @@
+# frozen_string_literal: true
+
+module GeoPattern
+  class Seed
+    private
+
+    attr_reader :seed
+
+    public
+
+    def initialize(string)
+      @seed = Digest::SHA1.hexdigest string.to_s
+    end
+
+    def [](*args)
+      seed[*args]
+    end
+
+    def to_i(index, length)
+      seed[index, length || 1].to_i(16)
+    end
+  end
+end

data/lib/geo_pattern/structure.rb

@@ -0,0 +1,27 @@
+# frozen_string_literal: true
+
+module GeoPattern
+  class Structure
+    include Roles::ComparableMetadata
+
+    extend Forwardable
+
+    attr_reader :image, :preset, :name, :generator
+
+    def_delegators :@preset, :fill_color_dark, :fill_color_light, :stroke_color, :stroke_opacity, :opacity_min, :opacity_max
+
+    def initialize(options)
+      @image = options[:image]
+      @preset = options[:preset]
+      @name = options[:name]
+      @generator = options[:generator]
+
+      raise ArgumentError, "Argument name is missing" if @name.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 :name, :fill_color_dark, :fill_color_light, :stroke_color, :stroke_opacity, :opacity_min, :opacity_max
+  end
+end

data/lib/geo_pattern/structure_generators/base_generator.rb

@@ -0,0 +1,88 @@
+# frozen_string_literal: true
+
+module GeoPattern
+  module StructureGenerators
+    class BaseGenerator
+      include Roles::NamedGenerator
+
+      private
+
+      attr_reader :svg, :seed, :fill_color_dark, :fill_color_light, :stroke_color, :stroke_opacity, :opacity_min, :opacity_max, :preset
+      attr_accessor :height, :width
+
+      public
+
+      def initialize(seed, preset, svg = SvgImage.new)
+        @svg = svg
+        @seed = seed
+        @preset = preset
+
+        @fill_color_dark = @preset.fill_color_dark
+        @fill_color_light = @preset.fill_color_light
+        @stroke_color = @preset.stroke_color
+        @stroke_opacity = @preset.stroke_opacity
+        @opacity_min = @preset.opacity_min
+        @opacity_max = @preset.opacity_max
+
+        @height = 100
+        @width = 100
+
+        after_initialize
+      end
+
+      def generate(pattern)
+        pattern.structure = Structure.new(image: svg_image, preset: preset, generator: self.class, name: name)
+
+        pattern.height = height
+        pattern.width = width
+
+        self
+      end
+
+      private
+
+      # Set Svg Image
+      def svg_image
+        image = generate_structure
+        image.height = height
+        image.width = width
+
+        image
+      end
+
+      # Hook for generators
+      def after_initialize
+      end
+
+      # Generate the structure
+      def generate_structure
+        raise NotImplementedError
+      end
+
+      def hex_val(index, len)
+        seed.to_i(index, len)
+      end
+
+      def fill_color(val)
+        val.even? ? fill_color_light : fill_color_dark
+      end
+
+      def opacity(val)
+        map(val, 0, 15, opacity_min, opacity_max)
+      end
+
+      def map(value, v_min, v_max, d_min, d_max)
+        PatternHelpers.map(value, v_min, v_max, d_min, d_max)
+      end
+
+      protected
+
+      def build_plus_shape(square_size)
+        [
+          "rect(#{square_size},0,#{square_size},#{square_size * 3})",
+          "rect(0, #{square_size},#{square_size * 3},#{square_size})"
+        ]
+      end
+    end
+  end
+end

data/lib/geo_pattern/structure_generators/chevrons_generator.rb

@@ -0,0 +1,57 @@
+# frozen_string_literal: true
+
+module GeoPattern
+  module StructureGenerators
+    class ChevronsGenerator < BaseGenerator
+      private
+
+      attr_reader :chevron_height, :chevron_width, :chevron
+
+      def after_initialize
+        @chevron_width = map(hex_val(0, 1), 0, 15, 30, 80)
+        @chevron_height = map(hex_val(0, 1), 0, 15, 30, 80)
+        @chevron = build_chevron_shape(chevron_width, chevron_height)
+
+        self.height = chevron_height * 6 * 0.66
+        self.width = chevron_width * 6
+      end
+
+      def generate_structure
+        i = 0
+        6.times do |y|
+          6.times do |x|
+            val = hex_val(i, 1)
+            opacity = opacity(val)
+            fill = fill_color(val)
+
+            styles = {
+              "stroke" => stroke_color,
+              "stroke-opacity" => stroke_opacity,
+              "fill" => fill,
+              "fill-opacity" => opacity,
+              "stroke-width" => 1
+            }
+
+            svg.group(chevron, styles.merge("transform" => "translate(#{x * chevron_width},#{y * chevron_height * 0.66 - chevron_height / 2})"))
+
+            # Add an extra row at the end that matches the first row, for tiling.
+            if y == 0
+              svg.group(chevron, styles.merge("transform" => "translate(#{x * chevron_width},#{6 * chevron_height * 0.66 - chevron_height / 2})"))
+            end
+            i += 1
+          end
+        end
+
+        svg
+      end
+
+      def build_chevron_shape(width, height)
+        e = height * 0.66
+        [
+          %{polyline("0,0,#{width / 2},#{height - e},#{width / 2},#{height},0,#{e},0,0")},
+          %{polyline("#{width / 2},#{height - e},#{width},0,#{width},#{e},#{width / 2},#{height},#{width / 2},#{height - e}")}
+        ]
+      end
+    end
+  end
+end

data/lib/geo_pattern/structure_generators/concentric_circles_generator.rb

@@ -0,0 +1,58 @@
+# frozen_string_literal: true
+
+module GeoPattern
+  module StructureGenerators
+    class ConcentricCirclesGenerator < BaseGenerator
+      private
+
+      attr_reader :scale, :ring_size, :stroke_width
+
+      def after_initialize
+        @scale = hex_val(0, 1)
+        @ring_size = map(scale, 0, 15, 10, 60)
+        @stroke_width = ring_size / 5
+
+        self.width = self.height = (ring_size + stroke_width) * 6
+      end
+
+      def generate_structure
+        i = 0
+        6.times do |y|
+          6.times do |x|
+            val = hex_val(i, 1)
+            opacity = opacity(val)
+            fill = fill_color(val)
+
+            svg.circle(
+              x * ring_size + x * stroke_width + (ring_size + stroke_width) / 2,
+              y * ring_size + y * stroke_width + (ring_size + stroke_width) / 2,
+              ring_size / 2,
+              "fill" => "none",
+              "stroke" => fill,
+              "style" => {
+                "opacity" => opacity,
+                "stroke-width" => "#{stroke_width}px"
+              }
+            )
+
+            val = hex_val(39 - i, 1)
+            opacity = opacity(val)
+            fill = fill_color(val)
+
+            svg.circle(
+              x * ring_size + x * stroke_width + (ring_size + stroke_width) / 2,
+              y * ring_size + y * stroke_width + (ring_size + stroke_width) / 2,
+              ring_size / 4,
+              "fill" => fill,
+              "fill-opacity" => opacity
+            )
+
+            i += 1
+          end
+        end
+
+        svg
+      end
+    end
+  end
+end

data/lib/geo_pattern/structure_generators/diamonds_generator.rb

@@ -0,0 +1,72 @@
+# frozen_string_literal: true
+
+module GeoPattern
+  module StructureGenerators
+    class DiamondsGenerator < BaseGenerator
+      private
+
+      attr_reader :diamond_height, :diamond_width, :diamond
+
+      def after_initialize
+        @diamond_width = map(hex_val(0, 1), 0, 15, 10, 50)
+        @diamond_height = map(hex_val(1, 1), 0, 15, 10, 50)
+        @diamond = build_diamond_shape(diamond_width, diamond_height)
+
+        self.height = diamond_height * 3
+        self.width = diamond_width * 6
+      end
+
+      def generate_structure
+        i = 0
+        6.times do |y|
+          6.times do |x|
+            val = hex_val(i, 1)
+            opacity = opacity(val)
+            fill = fill_color(val)
+
+            styles = {
+              "fill" => fill,
+              "fill-opacity" => opacity,
+              "stroke" => stroke_color,
+              "stroke-opacity" => stroke_opacity
+            }
+
+            dx = (y % 2 == 0) ? 0 : diamond_width / 2
+
+            svg.polyline(diamond, styles.merge(
+              "transform" => "translate(#{x * diamond_width - diamond_width / 2 + dx}, #{diamond_height / 2 * y - diamond_height / 2})"
+            ))
+
+            # Add an extra one at top-right, for tiling.
+            if x == 0
+              svg.polyline(diamond, styles.merge(
+                "transform" => "translate(#{6 * diamond_width - diamond_width / 2 + dx}, #{diamond_height / 2 * y - diamond_height / 2})"
+              ))
+            end
+
+            # Add an extra row at the end that matches the first row, for tiling.
+            if y == 0
+              svg.polyline(diamond, styles.merge(
+                "transform" => "translate(#{x * diamond_width - diamond_width / 2 + dx}, #{diamond_height / 2 * 6 - diamond_height / 2})"
+              ))
+            end
+
+            # Add an extra one at bottom-right, for tiling.
+            if x == 0 && y == 0
+              svg.polyline(diamond, styles.merge(
+                "transform" => "translate(#{6 * diamond_width - diamond_width / 2 + dx}, #{diamond_height / 2 * 6 - diamond_height / 2})"
+              ))
+            end
+            i += 1
+          end
+        end
+
+        svg
+      end
+
+      def build_diamond_shape(width, height)
+        "#{width / 2}, 0, #{width}, #{height / 2}, #{width / 2}, #{height}, 0, #{height / 2}"
+      end
+    end
+  end
+end