pnm 0.4.1 → 0.6.0

data/lib/pnm/exceptions.rb

@@ -1,3 +1,5 @@
+# frozen_string_literal: true
+
 module PNM
 
   # Base class for all PNM exceptions.

data/lib/pnm/image.rb

@@ -1,3 +1,5 @@
+# frozen_string_literal: true
+
 module PNM
 
   # Abstract base class for +PBM+, +PGM+, and +PPM+ images.
@@ -36,20 +38,20 @@ module PNM
     # This method should be called as PNM.create.
     # See there for a description of pixel data formats
     # and available options.
-    def self.create(pixels, options = {})
+    def self.create(pixels, type: nil, maxgray: nil, comment: nil)
       assert_valid_array(pixels)
-      assert_valid_maxgray(options[:maxgray])
-      assert_valid_comment(options[:comment])
+      assert_valid_maxgray(maxgray)
+      assert_valid_comment(comment)
 
-      type = sanitize_and_assert_valid_type(options[:type])
-      type ||= detect_type(pixels, options[:maxgray])
+      type = sanitize_and_assert_valid_type(type)
+      type ||= detect_type(pixels, maxgray)
 
       # except for type detection, the maxgray option must be ignored for PBM
-      if type == :pbm
-        maxgray = nil
-      else
-        maxgray = options[:maxgray]
-      end
+      maxgray = if type == :pbm
+                  nil
+                else
+                  maxgray
+                end
 
       image_class = case type
                     when :pbm
@@ -60,7 +62,7 @@ module PNM
                       PPMImage
                     end
 
-      image_class.new(pixels, maxgray, options[:comment])
+      image_class.new(pixels, maxgray, comment)
     end
 
     class << self
@@ -80,22 +82,31 @@ module PNM
       assert_pixel_value_range
 
       post_initialize
+
+      @pixels.freeze
+      @comment.freeze
     end
 
-    # Writes the image to +file+ (a filename or an IO object),
-    # using the specified encoding.
-    # Valid encodings are +:binary+ (default) and +:ascii+.
+    # Writes the image to +file+ (a filename or an IO object).
+    #
+    # When +add_extension+ is set to +true+ (default: +false+)
+    # the appropriate file extension is added to the provided filename
+    # (+.pbm+, +.pgm+, or +.ppm+).
+    #
+    # The encoding can be set using the +encoding+ keyword argument,
+    # valid options are +:binary+ (default) and +:ascii+.
     #
     # Returns the number of bytes written.
-    def write(file, encoding = :binary)
+    def write(file, add_extension: false, encoding: :binary)
       content = if encoding == :ascii
                   to_ascii
                 elsif encoding == :binary
                   to_binary
                 end
 
-      if file.kind_of?(String)
-        File.binwrite(file, content)
+      if file.is_a?(String)
+        filename = add_extension ? "#{file}.#{type}" : file
+        File.binwrite(filename, content)
       else
         file.binmode
         file.write content
@@ -107,35 +118,44 @@ module PNM
       "#{type.to_s.upcase} #{width}x#{height} #{type_string}"
     end
 
-    alias :to_s :info
+    alias to_s info
 
     # Returns a string representation for debugging.
     def inspect
       # implemented by subclasses
     end
 
-    private
+    # Equality --- Two images are considered equal if they have
+    # the same pixel values, type, maxgray, and comments.
+    def ==(other)
+      return true  if other.equal?(self)
+      return false  unless other.instance_of?(self.class)
+
+      type == other.type && maxgray == other.maxgray && comment == other.comment && pixels == other.pixels
+    end
 
     def self.assert_valid_array(pixels)  # :nodoc:
       assert_array_dimensions(pixels)
       assert_pixel_types(pixels)
     end
+    private_class_method :assert_valid_array
 
     def self.assert_array_dimensions(pixels)  # :nodoc:
       msg = "invalid pixel data: Array expected"
-      raise PNM::ArgumentError, msg  unless Array === pixels
+      raise PNM::ArgumentError, msg  unless pixels.is_a?(Array)
 
       msg = "invalid pixel array"
-
       raise PNM::DataError, msg  unless pixels.map(&:class).uniq == [Array]
+
       width = pixels.first.size
-      raise PNM::DataError, msg  if width == 0
+      raise PNM::DataError, msg  if width.zero?
       raise PNM::DataError, msg  unless pixels.map(&:size).uniq == [width]
     end
