usps_flags 0.5.0 → 0.5.1

data/lib/usps_flags/generate/generator_methods.rb

@@ -0,0 +1,139 @@
+# frozen_string_literal: false
+
+# Private methods for USPSFlags::Generator.
+#
+# These methods should never need to be called directly.
+# @private
+class USPSFlags
+  class Generate
+    module GeneratorMethods
+      # This module defined no public methods
+      def _; end
+
+    private
+
+      def static_generation_header
+        puts "\nSVGs generate a single file.",
+             'PNGs generate full-res, 1500w, 1000w, 500w, and thumbnail files.',
+             'Corresponding rank insignia (including smaller sizes) are also generated, as appropriate.'
+        USPSFlags::Helpers.log "\nGeneration location: #{USPSFlags.configuration.flags_dir}\n"
+        USPSFlags::Helpers.log "\n#{Time.now.strftime('%Y%m%d.%H%M%S%z')} – Generating static files...\n\n"
+        length = USPSFlags::Helpers.max_flag_name_length + 31
+        USPSFlags::Helpers.log "Flag | SVG | PNG        | Run time\n".rjust(length),
+                               "\n".rjust(USPSFlags::Helpers.max_flag_name_length + 32, '-')
+      end
+
+      def generate_zip(type)
+        no_dir = [USPSFlags::Errors::ZipGenerationError, 'Flags directory not found.']
+        raise(*no_dir) unless ::Dir.exist?("#{USPSFlags.configuration.flags_dir}/ZIP")
+
+        zip = "#{USPSFlags.configuration.flags_dir}/ZIP/USPS_Flags.#{type}.zip"
+        ::File.delete(zip) if ::File.exist?(zip)
+        write_zip_file(zip, type)
+
+        puts "Generated #{type.upcase} Zip"
+      end
+
+      def write_zip_file(zip, type)
+        ::Zip::File.open(zip, ::Zip::File::CREATE) do |z|
+          ::Dir.glob("#{USPSFlags.configuration.flags_dir}/#{type.upcase}/**/*").each do |f|
+            add_to_zip(z, f)
+          end
+        end
+      end
+
+      def add_to_zip(z, f)
+        filename = f.split('/').last
+        filename = "insignia/#{filename}" if f.split('/').last(2).first == 'insignia'
+        z.add(filename, f)
+      end
+
+      def generate_static_images_for(flag, svg: true, png: true)
+        run_time = track_time(simple: true) do
+          @flag = flag.upcase
+          USPSFlags::Helpers.log "#{@flag.rjust(USPSFlags::Helpers.max_flag_name_length)} |"
+          set_file_paths
+          generate_requested_images(svg, png)
+        end
+
+        USPSFlags::Helpers.log " | #{run_time.round(4).to_s[(0..5)].ljust(6, '0')} s\n"
+      end
+
+      def generate_requested_images(svg, png)
+        svg ? generate_static_svg : USPSFlags::Helpers.log('-')
+        png ? generate_static_png : USPSFlags::Helpers.log('- ')
+      end
+
+      def generate_static_svg
+        USPSFlags::Helpers.log ' '
+
+        generate_regular_svg
+        generate_insignia_svg
+      end
+
+      def generate_regular_svg
+        return if file_found?(@svg_file)
+
+        svg @flag, outfile: @svg_file, scale: 1
+        USPSFlags::Helpers.log 'S'
+      end
+
+      def generate_insignia_svg
+        return if no_insignia?
+
+        svg @flag, field: false, outfile: @svg_ins_file, scale: 1
+        USPSFlags::Helpers.log 'I'
+      end
+
+      def generate_static_png
+        USPSFlags::Helpers.log '  | '
+        generate_fullsize_png
+        generate_fullsize_png_insignia
+        generate_reduced_size_pngs
+      end
+
+      def generate_fullsize_png
+        return if file_found?(@png_file)
+
+        png(File.read(@svg_file), outfile: @png_file)
+        USPSFlags::Helpers.log 'F'
+      end
+
+      def generate_fullsize_png_insignia
+        return if no_insignia?
+        return if file_found?(@png_ins_file)
+
+        png(File.read(@svg_ins_file), outfile: @png_ins_file, trim: true)
+        USPSFlags::Helpers.log 'I'
+      end
+
+      def generate_reduced_size_pngs
+        USPSFlags::Helpers.png_sizes.keys.each do |size|
+          size, size_key = USPSFlags::Helpers.size_and_key(size: size, flag: @flag)
+          @sized_png_file = "#{USPSFlags.configuration.flags_dir}/PNG/#{@flag}.#{size_key}.png"
+          @sized_png_ins_file = @sized_png_file.gsub('/PNG/', '/PNG/insignia/')
+
+          generate_smaller_png(size, size_key)
+          generate_smaller_png_insignia(size, size_key)
+        end
+      end
+
+      def generate_smaller_png(size, size_key)
+        return if file_found?(@sized_png_file)
+        return if too_big?(@png_file, size)
+
+        USPSFlags::Helpers.resize_png(@png_file, file: @flag, size: size, size_key: size_key)
+        USPSFlags::Helpers.log USPSFlags::Helpers.png_sizes[size_key]
+      end
+
+      def generate_smaller_png_insignia(size, size_key)
+        return if no_insignia?
+        return if file_found?(@sized_png_ins_file)
+        return if too_big?(@png_ins_file, size)
+
+        USPSFlags::Helpers.resize_png(@png_ins_file, file: "insignia/#{@flag}", size: size, size_key: size_key)
+        USPSFlags::Helpers.log 'i'
+      end
+    end
+  end
+end

