pnm 0.3.4 → 0.4.0

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA1:
-  metadata.gz: 6a67b8402e945e8d27962981006428433aa2bf5d
-  data.tar.gz: adc0238ba64a48028c43c4a2daa60d94e3074297
+  metadata.gz: b65acf13eeae10d44cdb6819968ab967f240ec92
+  data.tar.gz: ac881cf1d053ee6110a2624c62092d1e93623414
 SHA512:
-  metadata.gz: 3ac2f0cf568b65fe2d70e6b9665db5c88c8011003446bea7858a74c2367bbc71d6af34c855b669dc7c1e2682aef15d7571a0c24ce73312c09c4c84882143ef7f
-  data.tar.gz: 3501103cd58fa19bf20ef47e9f482ed4d1243c9bc2acf8b4e1b270e5a1a46cb94d4162b4efd6d32547f251bace34e21a0c385766bd41f62780cd3562b93002b8
+  metadata.gz: aa018e4a6f04380252ba21c8a8e572138f55f78c57c2b67a1a2bedf7afdd3108287a2c283654177e163e9bc8d5df0ec3ca67a6906a4c678cd7bcf76b30499f63
+  data.tar.gz: 30ac4d58dd7ced728223abec188313480c19043908548a7a550c490c1dc745c47156886c22685c5d523ffbc782ea640289b5355a829c0f68c903110b79ff407f

data/README.md