+    private_class_method :assert_array_dimensions
 
     def self.assert_pixel_types(pixels)  # :nodoc:
       pixel_values = pixels.flatten(1)
-      is_color = (Array === pixel_values.first)
+      is_color = pixel_values.first.is_a?(Array)
 
       if is_color
         pixel_values.each {|pixel| assert_valid_color_pixel(pixel) }
@@ -143,43 +163,47 @@ module PNM
         pixel_values.each {|pixel| assert_valid_pixel(pixel) }
       end
     end
+    private_class_method :assert_pixel_types
 
     def self.assert_valid_pixel(pixel)  # :nodoc:
-      unless Fixnum === pixel
-        msg = "invalid pixel value: Fixnum expected - #{pixel.inspect}"
-        raise PNM::DataError, msg
-      end
+      return  if pixel.is_a?(Integer)
+
+      msg = "invalid pixel value: Integer expected - #{pixel.inspect}"
+      raise PNM::DataError, msg
     end
+    private_class_method :assert_valid_pixel
 
     def self.assert_valid_color_pixel(pixel)  # :nodoc:
-      unless Array === pixel && pixel.map(&:class) == [Fixnum, Fixnum, Fixnum]
-        msg =  "invalid pixel value: "
-        msg << "Array of 3 Fixnums expected - #{pixel.inspect}"
+      return  if pixel.is_a?(Array) && pixel.size == 3 && pixel.all? {|p| p.is_a?(Integer) }
 
-        raise PNM::DataError, msg
-      end
+      msg =  "invalid pixel value: ".dup
+      msg << "Array of 3 Integers expected - #{pixel.inspect}"
+      raise PNM::DataError, msg
     end
+    private_class_method :assert_valid_color_pixel
 
     def self.assert_valid_maxgray(maxgray)  # :nodoc:
       return  unless maxgray
+      return  if maxgray.is_a?(Integer) && maxgray > 0 && maxgray <= 255
 
-      unless Fixnum === maxgray && maxgray > 0 && maxgray <= 255
-        raise PNM::ArgumentError, "invalid maxgray value - #{maxgray.inspect}"
-      end
+      msg = "invalid maxgray value - #{maxgray.inspect}"
+      raise PNM::ArgumentError, msg
     end
+    private_class_method :assert_valid_maxgray
 
     def self.assert_valid_comment(comment)  # :nodoc:
       return  unless comment
+      return  if comment.is_a?(String)
 
-      unless String === comment
-        raise PNM::ArgumentError, "invalid comment value - #{comment.inspect}"
-      end
+      msg = "invalid comment value - #{comment.inspect}"
+      raise PNM::ArgumentError, msg
     end
+    private_class_method :assert_valid_comment
 
     def self.sanitize_and_assert_valid_type(type)  # :nodoc:
       return  unless type
 
-      type = type.to_sym  if type.kind_of?(String)
+      type = type.to_sym  if type.is_a?(String)
 
       unless [:pbm, :pgm, :ppm].include?(type)
         msg = "invalid image type - #{type.inspect}"
@@ -188,9 +212,10 @@ module PNM
 
       type
     end
+    private_class_method :sanitize_and_assert_valid_type
 
     def self.detect_type(pixels, maxgray)  # :nodoc:
-      if pixels.first.first.kind_of?(Array)
+      if pixels.first.first.is_a?(Array)
         :ppm
       elsif (maxgray && maxgray > 1) || pixels.flatten.max > 1
         :pgm
@@ -198,25 +223,27 @@ module PNM
         :pbm
       end
     end
+    private_class_method :detect_type
+
+    private
 
     def assert_grayscale_data  # :nodoc:
-      if color_pixels?
-        msg = "specified type does not match RGB data - #{type.inspect}"
-        raise PNM::DataError, msg
-      end
+      return  unless color_pixels?
+
+      msg = "specified type does not match RGB data - #{type.inspect}"
+      raise PNM::DataError, msg
     end
 
     def assert_pixel_value_range  # :nodoc:
-      unless pixels.flatten.max <= maxgray
-        raise PNM::DataError, "invalid data: value(s) greater than maxgray"
-      end
-      unless pixels.flatten.min >= 0
-        raise PNM::DataError, "invalid data: value(s) less than zero"
-      end
+      msg = "invalid data: value(s) greater than maxgray"
+      raise PNM::DataError, msg  unless pixels.flatten.max <= maxgray
+
+      msg = "invalid data: value(s) less than zero"
+      raise PNM::DataError, msg  unless pixels.flatten.min >= 0
     end
 
     def header_without_maxgray(encoding)  # :nodoc:
-      header =  "#{PNM.magic_number[type][encoding]}\n"
+      header = "#{PNM.magic_number[type][encoding]}\n".dup
       comment_lines.each do |line|
         header << (line.empty? ? "#\n" : "# #{line}\n")
       end
@@ -231,7 +258,7 @@ module PNM
 
     def comment_lines  # :nodoc:
       return []    unless comment
-      return ['']  if comment.empty?
+      return [""]  if comment.empty?
 
       keep_trailing_null_fields = -1  # magic value for split limit
       comment.split(/\n/, keep_trailing_null_fields)
@@ -250,11 +277,11 @@ module PNM
     end
 
     def color_pixels?  # :nodoc:
-      (pixels.first.first).kind_of?(Array)
+      pixels.first.first.is_a?(Array)
     end
 
     def inspect_string_with_maxgray  # :nodoc:
-        "#<%s:0x%x %s, maxgray=%d>" % [self.class.name, object_id, info, maxgray]
+      "#<%s:0x%x %s, maxgray=%d>" % [self.class.name, object_id, info, maxgray]
     end
 
     def inspect_string_without_maxgray  # :nodoc:

data/lib/pnm/parser.rb

@@ -1,3 +1,5 @@
+# frozen_string_literal: true
+
 module PNM
 
   # @private
@@ -20,14 +22,14 @@ module PNM
       content = content.dup
 
       magic_number = nil
-      tokens   = []
+      tokens = []
       comments = []
 
       until magic_number
         token = next_token!(content)
 