data/lib/usps_flags/generate/helper_methods.rb

@@ -0,0 +1,88 @@
+# frozen_string_literal: false
+
+# Private methods for USPSFlags::Generator.
+#
+# These methods should never need to be called directly.
+# @private
+class USPSFlags
+  class Generate
+    module HelperMethods
+      # This module defined no public methods
+      def _; end
+
+    private
+
+      def remove_static_files
+        %w[SVG PNG ZIP].each do |dir|
+          dir_path = "#{USPSFlags.configuration.flags_dir}/#{dir}"
+          ::FileUtils.rm_rf(::Dir.glob("#{dir_path}/*")) if ::Dir.exist?(dir_path)
+        end
+
+        ['SVG/insignia', 'PNG/insignia'].each do |dir|
+          ::FileUtils.mkdir_p("#{USPSFlags.configuration.flags_dir}/#{dir}")
+        end
+
+        USPSFlags::Helpers.log "\n - Cleared previous files.\n"
+      end
+
+      def set_file_paths
+        @svg_file = "#{USPSFlags.configuration.flags_dir}/SVG/#{@flag}.svg"
+        @png_file = @svg_file.gsub('/SVG/', '/PNG/').gsub('.svg', '.png')
+        @svg_ins_file = @svg_file.gsub('/SVG/', '/SVG/insignia/')
+        @png_ins_file = @svg_file.gsub('/SVG/', '/PNG/insignia/').gsub('.svg', '.png')
+        [@svg_file, @png_file, @svg_ins_file, @png_ins_file]
+      end
+
+      def set_temp_svg(svg)
+        @temp_svg_path = "#{USPSFlags.configuration.flags_dir}/temp.svg"
+        temp_svg = ::File.new(@temp_svg_path, 'w+')
+        temp_svg.write(svg)
+        temp_svg.flush
+        @temp_svg_path
+      end
+
+      def delete_temp_svg?
+        !@temp_svg_path.to_s.empty? && ::File.exist?(@temp_svg_path)
+      end
+
+      def any_all_arg?(svg, png, zips, reset)
+        svg || png || zips || reset
+      end
+
+      def all_arg_error
+        raise(
+          USPSFlags::Errors::StaticFilesGenerationError,
+          'At least one argument switch must be true out of [svg, png, zips, reset].'
+        )
+      end
+
+      def track_time(simple: false)
+        overall_start_time = Time.now
+        yield
+        end_time = Time.now - overall_start_time
+        simple ? end_time : USPSFlags::Helpers.log("\nTotal run time: #{end_time} s\n\n")
+      end
+
+      def no_insignia?
+        return false if USPSFlags::Helpers.valid_flags(:insignia).include?(@flag)
+
+        USPSFlags::Helpers.log '-'
+        true
+      end
+
+      def file_found?(file)
+        return false unless ::File.exist?(file)
+
+        USPSFlags::Helpers.log '.'
+        true
+      end
+
+      def too_big?(file, size)
+        return false unless size > MiniMagick::Image.open(file)[:width]
+
+        USPSFlags::Helpers.log '+'
+        true
+      end
+    end
+  end
+end