@@ -30,7 +30,7 @@ pixels = [[ 0, 10, 20],
 options = {:maxgray => 30, :comment => 'Test Image'}
 
 # create the image object
-image = PNM::Image.new(pixels, options)
+image = PNM.create(pixels, options)
 
 # retrieve some image properties
 image.info    # => "PGM 3x2 Grayscale"
@@ -43,7 +43,7 @@ Note that for PBM bilevel images a pixel value of 0 signifies white
 (and 1 signifies black), whereas for PGM and PPM images a value of 0
 signifies black.
 
-See PNM::Image.new for a more detailed description of pixel data formats
+See PNM.create for a more detailed description of pixel data formats
 and available options.
 
 Write an image to a file:
@@ -70,7 +70,7 @@ image.pixels   # => [[0, 10, 20], [10, 20, 30]]
 Force an image type:
 
 ``` ruby
-image = PNM::Image.new([[0, 1],[1, 0]], :type => :ppm)
+image = PNM.create([[0, 1],[1, 0]], :type => :ppm)
 image.info  # => "PPM 2x2 Color"
 ```
 

data/lib/pnm.rb

@@ -36,7 +36,7 @@ require_relative 'pnm/exceptions'
 #     options = {:maxgray => 30, :comment => 'Test Image'}
 #
 #     # create the image object
-#     image = PNM::Image.new(pixels, options)
+#     image = PNM.create(pixels, options)
 #
 #     # retrieve some image properties
 #     image.info    # => "PGM 3x2 Grayscale"
@@ -48,7 +48,7 @@ require_relative 'pnm/exceptions'
 # (and 1 signifies black), whereas for PGM and PPM images a value of 0
 # signifies black.
 #
-# See PNM::Image.new for a more detailed description of pixel data formats
+# See PNM.create for a more detailed description of pixel data formats
 # and available options.
 #
 # Write an image to a file:
@@ -70,7 +70,7 @@ require_relative 'pnm/exceptions'
 #
 # Force an image type:
 #
-#     image = PNM::Image.new([[0, 1],[1, 0]], :type => :ppm)
+#     image = PNM.create([[0, 1],[1, 0]], :type => :ppm)
 #     image.info  # => "PPM 2x2 Color"
 #
 # == See also
@@ -145,7 +145,42 @@ module PNM
     options = {:type => type, :maxgray => maxgray}
     options[:comment] = content[:comments].join("\n")  if content[:comments]
 
-    Image.new(pixels, options)
+    create(pixels, options)
+  end
+
+  # Creates an image from a two-dimensional array of bilevel,
+  # gray, or RGB values.
+  # The image type is guessed from the provided pixel data,
+  # unless it is explicitly set with the +type+ option.
+  #
+  # +pixels+::  The pixel data, given as a two-dimensional array of
+  #
+  #             * for PBM: bilevel values of 0 (white) or 1 (black),
+  #             * for PGM: gray values between 0 (black) and +maxgray+ (white),
+  #             * for PPM: an array of 3 values between 0 and +maxgray+,
+  #               corresponding to red, green, and blue (RGB);
+  #               a value of 0 means that the color is turned off.
+  #
+  # Optional settings that can be specified in the +options+ hash:
+  #
+  # +type+::    The type of the image (+:pbm+, +:pgm+, or +:ppm+).
+  #             By explicitly setting +type+, PGM images can be
+  #             created from bilevel pixel data, and PPM images can be
+  #             created from bilevel or gray pixel data.
+  #             String values (<tt>"pbm"</tt>, <tt>"pgm"</tt>,
+  #             or <tt>"ppm"</tt>) are also accepted.
+  # +maxgray+:: The maximum gray or color value.
+  #             For PGM and PPM, +maxgray+ must be less or equal 255
+  #             (the default value).
+  #             For bilevel pixel data, setting +maxgray+ to a value
+  #             greater than 1 implies a type of +:pgm+.
+  #             When +type+ is explicitly set to +:pbm+,
+  #             the +maxgray+ setting is disregarded.
+  # +comment+:: A multiline comment string.
+  #
+  # Returns a PNM::Image object.
+  def self.create(pixels, options = {})
+    Image.create(pixels, options)
   end
 
   # @private

data/lib/pnm/image.rb

@@ -1,15 +1,17 @@
 module PNM
 
-  # Class for +PBM+, +PGM+, and +PPM+ images.
+  # Abstract base class for +PBM+, +PGM+, and +PPM+ images.
   #
-  # Images can be created from pixel values, see ::new,
+  # Images can be created from pixel values, see PNM.create,
   # or read from a file or I/O stream, see PNM.read.
   #
   # See PNM module for examples.
   class Image
 
-    # The type of the image. See ::new for details.
-    attr_reader :type
+    # The type of the image. See PNM.create for details.
+    def type
+      # implemented by subclasses
+    end
 
     # The width of the image in pixels.
     attr_reader :width
@@ -18,11 +20,11 @@ module PNM
     attr_reader :height
 
     # The maximum gray or color value (for PBM always set to 1).
-    # See ::new for details.
+    # See PNM.create for details.
     attr_reader :maxgray
 
     # The pixel data, given as a two-dimensional array.
-    # See ::new for details.
+    # See PNM.create for details.
     attr_reader :pixels
 
     # An optional multiline comment string (or +nil+).
@@ -30,64 +32,54 @@ module PNM
 
     # Creates an image from a two-dimensional array of bilevel,
     # gray, or RGB values.
-    # The image type is guessed from the provided pixel data,
-    # unless it is explicitly set with the +type+ option.
-    #
-    # +pixels+::  The pixel data, given as a two-dimensional array of
-    #
-    #             * for PBM: bilevel values of 0 (white) or 1 (black),
-    #             * for PGM: gray values between 0 (black) and +maxgray+ (white),
-    #             * for PPM: an array of 3 values between 0 and +maxgray+,
-    #               corresponding to red, green, and blue (RGB);
-    #               a value of 0 means that the color is turned off.
     #
-    # Optional settings that can be specified in the +options+ hash:
-    #
-    # +type+::    The type of the image (+:pbm+, +:pgm+, or +:ppm+).
-    #             By explicitly setting +type+, PGM images can be
-    #             created from bilevel pixel data, and PPM images can be
-    #             created from bilevel or gray pixel data.
-    #             String values (<tt>"pbm"</tt>, <tt>"pgm"</tt>,
-    #             or <tt>"ppm"</tt>) are also accepted.
-    # +maxgray+:: The maximum gray or color value.
-    #             For PGM and PPM, +maxgray+ must be less or equal 255
-    #             (the default value).
-    #             For bilevel pixel data, setting +maxgray+ to a value
-    #             greater than 1 implies a type of +:pgm+.
-    #             When +type+ is explicitly set to +:pbm+,
-    #             the +maxgray+ setting is disregarded.
-    # +comment+:: A multiline comment string.
-    def initialize(pixels, options = {})
-      @type    = options[:type]
-      @maxgray = options[:maxgray]
-      @comment = options[:comment]
-      @pixels  = pixels.dup
+    # 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 = {})
+      assert_valid_array(pixels)
+      assert_valid_maxgray(options[:maxgray])
+      assert_valid_comment(options[:comment])
+
+      type = sanitize_and_assert_valid_type(options[:type])
+      type ||= detect_type(pixels, options[:maxgray])
+
+      # except for type detection, the maxgray option must be ignored for PBM
+      if type == :pbm
+        maxgray = nil
+      else
+        maxgray = options[:maxgray]
+      end
 
-      @type = @type.to_sym  if @type && String === @type
+      image_class = case type
+                    when :pbm
+                      PBMImage
+                    when :pgm
+                      PGMImage
+                    when :ppm
+                      PPMImage
+                    end
 
-      assert_valid_type     if @type
-      assert_valid_maxgray  if @maxgray
-      assert_valid_comment  if @comment
-      assert_valid_array
+      image_class.new(pixels, maxgray, options[:comment])
+    end
 
+    class << self
+      protected :new
+    end
+
+    # @private
+    #
+    # Invoked by ::create after basic input validations.
+    def initialize(pixels, maxgray, comment)  # :nodoc:
+      @pixels  = pixels.dup
       @width   = pixels.first.size
       @height  = pixels.size
+      @maxgray = maxgray || default_maxgray
+      @comment = comment
 
-      @type ||= detect_type(@pixels, @maxgray)
-
-      assert_matching_type_and_data
-
-      if @type == :pbm
-        @maxgray = 1
-      else
-        @maxgray ||= 255
-      end
-
-      assert_valid_pixel_values
+      assert_pixel_value_range
 
-      if type == :ppm && !pixels.first.first.kind_of?(Array)
-        @pixels.map! {|row| row.map {|pixel| gray_to_rgb(pixel) } }
-      end
+      post_initialize
     end
 
     # Writes the image to +file+ (a filename or an IO object),
@@ -119,65 +111,46 @@ module PNM
 
     # Returns a string representation for debugging.
     def inspect
-      if type == :pbm
-        "#<%s:0x%x %s>" % [self.class.name, object_id, info]
-      else
-        "#<%s:0x%x %s, maxgray=%d>" % [self.class.name, object_id, info, maxgray]
-      end
+      # implemented by subclasses
     end
 
     private
 
-    def type_string  # :nodoc:
-      case type
-      when :pbm
-        'Bilevel'
-      when :pgm
-        'Grayscale'
-      when :ppm
-        'Color'
-      end
-    end
-
-    def detect_type(pixels, maxgray)  # :nodoc:
-      if pixels.first.first.kind_of?(Array)
-        :ppm
-      elsif (maxgray && maxgray > 1) || pixels.flatten.max > 1
-        :pgm
-      else
-        :pbm
-      end
+    def self.assert_valid_array(pixels)  # :nodoc:
+      assert_array_dimensions(pixels)
+      assert_pixel_types(pixels)
     end
 
-    def assert_valid_array  # :nodoc:
+    def self.assert_array_dimensions(pixels)  # :nodoc:
       msg = "invalid pixel data: Array expected"
       raise PNM::ArgumentError, msg  unless Array === pixels
 
       msg = "invalid pixel array"
-      raise PNM::DataError, msg  unless Array === pixels.first
 
+      raise PNM::DataError, msg  unless pixels.map(&:class).uniq == [Array]
       width = pixels.first.size
-      is_color = (Array === pixels.first.first)
+      raise PNM::DataError, msg  unless pixels.map(&:size).uniq == [width]
+    end
 
-      pixels.each do |row|
-        raise PNM::DataError, msg  unless Array === row && row.size == width
+    def self.assert_pixel_types(pixels)  # :nodoc:
+      pixel_values = pixels.flatten(1)
+      is_color = (Array === pixel_values.first)
 
-        if is_color
-          row.each {|pixel| assert_valid_color_pixel(pixel) }
-        else
-          row.each {|pixel| assert_valid_pixel(pixel) }
-        end
+      if is_color
+        pixel_values.each {|pixel| assert_valid_color_pixel(pixel) }
+      else
+        pixel_values.each {|pixel| assert_valid_pixel(pixel) }
       end
     end
 
-    def assert_valid_pixel(pixel)  # :nodoc:
+    def self.assert_valid_pixel(pixel)  # :nodoc:
       unless Fixnum === pixel
         msg = "invalid pixel value: Fixnum expected - #{pixel.inspect}"
         raise PNM::DataError, msg
       end
     end
 
-    def assert_valid_color_pixel(pixel)  # :nodoc:
+    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}"
@@ -186,33 +159,53 @@ module PNM
       end
     end
 