-        if token.start_with?('#')
-          comments << token.gsub(/# */, '')
+        if token.start_with?("#")
+          comments << token.gsub(/# */, "")
         else
           magic_number = token
         end
@@ -36,11 +38,11 @@ module PNM
       assert_valid_magic_number(magic_number)
 
       while tokens.size < token_number[magic_number]
-        content.gsub!(/\A[ \t\r\n]+/, '')
+        content.gsub!(/\A[ \t\r\n]+/, "")
         token = next_token!(content)
 
-        if token.start_with?('#')
-          comments << token.gsub(/# */, '')
+        if token.start_with?("#")
+          comments << token.gsub(/# */, "")
         else
           tokens << token
         end
@@ -48,23 +50,23 @@ module PNM
 
       width, height, maxgray = tokens
 
-      assert_integer(width,   "width")
-      assert_integer(height,  "height")
+      assert_integer(width, "width")
+      assert_integer(height, "height")
       assert_integer(maxgray, "maxgray")  if maxgray
 
-      width   = width.to_i
-      height  = height.to_i
+      width = width.to_i
+      height = height.to_i
       maxgray = maxgray.to_i  if maxgray
 
-      assert_value(width,   "width")   {|x| x > 0 }
-      assert_value(height,  "height")  {|x| x > 0 }
-      assert_value(maxgray, "maxgray") {|x| x > 0 && x <= 255 }  if maxgray
+      assert_positive(width, "width")
+      assert_positive(height, "height")
+      assert_in_maxgray_range(maxgray)  if maxgray
 
       result = {
-        :magic_number => magic_number,
-        :width        => width,
-        :height       => height,
-        :data         => content
+        magic_number: magic_number,
+        width:        width,
+        height:       height,
+        data:         content
       }
       result[:maxgray]  = maxgray   if maxgray
       result[:comments] = comments  unless comments.empty?
@@ -74,24 +76,24 @@ module PNM
 
     def self.token_number
       {
-        'P1' => 2,
-        'P2' => 3,
-        'P3' => 3,
-        'P4' => 2,
-        'P5' => 3,
-        'P6' => 3
+        "P1" => 2,
+        "P2" => 3,
+        "P3" => 3,
+        "P4" => 2,
+        "P5" => 3,
+        "P6" => 3
       }
     end
 
     def self.next_token!(content)
-      delimiter = if content.start_with?('#')
+      delimiter = if content.start_with?("#")
                     "\n"
                   else
-                    %r{[ \t\r\n]|(?=#)}
+                    /[ \t\r\n]|(?=#)/
                   end
 
       token, rest = content.split(delimiter, 2)
-      raise PNM::ParserError, 'not enough tokens in file'  unless rest
+      raise PNM::ParserError, "not enough tokens in file"  unless rest
 
       content.replace(rest)
 
@@ -99,24 +101,31 @@ module PNM
     end
 
     def self.assert_valid_magic_number(magic_number)
-      unless %w{P1 P2 P3 P4 P5 P6}.include?(magic_number)
-        msg = "unknown magic number - `#{magic_number}'"
-        raise PNM::ParserError, msg
-      end
+      return  if %w[P1 P2 P3 P4 P5 P6].include?(magic_number)
+
+      msg = "unknown magic number - `#{magic_number}'"
+      raise PNM::ParserError, msg
     end
 
     def self.assert_integer(value_string, value_name)
-      unless /\A[0-9]+\Z/ === value_string
-        msg = "#{value_name} must be an integer - `#{value_string}'"
-        raise PNM::ParserError, msg
-      end
+      return  if value_string =~ /\A[0-9]+\Z/
+
+      msg = "#{value_name} must be an integer - `#{value_string}'"
+      raise PNM::ParserError, msg
     end
 
-    def self.assert_value(value, name)
-      unless yield(value)
-        msg = "invalid #{name} value - `#{value}'"
-        raise PNM::ParserError, msg
-      end
+    def self.assert_positive(value, name)
+      return  if value > 0
+
+      msg = "#{name} must be greater than 0 - `#{value}'"
+      raise PNM::ParserError, msg
+    end
+
+    def self.assert_in_maxgray_range(value)
+      return  if value > 0 && value <= 255
+
+      msg = "invalid maxgray value - `#{value}'"
+      raise PNM::ParserError, msg
     end
   end
 end

data/lib/pnm/version.rb

@@ -1,4 +1,6 @@
+# frozen_string_literal: true
+
 module PNM
-  VERSION  = '0.4.1'
-  DATE     = '2015-01-20'
+  VERSION = "0.6.0"
+  DATE    = "2020-09-23"
 end

data/pnm.gemspec

@@ -1,4 +1,6 @@
-require './lib/pnm'
+# frozen_string_literal: true
+
+require "./lib/pnm"
 
 version  = PNM::VERSION
 date     = PNM::DATE
@@ -6,39 +8,41 @@ homepage = PNM::HOMEPAGE
 tagline  = PNM::TAGLINE
 
 Gem::Specification.new do |s|
-  s.name              = 'pnm'
+  s.name              = "pnm"
   s.version           = version
   s.date              = date
 
-  s.description = 'PNM is a pure Ruby library for creating, reading, ' +
-                  'and writing of PNM image files (Portable Anymap): ' +
-                  'PBM (Portable Bitmap), ' +
-                  'PGM (Portable Graymap), and ' +
-                  'PPM (Portable Pixmap).'
+  s.description = "PNM is a pure Ruby library for creating, reading, " \
+                  "and writing of PNM image files (Portable Anymap): " \
+                  "PBM (Portable Bitmap), " \
+                  "PGM (Portable Graymap), and " \
+                  "PPM (Portable Pixmap)."
   s.summary = "PNM - #{tagline}"
 
-  s.authors = ['Marcus Stollsteimer']
-  s.email = 'sto.mar@web.de'
+  s.authors = ["Marcus Stollsteimer"]
+  s.email = "sto.mar@web.de"
   s.homepage = homepage
 
-  s.license = 'GPL-3'
+  s.license = "GPL-3.0"
 
-  s.required_ruby_version = '>= 1.9.3'
+  s.required_ruby_version = ">= 2.0.0"
 
-  s.add_development_dependency 'rake', '>= 10.0'
-  s.add_development_dependency 'minitest', '>= 5.0'
+  s.add_development_dependency "minitest", ">= 5.0"
+  s.add_development_dependency "rake", ">= 10.0"
 
-  s.require_path = 'lib'
+  s.require_paths = ["lib"]
 
-  s.test_files = Dir.glob('test/**/test_*.rb')
+  s.test_files = Dir.glob("test/**/test_*.rb")
 
-  s.files = %w{
+  s.files =
+    %w[
       README.md
       Rakefile
       pnm.gemspec
       .yardopts
-    } +
-    Dir.glob('{benchmark,lib,test}/**/*')
+    ] +
+    Dir.glob("{benchmark,lib,test}/**/*")
 
-  s.rdoc_options = ['--charset=UTF-8']
+  s.extra_rdoc_files = ["README.md"]
+  s.rdoc_options = ["--charset=UTF-8", "--main=README.md"]
 end