data/lib/usps_flags/helpers.rb

@@ -1,199 +1,197 @@
 # frozen_string_literal: false
 
 # Container class for helper methods.
-class USPSFlags::Helpers
-  require 'usps_flags/helpers/valid_flags'
-
-  class << self
-    # Valid options for flag generation.
-    #
-    # @param [Symbol] type Specify subset of flags.
-    # @option type [Symbol] :all All flags
-    # @option type [Symbol] :officer Officer flags
-    # @option type [Symbol] :insignia Insignia-eligible officer flags (no past officers)
-    # @option type [Symbol] :squadron Squadron-level officer flags
-    # @option type [Symbol] :district District-level officer flags
-    # @option type [Symbol] :national National-level officer flags
-    # @option type [Symbol] :special Special flags
-    # @option type [Symbol] :us US flag
-    # @return [Array] Valid options for flag generation (based on the provided type).
-    def valid_flags(type = :all)
-      USPSFlags::Helpers::ValidFlags.load_valid_flags
-      USPSFlags::Helpers::ValidFlags.load_special_flags
-      USPSFlags::Helpers::ValidFlags.load_valid_flag_groups
-      USPSFlags::Helpers::ValidFlags.valid_flags_for(type)
-    end
-
-    # Resizes and saves a PNG image.
-    #
-    # One of the params [file, outfile] is required, and outfile takes precedence.
-    #
-    # @param [String] png_file Path to the PNG file to resize.
-    # @param [String] file Abbreviated key for the output file (e.g. "LTC", "insignia/FLT").
-    # @param [String] outfile Path to the output file.
-    # @param [String] size Actual size to output as.
-    # @param [String] size_key Size suffix to attach to the file name.
-    def resize_png(png_file, file: nil, outfile: nil, size:, size_key: nil)
-      raise USPSFlags::Errors::PNGConversionError if outfile.nil? && file.nil?
-      raise USPSFlags::Errors::PNGConversionError if outfile.nil? && size_key.nil?
-
-      output_file_name = outfile || "#{USPSFlags.configuration.flags_dir}/PNG/#{file}.#{size_key}.png"
-      resize_convert(size, png_file, output_file_name)
-    end
+class USPSFlags
+  class Helpers
+    require 'usps_flags/helpers/valid_flags'
+
+    class << self
+      # Valid options for flag generation.
+      #
+      # @param [Symbol] type Specify subset of flags.
+      # @option type [Symbol] :all All flags
+      # @option type [Symbol] :officer Officer flags
+      # @option type [Symbol] :insignia Insignia-eligible officer flags (no past officers)
+      # @option type [Symbol] :squadron Squadron-level officer flags
+      # @option type [Symbol] :district District-level officer flags
+      # @option type [Symbol] :national National-level officer flags
+      # @option type [Symbol] :special Special flags
+      # @option type [Symbol] :us US flag
+      # @return [Array] Valid options for flag generation (based on the provided type).
+      def valid_flags(type = :all)
+        USPSFlags::Helpers::ValidFlags.load_valid_flags
+        USPSFlags::Helpers::ValidFlags.load_special_flags
+        USPSFlags::Helpers::ValidFlags.load_valid_flag_groups
+        USPSFlags::Helpers::ValidFlags.valid_flags_for(type)
+      end
 
-    # Gets the maximum length among valid flags.
-    #
-    # This is used USPSFlags::Generate, and should never need to be called directly.
-    # @private
-    def max_flag_name_length
-      valid_flags(:all).map(&:length).max
-    end
+      # Resizes and saves a PNG image.
+      #
+      # One of the params [file, outfile] is required, and outfile takes precedence.
+      #
+      # @param [String] png_file Path to the PNG file to resize.
+      # @param [String] file Abbreviated key for the output file (e.g. "LTC", "insignia/FLT").
+      # @param [String] outfile Path to the output file.
+      # @param [String] size Actual size to output as.
+      # @param [String] size_key Size suffix to attach to the file name.
+      def resize_png(png_file, file: nil, outfile: nil, size:, size_key: nil)
+        raise USPSFlags::Errors::PNGConversionError if outfile.nil? && file.nil?
+        raise USPSFlags::Errors::PNGConversionError if outfile.nil? && size_key.nil?
+
+        output_file_name = outfile || "#{USPSFlags.configuration.flags_dir}/PNG/#{file}.#{size_key}.png"
+        resize_convert(size, png_file, output_file_name)
+      end
 