-    def assert_valid_type  # :nodoc:
+    def self.assert_valid_maxgray(maxgray)  # :nodoc:
+      return  unless maxgray
+
+      unless Fixnum === maxgray && maxgray > 0 && maxgray <= 255
+        raise PNM::ArgumentError, "invalid maxgray value - #{maxgray.inspect}"
+      end
+    end
+
+    def self.assert_valid_comment(comment)  # :nodoc:
+      return  unless comment
+
+      unless String === comment
+        raise PNM::ArgumentError, "invalid comment value - #{comment.inspect}"
+      end
+    end
+
+    def self.sanitize_and_assert_valid_type(type)  # :nodoc:
+      return  unless type
+
+      type = type.to_sym  if type.kind_of?(String)
+
       unless [:pbm, :pgm, :ppm].include?(type)
         msg = "invalid image type - #{type.inspect}"
         raise PNM::ArgumentError, msg
       end
-    end
 
-    def assert_matching_type_and_data  # :nodoc:
-      if Array === pixels.first.first && [:pbm, :pgm].include?(type)
-        msg = "specified type does not match data - #{type.inspect}"
-        raise PNM::DataError, msg
-      end
+      type
     end
 
-    def assert_valid_maxgray  # :nodoc:
-      unless Fixnum === maxgray && maxgray > 0 && maxgray <= 255
-        raise PNM::ArgumentError, "invalid maxgray value - #{maxgray.inspect}"
+    def self.detect_type(pixels, maxgray)  # :nodoc:
+      if pixels.first.first.kind_of?(Array)
+        :ppm
+      elsif (maxgray && maxgray > 1) || pixels.flatten.max > 1
+        :pgm
+      else
+        :pbm
       end
     end
 
