imagesize 0.0.1

data/History.txt

@@ -0,0 +1,4 @@
++++ 0.0.1 2007-04-19
+
++ 1 major enhancement:
+  + Initial release

data/Manifest.txt

@@ -0,0 +1,28 @@
+History.txt
+Manifest.txt
+README.txt
+Rakefile
+lib/image_size.rb
+lib/image_size/version.rb
+lib/image_size/image_size.rb
+scripts/txt2html
+setup.rb
+test/test_helper.rb
+test/test_image_size.rb
+test/2-4-7.png
+test/4_1_2.gif
+test/bmp.bmp
+test/cursor.xbm
+test/detect.swf
+test/pbm.pbm
+test/pcx.pcx
+test/pgm.pgm
+test/test.xpm
+test/tiff.tiff
+test/tokyo_tower.jpg
+test/tower_e.gif.psd
+website/index.html
+website/index.txt
+website/javascripts/rounded_corners_lite.inc.js
+website/stylesheets/screen.css
+website/template.rhtml

data/README.txt

@@ -0,0 +1,3 @@
+README for imagesize
+====================
+

data/Rakefile

@@ -0,0 +1,97 @@
+require 'rubygems'
+require 'rake'
+require 'rake/clean'
+require 'rake/testtask'
+require 'rake/packagetask'
+require 'rake/gempackagetask'
+require 'rake/rdoctask'
+require 'rake/contrib/rubyforgepublisher'
+require 'fileutils'
+require 'hoe'
+include FileUtils
+require File.join(File.dirname(__FILE__), 'lib', 'image_size', 'version')
+
+AUTHOR = 'Keisuke Minami'  # can also be an array of Authors
+EMAIL = "keisuke@rccn.com"
+DESCRIPTION = "measure image size(GIF, PNG, JPEG ,,, etc)"
+GEM_NAME = 'imagesize' # what ppl will type to install your gem
+RUBYFORGE_PROJECT = 'imagesize' # The unix name for your project
+HOMEPATH = "http://#{RUBYFORGE_PROJECT}.rubyforge.org"
+
+
+NAME = "imagesize"
+REV = nil # UNCOMMENT IF REQUIRED: File.read(".svn/entries")[/committed-rev="(d+)"/, 1] rescue nil
+VERS = ENV['VERSION'] || (Imagesize::VERSION::STRING + (REV ? ".#{REV}" : ""))
+CLEAN.include ['**/.*.sw?', '*.gem', '.config', '**/.DS_Store']
+RDOC_OPTS = ['--quiet', '--title', 'imagesize documentation',
+    "--opname", "index.html",
+    "--line-numbers", 
+    "--main", "README",
+    "--inline-source"]
+
+class Hoe
+  def extra_deps 
+    @extra_deps.reject { |x| Array(x).first == 'hoe' } 
+  end 
+end
+
+# Generate all the Rake tasks
+# Run 'rake -T' to see list of generated tasks (from gem root directory)
+hoe = Hoe.new(GEM_NAME, VERS) do |p|
+  p.author = AUTHOR 
+  p.description = DESCRIPTION
+  p.email = EMAIL
+  p.summary = DESCRIPTION
+  p.url = HOMEPATH
+  p.rubyforge_name = RUBYFORGE_PROJECT if RUBYFORGE_PROJECT
+  p.test_globs = ["test/**/test_*.rb"]
+  p.clean_globs = CLEAN  #An array of file patterns to delete on clean.
+  
+  # == Optional
+  p.changes = p.paragraphs_of("History.txt", 0..1).join("\n\n")
+  #p.extra_deps = []     # An array of rubygem dependencies [name, version], e.g. [ ['active_support', '>= 1.3.1'] ]
+  #p.spec_extras = {}    # A hash of extra values to set in the gemspec.
+end
+
+
+desc 'Generate website files'
+task :website_generate do
+  Dir['website/**/*.txt'].each do |txt|
+    sh %{ ruby scripts/txt2html #{txt} > #{txt.gsub(/txt$/,'html')} }
+  end
+end
+
+desc 'Upload website files to rubyforge'
+task :website_upload do
+  config = YAML.load(File.read(File.expand_path("~/.rubyforge/user-config.yml")))
+  host = "#{config["username"]}@rubyforge.org"
+  remote_dir = "/var/www/gforge-projects/#{RUBYFORGE_PROJECT}/"
+  # remote_dir = "/var/www/gforge-projects/#{RUBYFORGE_PROJECT}/#{GEM_NAME}"
+  local_dir = 'website'
+  sh %{rsync -av #{local_dir}/ #{host}:#{remote_dir}}
+end
+
+desc 'Generate and upload website files'
+task :website => [:website_generate, :website_upload]
+
+
+
+### ここから持ってきた設定
+### http://d.hatena.ne.jp/secondlife/20061106/1162785661
+Rake::RDocTask.new do |rdoc|
+  rdoc.rdoc_dir = 'html'
+  rdoc.options += RDOC_OPTS
+  rdoc.template = "#{ENV['template']}.rb" if ENV['template']
+  if ENV['DOC_FILES']
+    rdoc.rdoc_files.include(ENV['DOC_FILES'].split(/,\s*/))
+  else
+#    rdoc.rdoc_files.include('README', 'CHANGELOG')
+    rdoc.rdoc_files.include('README.txt')
+    rdoc.rdoc_files.include('lib/**/*.rb')
+  end
+end
+
+desc "Publish to RubyForge"
+task :rubyforge => [:rdoc, :package] do
+  Rake::RubyForgePublisher.new(RUBYFORGE_PROJECT, 'gawgaw61').upload
+end

data/lib/image_size.rb

@@ -0,0 +1,5 @@
+#Dir[File.join(File.dirname(__FILE__), 'imagesize/**/*.rb')].sort.each { |lib| require lib }
+
+require 'image_size/image_size.rb'
+require 'image_size/version.rb'
+

data/lib/image_size/image_size.rb

@@ -0,0 +1,284 @@
+#!ruby
+
+class ImageSize
+# Image Type Constants
+	module Type
+		OTHER = "OTHER"
+		GIF  = "GIF"
+		PNG  = "PNG"
+		JPEG = "JPEG"
+		BMP  = "BMP"
+		PPM  = "PPM" # PPM is like PBM, PGM, & XV
+		PBM  = "PBM"
+		PGM  = "PGM"
+#		XV   = "XV"
+		XBM  = "XBM"
+		TIFF = "TIFF"
+		XPM  = "XPM"
+		PSD  = "PSD"
+		PCX  = "PCX"
+		SWF  = "SWF"
+	end
+
+	JpegCodeCheck = [
+		"\xc0", "\xc1", "\xc2", "\xc3",
+		"\xc5", "\xc6", "\xc7",
+		"\xc9", "\xca", "\xcb",
+		"\xcd", "\xce", "\xcf",
+	]
+
+# image type list
+	def ImageSize.type_list
+		Type.constants 
+	end
+
+# receive image & make size
+# argument is image String or IO
+	def initialize(img_data, img_type = nil)
+		@img_data = img_data.dup
+		@img_wedth = nil
+		@img_height = nil
+
+		if @img_data.is_a?(IO)
+			@img_top = @img_data.read(128)
+			@img_data.seek(0, 0)
+# define Singleton-method definition to IO (byte, offset)
+			def @img_data.read_o(length = 1, offset = nil)
+				self.seek(offset, 0) if offset
+				ret = self.read(length)
+				raise "cannot read!!" unless ret
+				ret
+			end
+		elsif @img_data.is_a?(String)
+			@img_top = @img_data[0, 128]
+# define Singleton-method definition to String (byte, offset)
+			def @img_data.read_o(length = 1, offset = nil)
+				@img_offset = 0 if !(defined?(@img_offset))
+				@img_offset = offset if offset
+				ret = self[@img_offset, length]
+				@img_offset += length
+				ret
+			end
+		else
+			raise "argument class error!! #{img_data.type}"
+		end
+
+		if img_type.nil?
+			@img_type = check_type()
+		else
+			match = false
+			Type.constants.each do |t|
+				match = true if img_type == t
+			end
+			raise("img_type is failed. #{img_type}\n") if match == false
+			@img_type = img_type
+		end
+
+		eval("@img_width, @img_height = measure_" + @img_type + "()") if @img_type != Type::OTHER
+	end
+
+# get parameter
+	def get_type; @img_type; end
+	def get_height
+		if @img_type == Type::OTHER then nil else @img_height end
+	end
+	def get_width
+		if @img_type == Type::OTHER then nil else @img_width end
+	end
+
+	def check_type()
+		if @img_top =~ /^GIF8[7,9]a/                      then Type::GIF
+		elsif @img_top[0, 8] == "\x89PNG\x0d\x0a\x1a\x0a" then Type::PNG
+		elsif @img_top[0, 2] == "\xFF\xD8"                then Type::JPEG
+		elsif @img_top[0, 2] == 'BM'                      then Type::BMP
+		elsif @img_top =~ /^P[1-7]/                       then Type::PPM
+		elsif @img_top =~ /\#define\s+\S+\s+\d+/          then Type::XBM
+		elsif @img_top[0, 4] == "MM\x00\x2a"              then Type::TIFF
+		elsif @img_top[0, 4] == "II\x2a\x00"              then Type::TIFF
+		elsif @img_top =~ /\/\* XPM \*\//                 then Type::XPM
+		elsif @img_top[0, 4] == "8BPS"                    then Type::PSD
+		elsif @img_top[1, 2] == "WS"                      then Type::SWF
+		elsif @img_top[0] == 10                           then Type::PCX
+		else Type::OTHER
+		end
+	end
+	private(:check_type)
+
+	def measure_GIF()
+		@img_data.read_o(6)
+		@img_data.read_o(4).unpack('vv')
+	end
+	private(:measure_GIF)
+
+	def measure_PNG()
+		@img_data.read_o(12)
+		raise "This file is not PNG." unless @img_data.read_o(4) == "IHDR"
+		@img_data.read_o(8).unpack('NN')
+	end
+	private(:measure_PNG)
+
+	def measure_JPEG()
+		c_marker = "\xFF"   # Section marker.
+		@img_data.read_o(2)
+		while(true)
+			marker, code, length = @img_data.read_o(4).unpack('aan')
+			raise "JPEG marker not found!" if marker != c_marker
+
+			if JpegCodeCheck.include?(code)
+				height, width = @img_data.read_o(5).unpack('xnn')
+				return([width, height])
+			end
+			@img_data.read_o(length - 2)
+		end
+	end
+	private(:measure_JPEG)
+
+	def measure_BMP()
+		@img_data.read_o(26).unpack("x18VV");
+	end
+	private(:measure_BMP)
+
+	def measure_PPM()
+		header = @img_data.read_o(1024)
+		header.gsub!(/^\#[^\n\r]*/m, "")
+		header =~ /^(P[1-6])\s+?(\d+)\s+?(\d+)/m
+		width = $2.to_i; height = $3.to_i
+		case $1
+			when "P1", "P4" then @img_type = "PBM"
+			when "P2", "P5" then @img_type = "PGM"
+			when "P3", "P6" then @img_type = "PPM"
+#			when "P7"
+#				@img_type = "XV"
+#				header =~ /IMGINFO:(\d+)x(\d+)/m
+#				width = $1.to_i; height = $2.to_i
+		end
+		[width, height]
+	end
+	private(:measure_PPM)
+
+	alias :measure_PGM :measure_PPM
+	private(:measure_PGM)
+	alias :measure_PBM :measure_PPM
+	private(:measure_PBM)
+
+	def measure_XBM()
+		@img_data.read_o(1024) =~ /^\#define\s*\S*\s*(\d+)\s*\n\#define\s*\S*\s*(\d+)/mi
+		[$1.to_i, $2.to_i]
+	end
+	private(:measure_XBM)
+
+	def measure_XPM()
+		width = height = nil
+		while(line = @img_data.read_o(1024))
+			if line =~ /"\s*(\d+)\s+(\d+)(\s+\d+\s+\d+){1,2}\s*"/m
+				width = $1.to_i; height = $2.to_i
+				break
+			end
+		end
+		[width, height]
+	end
+	private(:measure_XPM)
+
+	def measure_PSD()
+		@img_data.read_o(26).unpack("x14NN")
+	end
+	private(:measure_PSD)
+
+	def measure_TIFF()
+		endian = if (@img_data.read_o(4) =~ /II\x2a\x00/o) then 'v' else 'n' end
+# 'v' little-endian   'n' default to big-endian
+
+		packspec = [
+			nil,           # nothing (shouldn't happen)
+			'C',           # BYTE (8-bit unsigned integer)
+			nil,           # ASCII
+			endian,        # SHORT (16-bit unsigned integer)
+			endian.upcase, # LONG (32-bit unsigned integer)
+			nil,           # RATIONAL
+			'c',           # SBYTE (8-bit signed integer)
+			nil,           # UNDEFINED
+			endian,        # SSHORT (16-bit unsigned integer)
+			endian.upcase, # SLONG (32-bit unsigned integer)
+		]
+
+		offset = @img_data.read_o(4).unpack(endian.upcase)[0] # Get offset to IFD
+
+		ifd = @img_data.read_o(2, offset)
+		num_dirent = ifd.unpack(endian)[0]                   # Make it useful
+		offset += 2
+		num_dirent = offset + (num_dirent * 12);             # Calc. maximum offset of IFD
+
+		ifd = width = height = nil
+		while(width.nil? || height.nil?)
+			ifd = @img_data.read_o(12, offset)                 # Get first directory entry
+			break if (ifd.nil? || (offset > num_dirent))
+			offset += 12
+			tag = ifd.unpack(endian)[0]                       # ...and decode its tag
+			type = ifd[2, 2].unpack(endian)[0]                # ...and the data type
+
+     # Check the type for sanity.
+			next if (type > packspec.size + 0) || (packspec[type].nil?)
+			if tag == 0x0100                                  # Decode the value
+				width = ifd[8, 4].unpack(packspec[type])[0]
+			elsif tag == 0x0101                               # Decode the value
+				height = ifd[8, 4].unpack(packspec[type])[0]
+			end
+		end
+
+		raise "#{if width.nil? then 'width not defined.' end} #{if height.nil? then 'height not defined.' end}" if width.nil? || height.nil?
+		[width, height]
+	end
+	private(:measure_TIFF)
+
+	def measure_PCX()
+		header = @img_data.read_o(128)
+		head_part = header.unpack('C4S4')
+		width = head_part[6] - head_part[4] + 1
+		height = head_part[7] - head_part[5] + 1
+		[width, height]
+	end
+	private(:measure_PCX)
+
+	def measure_SWF()
+		header = @img_data.read_o(9)
+		
+		sig1 = header[0,1]
+		sig2 = header[1,1]
+		sig3 = header[2,1]
+
+		if !((sig1 == 'F' || sig1 == 'C') && sig2 == 'W' && sig3 == 'S')
+			raise("This file is not SWF.")
+		end
+
+		bit_length = Integer("0b#{header.unpack('@8B5')}")
+		header << @img_data.read_o(bit_length*4/8+1)
+		str = header.unpack("@8B#{5+bit_length*4}")[0]
+		last = 5
+		x_min = Integer("0b#{str[last,bit_length]}")
+		x_max = Integer("0b#{str[(last += bit_length),bit_length]}")
+		y_min = Integer("0b#{str[(last += bit_length),bit_length]}")
+		y_max = Integer("0b#{str[(last += bit_length),bit_length]}")
+		width = (x_max - x_min)/20
+		height = (y_max - y_min)/20
+		[width, height]
+	end
+	private(:measure_PCX)
+end
+
+
+if __FILE__ == $0
+	print "TypeList: #{ImageSize.type.inspect}\n"
+
+	Dir.glob("*").each do |file|
+		print "#{file} (string)\n"
+		open(file, "rb") do |fh|
+			img = ImageSize.new(fh.read)
+			print <<-EOF
+type:   #{img.get_type.inspect}
+width:  #{img.get_width.inspect}
+height: #{img.get_height.inspect}
+			EOF
+		end
+	end
+end
+

data/lib/image_size/version.rb

@@ -0,0 +1,9 @@
+module Imagesize #:nodoc:
+  module VERSION #:nodoc:
+    MAJOR = 0
+    MINOR = 0
+    TINY  = 1
+
+    STRING = [MAJOR, MINOR, TINY].join('.')
+  end
+end

data/scripts/txt2html

@@ -0,0 +1,67 @@
+#!/usr/bin/env ruby
+
+require 'rubygems'
+require 'redcloth'
+require 'syntax/convertors/html'
+require 'erb'
+require File.dirname(__FILE__) + '/../lib/image_size/version.rb'
+
+version  = Imagesize::VERSION::STRING
+download = 'http://rubyforge.org/projects/imagesize'
+
+class Fixnum
+  def ordinal
+    # teens
+    return 'th' if (10..19).include?(self % 100)
+    # others
+    case self % 10
+    when 1: return 'st'
+    when 2: return 'nd'
+    when 3: return 'rd'
+    else    return 'th'
+    end
+  end
+end
+
+class Time
+  def pretty
+    return "#{mday}#{mday.ordinal} #{strftime('%B')} #{year}"
+  end
+end
+
+def convert_syntax(syntax, source)
+  return Syntax::Convertors::HTML.for_syntax(syntax).convert(source).gsub(%r!^<pre>|</pre>$!,'')
+end
+
+if ARGV.length >= 1
+  src, template = ARGV
+  template ||= File.dirname(__FILE__) + '/../website/template.rhtml'
+  
+else
+  puts("Usage: #{File.split($0).last} source.txt [template.rhtml] > output.html")
+  exit!
+end
+
+template = ERB.new(File.open(template).read)
+
+title = nil
+body = nil
+File.open(src) do |fsrc|
+  title_text = fsrc.readline
+  body_text = fsrc.read
+  syntax_items = []
+  body_text.gsub!(%r!<(pre|code)[^>]*?syntax=['"]([^'"]+)[^>]*>(.*?)</
>!m){
+    ident = syntax_items.length
+    element, syntax, source = $1, $2, $3
+    syntax_items << "<#{element} class='syntax'>#{convert_syntax(syntax, source)}</#{element}>"
+    "syntax-temp-#{ident}"
+  }
+  title = RedCloth.new(title_text).to_html.gsub(%r!<.*?>!,'').strip
+  body = RedCloth.new(body_text).to_html
+  body.gsub!(%r!(?:<pre><code>)?syntax-temp-(d+)(?:</code></pre>)?!){ syntax_items[$1.to_i] }
+end
+stat = File.stat(src)
+created = stat.ctime
+modified = stat.mtime
+
+$stdout << template.result(binding)