-    # Gets the generation details for the given rank.
-    #
-    # This is used USPSFlags::Generate, and should never need to be called directly.
-    # @private
-    def flag_details(rank)
-      {
-        style: flag_style(rank),
-        color: flag_color(rank),
-        type:  flag_type(rank),
-        level: flag_level(rank),
-        count: flag_count(rank)
-      }
-    end
+      # Gets the maximum length among valid flags.
+      #
+      # This is used USPSFlags::Generate, and should never need to be called directly.
+      # @private
+      def max_flag_name_length
+        valid_flags(:all).map(&:length).max
+      end
 
-    # Image sizes for generated PNG images.
-    #
-    # This is used USPSFlags::Generate, and should never need to be called directly.
-    # @private
-    def png_sizes
-      { 1500 => 'H', 1000 => 'K', 500 => 'D', 'thumb' => 'T' }
-    end
+      # Gets the generation details for the given rank.
+      #
+      # This is used USPSFlags::Generate, and should never need to be called directly.
+      # @private
+      def flag_details(rank)
+        {
+          style: flag_style(rank),
+          color: flag_color(rank),
+          type: flag_type(rank),
+          level: flag_level(rank),
+          count: flag_count(rank)
+        }
+      end
 
-    # Gets size key for saving PNG images.
-    #
-    # This is used USPSFlags::Generate, and should never need to be called directly.
-    # @private
-    def size_and_key(size:, flag:)
-      return [size, size] unless size == 'thumb'
+      # Image sizes for generated PNG images.
+      #
+      # This is used USPSFlags::Generate, and should never need to be called directly.
+      # @private
+      def png_sizes
+        { 1500 => 'H', 1000 => 'K', 500 => 'D', 'thumb' => 'T' }
+      end
 
-      size = case flag
-             when 'ENSIGN'
-               200
-             when 'US'
-               300
-             else
-               150
+      # Gets size key for saving PNG images.
+      #
+      # This is used USPSFlags::Generate, and should never need to be called directly.
+      # @private
+      def size_and_key(size:, flag:)
+        return [size, size] unless size == 'thumb'
+
+        size = case flag
+               when 'ENSIGN'
+                 200
+               when 'US'
+                 300
+               else
+                 150
+        end
+
+        [size, 'thumb']
       end
 
-      [size, 'thumb']
-    end
+      # Prints message(s) to the console and logs them.
+      #
+      # This should never need to be called directly.
+      # @private
+      def log(*messages)
+        ::FileUtils.mkdir_p(USPSFlags.configuration.log_path)
+        outputs = [STDOUT]
 
-    # Prints message(s) to the console and logs them.
-    #
-    # This should never need to be called directly.
-    # @private
-    def log(*messages)
-      ::FileUtils.mkdir_p(USPSFlags.configuration.log_path)
-      outputs = [STDOUT]
+        log_file = File.open("#{USPSFlags.configuration.log_path}/flag.log", 'a')
+        outputs << log_file
 
-      log_file = File.open("#{USPSFlags.configuration.log_path}/flag.log", 'a')
-      outputs << log_file
+        messages.each do |message|
+          outputs.each { |f| f.write(message) }
+        end
 
-      messages.each do |message|
-        outputs.each { |f| f.write(message) }
+        messages
+      ensure
+        log_file.close if log_file.is_a?(File)
       end
 
-      messages
-    ensure
-      log_file.close if log_file.is_a?(File)
-    end
-
-    # Ensures the directory for the specified path exists.
-    #
-    # This should never need to be called directly.
-    # @private
-    def ensure_dir_for_file(path)
-      return false if path.nil? || path.empty? || !path.scan('/')
+      # Ensures the directory for the specified path exists.
+      #
+      # This should never need to be called directly.
+      # @private
+      def ensure_dir_for_file(path)
+        return false if path.nil? || path.empty? || !path.scan('/')
 