-    def assert_valid_comment  # :nodoc:
-      unless String === comment
-        raise PNM::ArgumentError, "invalid comment value - #{comment.inspect}"
+    def assert_grayscale_data  # :nodoc:
+      if color_pixels?
+        msg = "specified type does not match RGB data - #{type.inspect}"
+        raise PNM::DataError, msg
       end
     end
 
-    def assert_valid_pixel_values  # :nodoc:
+    def assert_pixel_value_range  # :nodoc:
       unless pixels.flatten.max <= maxgray
         raise PNM::DataError, "invalid data: value(s) greater than maxgray"
       end
@@ -221,17 +214,20 @@ module PNM
       end
     end
 
-    def header(encoding)  # :nodoc:
+    def header_without_maxgray(encoding)  # :nodoc:
       header =  "#{PNM.magic_number[type][encoding]}\n"
       comment_lines.each do |line|
         header << (line.empty? ? "#\n" : "# #{line}\n")
       end
       header << "#{width} #{height}\n"
-      header << "#{maxgray}\n"  unless type == :pbm
 
       header
     end
 
+    def header_with_maxgray(encoding)  # :nodoc:
+      header_without_maxgray(encoding) << "#{maxgray}\n"
+    end
+
     def comment_lines  # :nodoc:
       return []    unless comment
       return ['']  if comment.empty?
@@ -252,6 +248,115 @@ module PNM
       header(:binary) << data_string
     end
 
+    def color_pixels?  # :nodoc:
+      (pixels.first.first).kind_of?(Array)
+    end
+
+    def inspect_string_with_maxgray  # :nodoc:
+        "#<%s:0x%x %s, maxgray=%d>" % [self.class.name, object_id, info, maxgray]
+    end
+
+    def inspect_string_without_maxgray  # :nodoc:
+      "#<%s:0x%x %s>" % [self.class.name, object_id, info]
+    end
+  end
+
+
+  # Class for +PBM+ images. See the Image class for documentation.
+  class PBMImage < Image
+
+    def type
+      :pbm
+    end
+
+    def inspect
+      inspect_string_without_maxgray
+    end
+
+    private
+
+    def post_initialize  # :nodoc:
+      assert_grayscale_data
+    end
+
+    def default_maxgray  # :nodoc:
+      1
+    end
+
+    def type_string  # :nodoc:
+      "Bilevel"
+    end
+
+    def header(encoding)  # :nodoc:
+      header_without_maxgray(encoding)
+    end
+  end
+
+
+  # Class for +PGM+ images. See the Image class for documentation.
+  class PGMImage < Image
+
+    def type
+      :pgm
+    end
+
+    def inspect
+      inspect_string_with_maxgray
+    end
+
+    private
+
+    def post_initialize  # :nodoc:
+      assert_grayscale_data
+    end
+
+    def default_maxgray  # :nodoc:
+      255
+    end
+
+    def type_string  # :nodoc:
+      "Grayscale"
+    end
+
+    def header(encoding)  # :nodoc:
+      header_with_maxgray(encoding)
+    end
+  end
+
+
+  # Class for +PPM+ images. See the Image class for documentation.
+  class PPMImage < Image
+
+    def type
+      :ppm
+    end
+
+    def inspect
+      inspect_string_with_maxgray
+    end
+
+    private
+
+    def post_initialize  # :nodoc:
+      convert_pixels_to_color  unless color_pixels?
+    end
+
+    def default_maxgray  # :nodoc:
+      255
+    end
+
+    def type_string  # :nodoc:
+      "Color"
+    end
+
+    def header(encoding)  # :nodoc:
+      header_with_maxgray(encoding)
+    end
+
+    def convert_pixels_to_color  # :nodoc:
+      pixels.map! {|row| row.map {|pixel| gray_to_rgb(pixel) } }
+    end
+
     def gray_to_rgb(gray_value)  # :nodoc:
       Array.new(3, gray_value)
     end

data/lib/pnm/version.rb

@@ -1,4 +1,4 @@
 module PNM
-  VERSION  = '0.3.4'
-  DATE     = '2014-11-21'
+  VERSION  = '0.4.0'
+  DATE     = '2014-12-28'
 end

data/test/test_exceptions.rb

@@ -7,111 +7,111 @@ require 'stringio'
 require 'pnm'
 
 
-describe 'PNM::Image.new' do
+describe 'PNM.create' do
 
   it 'raises an exception for invalid data type (String)' do
     data = '0'
-    lambda { PNM::Image.new(data) }.must_raise PNM::ArgumentError
+    lambda { PNM.create(data) }.must_raise PNM::ArgumentError
   end
 
   it 'raises an exception for invalid type' do
     data = [[0, 0], [0, 0]]
-    lambda { PNM::Image.new(data, :type => :abc) }.must_raise PNM::ArgumentError
+    lambda { PNM.create(data, :type => :abc) }.must_raise PNM::ArgumentError
   end
 
   it 'raises an exception for invalid maxgray (String)' do
     data = [[0, 0], [0, 0]]
-    lambda { PNM::Image.new(data, :maxgray => '255') }.must_raise PNM::ArgumentError
+    lambda { PNM.create(data, :maxgray => '255') }.must_raise PNM::ArgumentError
   end
 
   it 'raises an exception for invalid maxgray (> 255)' do
     data = [[0, 0], [0, 0]]
-    lambda { PNM::Image.new(data, :maxgray => 256) }.must_raise PNM::ArgumentError
+    lambda { PNM.create(data, :maxgray => 256) }.must_raise PNM::ArgumentError
   end
 
   it 'raises an exception for invalid maxgray (0)' do
     data = [[0, 0], [0, 0]]
-    lambda { PNM::Image.new(data, :maxgray => 0) }.must_raise PNM::ArgumentError
+    lambda { PNM.create(data, :maxgray => 0) }.must_raise PNM::ArgumentError
   end
 
   it 'raises an exception for invalid comment (Fixnum)' do
     data = [[0, 0], [0, 0]]
-    lambda { PNM::Image.new(data, :comment => 1) }.must_raise PNM::ArgumentError
+    lambda { PNM.create(data, :comment => 1) }.must_raise PNM::ArgumentError
   end
 
   it 'raises an exception for image type and data mismatch (PBM)' do
     data = [[[0,0,0], [0,0,0]], [[0,0,0], [0,0,0]]]
-    lambda { PNM::Image.new(data, :type => :pbm) }.must_raise PNM::DataError
+    lambda { PNM.create(data, :type => :pbm) }.must_raise PNM::DataError
   end
 
   it 'raises an exception for image type and data mismatch (PGM)' do
     data = [[[0,0,0], [0,0,0]], [[0,0,0], [0,0,0]]]
-    lambda { PNM::Image.new(data, :type => :pgm) }.must_raise PNM::DataError
+    lambda { PNM.create(data, :type => :pgm) }.must_raise PNM::DataError
   end
 
   it 'raises an exception for non-integer pixel value (String)' do
     data = [[0, 0], ['X', 0]]