-      dirs = path.split('/')
-      dirs.pop
-      ::FileUtils.mkdir_p(dirs.join('/')).first
-    end
+        dirs = path.split('/')
+        dirs.pop
+        ::FileUtils.mkdir_p(dirs.join('/')).first
+      end
 
-    # Prints output to the console or saves to a file, then returns the generated data.
-    #
-    # This should never need to be called directly.
-    # @private
-    def output(svg, outfile: nil)
-      if outfile.nil?
-        puts svg, "\n"
-      elsif outfile != ''
-        ensure_dir_for_file(outfile)
-        f = ::File.new(outfile, 'w+')
-        f.write(svg)
-        f.close
-      end
-      svg
-    end
+      # Prints output to the console or saves to a file, then returns the generated data.
+      #
+      # This should never need to be called directly.
+      # @private
+      def output(svg, outfile: nil)
+        if outfile.nil?
+          puts svg, "\n"
+        elsif outfile != ''
+          ensure_dir_for_file(outfile)
+          f = ::File.new(outfile, 'w+')
+          f.write(svg)
+          f.close
+        end
+        svg
+      end
 
-  private
+    private
 
-    def resize_convert(size, png_file, output_file_name)
-      MiniMagick::Tool::Convert.new do |convert|
-        convert << '-background' << 'none'
-        convert << '-format' << 'png'
-        convert << '-resize' << "#{size}"
-        convert << png_file
-        convert << output_file_name
+      def resize_convert(size, png_file, output_file_name)
+        MiniMagick::Tool::Convert.new do |convert|
+          convert << '-background' << 'none'
+          convert << '-format' << 'png'
+          convert << '-resize' << size.to_s
+          convert << png_file
+          convert << output_file_name
+        end
       end
-    end
 
-    def flag_style(rank)
-      return :past if valid_flags(:past).include?(rank)
-      return :swallowtail if valid_flags(:swallowtail).include?(rank)
+      def flag_style(rank)
+        return :past if valid_flags(:past).include?(rank)
+        return :swallowtail if valid_flags(:swallowtail).include?(rank)
 
-      :regular
-    end
+        :regular
+      end
 
-    def flag_color(rank)
-      return :blue if valid_flags(:command).include?(rank)
-      return :red if valid_flags(:bridge).include?(rank)
+      def flag_color(rank)
+        return :blue if valid_flags(:command).include?(rank)
+        return :red if valid_flags(:bridge).include?(rank)
 
-      :white
-    end
+        :white
+      end
 
-    def flag_level(rank)
-      return :n if rank.match? /N.*/
-      return :d if rank.match? /D.*/
-      return :s if rank == 'FLT'
-    end
+      def flag_level(rank)
+        return :n if rank.match?(/N.*/)
+        return :d if rank.match?(/D.*/)
+        return :s if rank == 'FLT'
+      end
 
-    def flag_count(rank)
-      return 3 if valid_flags(:command).include?(rank)
-      return 2 if valid_flags(:bridge).include?(rank)
+      def flag_count(rank)
+        return 3 if valid_flags(:command).include?(rank)
+        return 2 if valid_flags(:bridge).include?(rank)
 
-      1
-    end
+        1
+      end
+
+      def flag_type(rank)
+        specifics = { 'PORTCAP' => :pc, 'FLEETCAP' => :fc, 'STFC' => :stf }
+        return specifics[rank] if specifics.key?(rank)
+        return :a if rank.match?(/.AIDE/)
+        return :f if rank.match?(/.?FLT/)
 
-    def flag_type(rank) # Complexity
-      specifics = { 'PORTCAP' => :pc, 'FLEETCAP' => :fc, 'STFC' => :stf }
-      if specifics.keys.include?(rank)
-        specifics[rank]
-      elsif rank.match? /.AIDE/
-        :a
-      elsif rank.match? /.?FLT/
-        :f
-      else
         get_line_flag_level(rank)
       end
-    end
 
-    def get_line_flag_level(rank)
-      return :s if valid_flags(:squadron).include?(rank)
-      return :d if valid_flags(:district).include?(rank)
-      return :n if valid_flags(:national).include?(rank)
+      def get_line_flag_level(rank)
+        return :s if valid_flags(:squadron).include?(rank)
+        return :d if valid_flags(:district).include?(rank)
+        return :n if valid_flags(:national).include?(rank)
+      end
     end
   end
 end