-    lambda { PNM::Image.new(data) }.must_raise PNM::DataError
+    lambda { PNM.create(data) }.must_raise PNM::DataError
   end
 
   it 'raises an exception for non-integer pixel value (Float)' do
     data = [[0, 0], [0.5, 0]]
-    lambda { PNM::Image.new(data) }.must_raise PNM::DataError
+    lambda { PNM.create(data) }.must_raise PNM::DataError
   end
 
   it 'raises an exception for rows of different size' do
     data = [[0, 0], [0, 0, 0]]
-    lambda { PNM::Image.new(data) }.must_raise PNM::DataError
+    lambda { PNM.create(data) }.must_raise PNM::DataError
   end
 
   it 'raises an exception for invalid array dimensions (#1)' do
     data = [0, 0, 0]
-    lambda { PNM::Image.new(data) }.must_raise PNM::DataError
+    lambda { PNM.create(data) }.must_raise PNM::DataError
   end
 
   it 'raises an exception for invalid array dimensions (#2)' do
     data = [[0, 0], 0, 0]
-    lambda { PNM::Image.new(data) }.must_raise PNM::DataError
+    lambda { PNM.create(data) }.must_raise PNM::DataError
   end
 
   it 'raises an exception for invalid array dimensions (#3)' do
     data = [[0, 0], [0, [0, 0]]]
-    lambda { PNM::Image.new(data) }.must_raise PNM::DataError
+    lambda { PNM.create(data) }.must_raise PNM::DataError
   end
 
   it 'raises an exception for invalid array dimensions (#4)' do
     data = [[[0,0], [0,0]], [[0,0], [0,0]]]
-    lambda { PNM::Image.new(data) }.must_raise PNM::DataError
+    lambda { PNM.create(data) }.must_raise PNM::DataError
   end
 
   it 'raises an exception for invalid array dimensions (#5)' do
     data = [[[0,0,0], [0,0,0]], [0 ,0]]
-    lambda { PNM::Image.new(data) }.must_raise PNM::DataError
+    lambda { PNM.create(data) }.must_raise PNM::DataError
   end
 
   it 'raises an exception for invalid array dimensions (#6)' do
     data = [[[0,0,0], 0], [0 ,0]]
-    lambda { PNM::Image.new(data) }.must_raise PNM::DataError
+    lambda { PNM.create(data) }.must_raise PNM::DataError
   end
 
   it 'raises an exception for invalid PBM data (> 1)' do
     data = [[0, 0], [2, 0]]
-    lambda { PNM::Image.new(data, :type => :pbm) }.must_raise PNM::DataError
+    lambda { PNM.create(data, :type => :pbm) }.must_raise PNM::DataError
   end
 
   it 'raises an exception for invalid PBM data (< 0)' do
     data = [[0, 0], [-1, 0]]
-    lambda { PNM::Image.new(data, :type => :pbm) }.must_raise PNM::DataError
+    lambda { PNM.create(data, :type => :pbm) }.must_raise PNM::DataError
   end
 
   it 'raises an exception for invalid PGM data (> 255)' do
     data = [[0, 0], [1, 500]]
-    lambda { PNM::Image.new(data, :type => :pgm) }.must_raise PNM::DataError
+    lambda { PNM.create(data, :type => :pgm) }.must_raise PNM::DataError
   end
 
   it 'raises an exception for invalid PGM data (> maxgray)' do
     data = [[0, 0], [1, 200]]
-    lambda { PNM::Image.new(data, :maxgray => 100) }.must_raise PNM::DataError
+    lambda { PNM.create(data, :maxgray => 100) }.must_raise PNM::DataError
   end
 end
 

data/test/test_image.rb

@@ -3,7 +3,7 @@
 # Copyright (C) 2013-2014 Marcus Stollsteimer
 
 require 'minitest/autorun'
-require 'pnm/image'
+require 'pnm'
 
 
 describe PNM::Image do
@@ -19,7 +19,7 @@ describe PNM::Image do
               [0,0,1,0,0],
               [0,0,0,0,0]]
     comment = 'Bilevel'
-    @bilevel = PNM::Image.new(pixels, {:comment => comment})
+    @bilevel = PNM.create(pixels, {:comment => comment})
 
     pixels = [[0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0],
               [0,1,1,1,0,1,1,1,1,0,1,1,1,1,1,0],
@@ -27,95 +27,95 @@ describe PNM::Image do
               [0,0,1,0,0,1,0,0,1,0,1,0,1,0,1,0],
               [0,0,1,0,0,1,1,1,1,0,1,0,1,0,1,0],
               [0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0]]
-    @bilevel_2 = PNM::Image.new(pixels)
+    @bilevel_2 = PNM.create(pixels)
 
     pixels = [[  0, 50,100,150],
               [ 50,100,150,200],
               [100,150,200,250]]
     comment = "Grayscale\n(with multiline comment)"
-    @grayscale = PNM::Image.new(pixels, {:maxgray => 250, :comment => comment})
+    @grayscale = PNM.create(pixels, {:maxgray => 250, :comment => comment})
 
     pixels = [[65,66], [13,10], [65,66]]
-    @grayscale_crlf = PNM::Image.new(pixels)
+    @grayscale_crlf = PNM.create(pixels)
 
     pixels = [[[0,6,0], [1,5,1], [2,4,2], [3,3,4], [4,2,6]],
               [[1,5,2], [2,4,2], [3,3,2], [4,2,2], [5,1,2]],
               [[2,4,6], [3,3,4], [4,2,2], [5,1,1], [6,0,0]]]
-    @color = PNM::Image.new(pixels, {:maxgray => 6})
+    @color = PNM.create(pixels, {:maxgray => 6})
   end
 
   it 'sets maxgray to 1 for bilevel images' do
-    image = PNM::Image.new([[0,1,0], [1,0,1]])
+    image = PNM.create([[0,1,0], [1,0,1]])
     image.type.must_equal :pbm
     image.maxgray.must_equal 1
   end
 
   it 'sets maxgray by default to 255 for grayscale images' do
-    image = PNM::Image.new([[0,10,20], [10,20,30]])
+    image = PNM.create([[0,10,20], [10,20,30]])
     image.type.must_equal :pgm
     image.maxgray.must_equal 255
   end
 
   it 'sets maxgray by default to 255 for color images' do
-    image = PNM::Image.new([[[0,0,0], [10,10,10]], [[10,10,10], [20,20,20]]])
+    image = PNM.create([[[0,0,0], [10,10,10]], [[10,10,10], [20,20,20]]])
     image.type.must_equal :ppm
     image.maxgray.must_equal 255
   end
 
   it 'accepts setting of maxgray to 1 for bilevel images' do
-    image = PNM::Image.new([[0,1,0], [1,0,1]], {:maxgray => 1})
+    image = PNM.create([[0,1,0], [1,0,1]], {:maxgray => 1})
     image.type.must_equal :pbm
     image.maxgray.must_equal 1
   end
 
   it 'ignores invalid maxgray for bilevel images and sets it to 1' do
-    image = PNM::Image.new([[0,1,0], [1,0,1]], {:type => :pbm, :maxgray => 255})
+    image = PNM.create([[0,1,0], [1,0,1]], {:type => :pbm, :maxgray => 255})
     image.type.must_equal :pbm
     image.maxgray.must_equal 1
   end
 
   it 'can create a grayscale image from bilevel values (using type)' do
-    image = PNM::Image.new([[0,1,0], [1,0,1]], {:type => :pgm})
+    image = PNM.create([[0,1,0], [1,0,1]], {:type => :pgm})
     image.type.must_equal :pgm
     image.pixels.must_equal [[0,1,0], [1,0,1]]
     image.maxgray.must_equal 255
   end
 
   it 'also accepts types given as string instead of symbol' do
-    image = PNM::Image.new([[0,1,0], [1,0,1]], {:type => "pgm"})
+    image = PNM.create([[0,1,0], [1,0,1]], {:type => "pgm"})
     image.type.must_equal :pgm
   end
 
   it 'can create a grayscale image from bilevel values (using maxgray)' do
-    image = PNM::Image.new([[0,1,0], [1,0,1]], {:maxgray => 2})
+    image = PNM.create([[0,1,0], [1,0,1]], {:maxgray => 2})
     image.type.must_equal :pgm
     image.pixels.must_equal [[0,1,0], [1,0,1]]
     image.maxgray.must_equal 2
   end
 
   it 'can create a color image from bilevel values' do
-    image = PNM::Image.new([[0,1,0], [1,0,1]], {:type => :ppm})
+    image = PNM.create([[0,1,0], [1,0,1]], {:type => :ppm})
     image.info.must_match %r{^PPM 3x2 Color}
     image.pixels.must_equal [[[0,0,0], [1,1,1], [0,0,0]], [[1,1,1], [0,0,0], [1,1,1]]]
     image.maxgray.must_equal 255
   end
 
   it 'can create a color image from bilevel values with a given maxgray' do
-    image = PNM::Image.new([[0,1,0], [1,0,1]], {:type => :ppm, :maxgray => 2})
+    image = PNM.create([[0,1,0], [1,0,1]], {:type => :ppm, :maxgray => 2})
     image.info.must_match %r{^PPM 3x2 Color}
     image.pixels.must_equal [[[0,0,0], [1,1,1], [0,0,0]], [[1,1,1], [0,0,0], [1,1,1]]]
     image.maxgray.must_equal 2
   end
 
   it 'can create a color image from gray values' do
-    image = PNM::Image.new([[0,3,6], [3,6,9]], {:type => :ppm})
+    image = PNM.create([[0,3,6], [3,6,9]], {:type => :ppm})
     image.info.must_match %r{^PPM 3x2 Color}
     image.pixels.must_equal [[[0,0,0], [3,3,3], [6,6,6]], [[3,3,3], [6,6,6], [9,9,9]]]
   end
 
   it 'does not modify the input data for color images created from gray values' do
     data = [[0,3,6], [3,6,9]]
-    PNM::Image.new(data, {:type => :ppm})
+    PNM.create(data, {:type => :ppm})
     data.must_equal [[0,3,6], [3,6,9]]
   end
 
@@ -168,9 +168,9 @@ describe PNM::Image do
   end
 
   it 'can return meaningful debugging information' do
-    @bilevel.inspect.must_match   %r{^#<PNM::Image:0x\h+ PBM 5x6 Bilevel>$}
-    @grayscale.inspect.must_match %r{^#<PNM::Image:0x\h+ PGM 4x3 Grayscale, maxgray=250>$}
-    @color.inspect.must_match     %r{^#<PNM::Image:0x\h+ PPM 5x3 Color, maxgray=6>$}
+    @bilevel.inspect.must_match   %r{^#<PNM::\w+Image:0x\h+ PBM 5x6 Bilevel>$}
+    @grayscale.inspect.must_match %r{^#<PNM::\w+Image:0x\h+ PGM 4x3 Grayscale, maxgray=250>$}
+    @color.inspect.must_match     %r{^#<PNM::\w+Image:0x\h+ PPM 5x3 Color, maxgray=6>$}
   end
 
   it 'can write binary data containing CRLF' do
@@ -187,14 +187,14 @@ describe PNM::Image do
 
   it 'can write zero-length comments' do
     comment = ''
-    PNM::Image.new([[0,0]], :comment => comment).write(@temp_path, :ascii)
+    PNM.create([[0,0]], :comment => comment).write(@temp_path, :ascii)
     File.binread(@temp_path).must_equal "P1\n#\n2 1\n0 0\n"
     File.delete(@temp_path)
   end
 
   it 'can write comments with trailing zero-length line' do
     comment = "An empty line:\n"
-    PNM::Image.new([[0,0]], :comment => comment).write(@temp_path, :ascii)
+    PNM.create([[0,0]], :comment => comment).write(@temp_path, :ascii)
     File.binread(@temp_path).must_equal "P1\n# An empty line:\n#\n2 1\n0 0\n"
     File.delete(@temp_path)
   end

metadata

@@ -1,14 +1,14 @@
 --- !ruby/object:Gem::Specification
 name: pnm
 version: !ruby/object:Gem::Version
-  version: 0.3.4
+  version: 0.4.0
 platform: ruby
 authors:
 - Marcus Stollsteimer
 autorequire: 
 bindir: bin
 cert_chain: []
-date: 2014-11-21 00:00:00.000000000 Z
+date: 2014-12-28 00:00:00.000000000 Z
 dependencies:
 - !ruby/object:Gem::Dependency
   name: rake
@@ -80,7 +80,7 @@ required_rubygems_version: !ruby/object:Gem::Requirement
       version: '0'
 requirements: []
 rubyforge_project: 
-rubygems_version: 2.4.4
+rubygems_version: 2.4.5
 signing_key: 
 specification_version: 4
 summary: PNM - create/read/write PNM image files (PBM, PGM, PPM)