flash_tool 0.5.0

data/.gitignore

@@ -0,0 +1,8 @@
+pkg
+nbproject
+doc
+coverage
+ 
+pkg
+.loadpath
+.project

data/MIT-LICENSE

@@ -0,0 +1,20 @@
+Copyright (c) 2010 Bojan Milosavljević milboj@gmail.com
+
+Permission is hereby granted, free of charge, to any person obtaining
+a copy of this software and associated documentation files (the
+"Software"), to deal in the Software without restriction, including
+without limitation the rights to use, copy, modify, merge, publish,
+distribute, sublicense, and/or sell copies of the Software, and to
+permit persons to whom the Software is furnished to do so, subject to
+the following conditions:
+
+The above copyright notice and this permission notice shall be
+included in all copies or substantial portions of the Software.
+
+THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND,
+EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF
+MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND
+NONINFRINGEMENT. IN NO EVENT SHALL THE AUTHORS OR COPYRIGHT HOLDERS BE
+LIABLE FOR ANY CLAIM, DAMAGES OR OTHER LIABILITY, WHETHER IN AN ACTION
+OF CONTRACT, TORT OR OTHERWISE, ARISING FROM, OUT OF OR IN CONNECTION
+WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE SOFTWARE.

data/README.rdoc

@@ -0,0 +1,91 @@
+= Flash Tool
+
+A ruby wrapper for swftool command line tool. http://www.swftools.org/
+
+Flash tool is small and mini tool for creating swf files from pdfs, pictures and
+fonts and parsing data from flash files.
+
+== Use
+
+With this wrapper you commands from swftools program.
+
+SWFTools is a collection of utilities for working with Adobe Flash files.
+With Flash tool you can easely creates and manipulates flash files.
+
+== Creating flash files
+
+With Flash tool you can create swf file from pdf, jpeg (jpeg and jpg extension),
+png, gif, fonts (ttf, afm,  pfa, pfb formats) and wav(this funcionality is untested
+and you can often have problems with SWFTools installation with command wav2swf)
+
+Simple creating flash object from pdf file
+
+ swfile = FlashObject.new('path_to_file.pdf')
+ swfile.pages('1-10')
+ swfile.jpegquality('80')
+ swfile.save('outputfile_path.swf') # no need to declare ouptutfile_path in save if you used swfile.output() method before
+
+Creating file from other format is very similar
+
+Example for jpg
+
+ swfile = FlashObject.new('path_to_file.jpg')
+ swfile.output('outputfile_path.swf')
+ swfile.save()
+
+Flash tool automaticly recognize extension of file and call propriete SWFTool program
+If you use files without extension you just simply add string of extension when
+initialize FlashObject
+
+ swfile = FlashObject.new('path_to_file','jpg')
+
+You can use tempfile
+
+ swfile = FlashOject.from_blob('path_to_file','jpg')
+
+Creating flash with viewer
+
+ swfile = FlashObject.new('path_to_file.pdf')
+ swfile.pages('1-10')
+ swfile.viewer('path_to_viewer_file')
+ swfile.save('outputfile_path.swf')
+
+SWFTool command will be called when you save object.
+
+==Parsing text from file
+
+It is very simple
+
+ FlashTool.parse_text('path_to_file.swf')
+
+==Geting data from flash files
+
+You can get data from flash files with swfdump tool
+
+ FlashTool.swfdump('path_to_file.swf', 'command') #use swfdump options http://www.swftools.org/swfdump.html
+
+Don't use option text it is buggy, instead use method FlashTool.parse_text
+With method swfdump output is string
+
+Better way
+
+ FlashTool.(command) List of command can get from http://www.swftools.org/swfdump.html
+
+Examples
+ FlashTool.rate(file)   #return Float
+ FlashTool.width(file)  #return Integer
+ FlashTool.height(file) #return Integer
+ FlashTool.frames(file) #return Integer
+
+Other methods returns String
+
+All this methods call commands swfdump, every time you call method. If you want
+to do it in one pass use
+
+ FlashTool.flash_info(file)
+
+Returns hash with keys 'width', 'rate', 'height', 'frames', and all values are strings
+
+
+
+

data/Rakefile

@@ -0,0 +1,63 @@
+require 'rubygems'
+require 'rake'
+
+begin
+  require 'jeweler'
+  Jeweler::Tasks.new do |gem|
+    gem.name = "flash_tool"
+    gem.summary = "Simple and mini tool for creating swf (flash) files from pdf, jpg, png and gif with swftools"
+    gem.description = "A ruby wrapper for swftool command line tool. http://www.swftools.org/ 
+Flash tool is small and mini tool for creating swf files from pdfs, pictures and
+fonts and parsing data from flash files."
+    gem.email = "milboj@gmail.com"
+    gem.homepage = "http://github.com/milboj/flash_tool"
+    gem.authors = ["Bojan Milosavljevic"]
+    gem.rubyforge_project = 'flashtool'
+
+
+#   gem.add_development_dependency "", ">= 0"
+    # gem is a Gem::Specification... see http://www.rubygems.org/read/chapter/20 for additional settings
+  end
+  Jeweler::GemcutterTasks.new
+  Jeweler::RubyforgeTasks.new do |rubyforge|
+    rubyforge.doc_task = "rdoc"
+  end
+rescue LoadError
+  puts "Jeweler (or a dependency) not available. Install it with: gem install jeweler"
+end
+
+require 'rake/testtask'
+Rake::TestTask.new(:test) do |test|
+  test.libs << 'lib' << 'test'
+  test.pattern = 'test/test_*.rb'
+  test.verbose = true
+end
+
+begin
+  require 'rcov/rcovtask'
+  Rcov::RcovTask.new do |test|
+    test.libs << 'test'
+    test.pattern = 'test/test_*.rb'
+    test.verbose = true
+  end
+rescue LoadError
+  task :rcov do
+    abort "RCov is not available. In order to run rcov, you must: sudo gem install spicycode-rcov"
+  end
+end
+
+
+task :test => :check_dependencies
+
+task :default => :test
+
+require 'rake/rdoctask'
+Rake::RDocTask.new do |rdoc|
+  version = File.exist?('VERSION') ? File.read('VERSION') : ""
+
+  rdoc.rdoc_dir = 'rdoc'
+  rdoc.title = "flash_tool #{version}"
+  rdoc.rdoc_files.include('README*')
+  rdoc.rdoc_files.include('lib/*.rb')
+end
+

data/VERSION

@@ -0,0 +1 @@
+0.5.0

data/flash_tool.gemspec

@@ -0,0 +1,65 @@
+# Generated by jeweler
+# DO NOT EDIT THIS FILE DIRECTLY
+# Instead, edit Jeweler::Tasks in Rakefile, and run the gemspec command
+# -*- encoding: utf-8 -*-
+
+Gem::Specification.new do |s|
+  s.name = %q{flash_tool}
+  s.version = "0.5.0"
+
+  s.required_rubygems_version = Gem::Requirement.new(">= 0") if s.respond_to? :required_rubygems_version=
+  s.authors = ["Bojan Milosavljevic"]
+  s.date = %q{2010-03-20}
+  s.description = %q{A ruby wrapper for swftool command line tool. http://www.swftools.org/ 
+Flash tool is small and mini tool for creating swf files from pdfs, pictures and
+fonts and parsing data from flash files.}
+  s.email = %q{milboj@gmail.com}
+  s.extra_rdoc_files = [
+    "README.rdoc"
+  ]
+  s.files = [
+    ".gitignore",
+     ".loadpath",
+     ".project",
+     "MIT-LICENSE",
+     "README.rdoc",
+     "Rakefile",
+     "VERSION",
+     "flash_tool.gemspec",
+     "lib/flash_tool.rb",
+     "test/25-1.gif",
+     "test/bad_ext.txt",
+     "test/bad_swf.swf",
+     "test/jpeg.swf",
+     "test/liberationserif_bold.ttf",
+     "test/rfxview.swf",
+     "test/test.jpg",
+     "test/test.pdf",
+     "test/test.png",
+     "test/test_flash_data.rb",
+     "test/test_flash_tool.rb",
+     "test/test_with_password.pdf",
+     "test/tester.swf"
+  ]
+  s.homepage = %q{http://github.com/milboj/flash_tool}
+  s.rdoc_options = ["--charset=UTF-8"]
+  s.require_paths = ["lib"]
+  s.rubyforge_project = %q{flashtool}
+  s.rubygems_version = %q{1.3.6}
+  s.summary = %q{Simple and mini tool for creating swf (flash) files from pdf, jpg, png and gif with swftools}
+  s.test_files = [
+    "test/test_flash_tool.rb",
+     "test/test_flash_data.rb"
+  ]
+
+  if s.respond_to? :specification_version then
+    current_version = Gem::Specification::CURRENT_SPECIFICATION_VERSION
+    s.specification_version = 3
+
+    if Gem::Version.new(Gem::RubyGemsVersion) >= Gem::Version.new('1.2.0') then
+    else
+    end
+  else
+  end
+end
+

data/lib/flash_tool.rb

@@ -0,0 +1,195 @@
+require 'tempfile'
+
+module FlashTool
+  class FlashToolError < RuntimeError
+  end
+
+  # Creating flash swf files from pdf, jpg, png, gif and fonts file
+  class FlashObject
+    attr :input
+    attr :type
+    attr :args
+
+    # Input is path file with good extesnion
+    # Approved formats are :
+    # *pdf,
+    # *jpeg (jpeg and jpg extension),
+    # *png,
+    # *gif,
+    # *fonts (ttf, afm,  pfa, pfb formats) and
+    # *wav (wav funcionality is untested and you can often have problems with SWFTools installation with command wav2swf)
+    #
+    # type - is extension name string if your input file have other extension
+    #
+    # == Example
+    #  flash = FlashOjbect.new('path_to_file', 'png')
+    #
+    # Raise exceptions
+    def initialize(input,type = nil, tempfile = nil)
+      @args = []
+      @tempfile = tempfile
+      @input = input
+      @type = type || input.split('.').last
+      @command = type_parser(@type)
+
+      raise FlashToolError, "File not found" unless File.exist?(input)
+    end
+
+
+    def self.from_blob(blob, ext)
+      begin
+        tempfile = Tempfile.new(['swf_tool', ext.to_s])
+        tempfile.binmode
+        tempfile.write(blob)
+      ensure
+        tempfile.close if tempfile
+      end
+
+      return self.new(tempfile.path, ext ,tempfile)
+    end
+
+    #
+    def save(output_path=nil)
+      if output_path
+        @args << "--output"
+        @args << output_path
+      end
+      run_command(@command,*@args << @input)
+    end
+
+    
+
+
+    def method_missing(symbol, *args)
+      @args << ("--#{symbol}")
+      @args +=(args)
+    end
+
+    private
+
+    def type_parser input
+      case input.downcase
+      when "pdf"
+        command = "pdf2swf"
+      when "jpg", "jpeg"
+        command = "jpeg2swf"
+      when "png"
+        command = "png2swf"
+      when "gif"
+        command = "gif2swf"
+      when "ttf", "afm",  "pfa", "pfb"
+        command = "font2swf"
+      when "wav"
+        command = "wav2swf"
+      else
+        raise FlashToolError, "Invalid type"
+      end
+      return command
+    end
+
+    def +(value)
+      @args << "+#{value}"
+    end
+
+    
+    def run_command(command ,*args)
+      args.collect! do |arg|
+        # args can contain characters like '>' so we must escape them, but don't quote switches
+        if arg !~ /^[\+\-]/
+          "\"#{arg}\""
+        else
+          arg.to_s
+        end
+      end
+      command = "#{command} #{args.join(" ")}"
+      output = `#{command} 2>&1`
+
+      if $?.exitstatus != 0
+        raise FlashToolError, "SWF command (#{command.inspect}) failed: #{{:status_code => $?, :output => output}.inspect}"
+      else
+        output
+      end
+    end
+    
+  
+  end
+
+
+
+
+  # This method parse text from swf file.
+  # File must have extension swf
+  def FlashTool.parse_text(file)
+    # something is bad with this program don't send errors, and ther is no need to check for errors
+    # we must check file first
+    # by documetation swfdump --text need to do this but
+    raise FlashToolError, "File missing path: #{file}" unless File.exist?(file)
+    raise FlashToolError, "Wrong file type SWF path: #{file} "  unless file =~ /(.swf)$/i
+    command = "swfstrings #{file}"
+    output = `#{command} 2>&1`
+    # if file have appropiate name but is something is wrong with him
+    raise FlashToolError, output if output =~/(errors.)$/
+    return output
+  end
+
+  def FlashTool.method_missing(option, file)
+    text = self.swfdump(file, option)
+    option = option.to_s
+    if option == "width" || option == 'height' || option == 'frames'
+      return text.split(' ').last.to_i
+    elsif option == 'rate'
+      return text.split(' ').last.to_f
+    else
+      return text
+    end
+  end
+
+  ###
+  # Returns hash value with basic flash parameters
+  # Keys are [width, rate, height, frames] and
+  # values are kind of string
+  def FlashTool.flash_info(file)
+    args = ['width', 'rate', 'height', 'frames']
+    data = swfdump(file, args)
+    data.gsub!(/(-X)/, "width ")
+    data.gsub!(/(-Y)/, "height ")
+    data.gsub!(/(-r)/, "rate ")
+    data.gsub!(/(-f)/, "frames ")
+
+    return Hash[*data.split(' ')]
+
+  end
+
+
+  ###
+  # This  method is very similar to swfdump command http://www.swftools.org/swfdump.html
+  # Use longer options for this commands without --
+  # DON'T use option text that option don't work
+  # ==Examples
+  #  FlashTool.swfdump('test.swf', 'rate')
+  #
+  #  FlashTool.swfdump('test.swf', ['rate','width','height']
+  def FlashTool.swfdump(file, option=nil)
+    command = 'swfdump'
+    if option
+      if option.kind_of? Array
+        option.collect! { |a|   "--#{a}" }
+        option = option.join(' ')
+      else
+        option = "--#{option}"
+      end
+    end
+
+    command = "#{command} #{option} #{file}"
+
+    output = `#{command} 2>&1`
+    if $?.exitstatus != 0
+      raise FlashToolError, "SWF command : #{command.inspect} failed : #{{:status_code => $?, :output => output}.inspect}"
+    else
+      return output
+    end
+  end
+end
+
+
+

data/test/bad_ext.txt

@@ -0,0 +1 @@
+Just for test 

data/test/test_flash_data.rb

@@ -0,0 +1,69 @@
+# To change this template, choose Tools | Templates
+# and open the template in the editor.
+
+require File.join(File.dirname(__FILE__), '../lib/flash_tool.rb')
+
+require 'test/unit'
+
+class Test_Flash_Data < Test::Unit::TestCase
+  include FlashTool
+  CURRENT_DIR = File.dirname(File.expand_path(__FILE__)) + "/"
+  TEST_SWF = CURRENT_DIR + "tester.swf"
+  BAD_FILE = CURRENT_DIR + "bad_ext.txt"
+  JPG_SWF = CURRENT_DIR + "jpeg.swf"
+  NO_FILE = CURRENT_DIR + "jpegswf.swf"
+  BAD_SWF = CURRENT_DIR + "bad_swf.swf"
+  
+  def test_get_info
+    info =  FlashTool.flash_info(TEST_SWF)
+    assert_kind_of Hash, info
+  end
+
+  def test_missing_methods
+    assert_kind_of(Integer, FlashTool.width(TEST_SWF))
+    assert_kind_of(Integer, FlashTool.height(TEST_SWF))
+    assert_kind_of(Integer, FlashTool.frames(TEST_SWF))
+    assert_kind_of(Float, FlashTool.rate(TEST_SWF))
+    assert_kind_of(String, FlashTool.html(TEST_SWF))
+    assert_kind_of(String, FlashTool.xhtml(TEST_SWF))
+    assert_kind_of(String, FlashTool.full(TEST_SWF))
+    assert_kind_of(String, FlashTool.hex(TEST_SWF))
+    assert_kind_of(String, FlashTool.buttons(TEST_SWF))
+    assert_kind_of(String, FlashTool.placements(TEST_SWF))
+    assert_kind_of(String, FlashTool.fonts(TEST_SWF))
+
+  end
+
+  def test_bad_file
+
+    assert_raise(FlashToolError) { FlashTool.flash_info(BAD_FILE) }
+    assert_raise(FlashToolError) { FlashTool.full(BAD_FILE) }
+    assert_raise(FlashToolError) { FlashTool.width(BAD_FILE) }
+    assert_raise(FlashToolError) { FlashTool.parse_text(BAD_FILE) }
+    assert_raise(FlashToolError) { FlashTool.swfdump(BAD_FILE, 'width') }
+  end
+
+  def test_no_file
+
+    assert_raise(FlashToolError) { FlashTool.flash_info(NO_FILE) }
+    assert_raise(FlashToolError) { FlashTool.full(NO_FILE) }
+    assert_raise(FlashToolError) { FlashTool.width(NO_FILE) }
+    assert_raise(FlashToolError) { FlashTool.parse_text(NO_FILE) }
+    assert_raise(FlashToolError) { FlashTool.swfdump(NO_FILE, 'width') }
+  end
+
+  # Testing bad swf
+  def test_bad_swf_file
+
+    assert_raise(FlashToolError) { FlashTool.flash_info(BAD_SWF) }
+    assert_raise(FlashToolError) { FlashTool.full(BAD_SWF) }
+    assert_raise(FlashToolError) { FlashTool.width(BAD_SWF) }
+    assert_raise(FlashToolError) { FlashTool.parse_text(BAD_SWF) }
+    assert_raise(FlashToolError) { FlashTool.swfdump(BAD_SWF, 'width') }
+  end
+
+  def test_parse_text
+    assert_equal "",FlashTool.parse_text(JPG_SWF) #image flash
+    assert_true(FlashTool.parse_text(TEST_SWF).length > 100 ) #test number of charachters
+  end
+end

data/test/test_flash_tool.rb

@@ -0,0 +1,162 @@
+# To change this template, choose Tools | Templates
+# and open the template in the editor.
+
+require 'test/unit'
+require File.join(File.dirname(__FILE__), '../lib/flash_tool.rb')
+
+class FlashToolsTest < Test::Unit::TestCase
+  include FlashTool
+
+  CURRENT_DIR = File.dirname(File.expand_path(__FILE__)) + "/"
+
+  PDF_FILE  = CURRENT_DIR + "test.pdf"
+  PDF_PASSW_PROTECTED = CURRENT_DIR + "test_with_password.pdf"
+  GIF_FILE  = CURRENT_DIR + "25-1.gif"
+  FONT_FILE = CURRENT_DIR + "liberationserif_bold.ttf"
+  JPG_FILE  = CURRENT_DIR + "test.jpg"
+  PNG_FILE  = CURRENT_DIR + "test.png"
+  VIEW_SWF  = CURRENT_DIR + "rfxview.swf"
+
+
+
+  def test_flash_object_from_blob
+    File.open(JPG_FILE, "rb") do |f|
+      flash_object = FlashObject.from_blob(f.read, 'jpg')
+    end
+  end
+
+
+  def test_flash_object_new
+    flash_object = FlashObject.new(JPG_FILE)
+  end
+
+  #
+  # Testing file type detection and creation by file type
+  #
+  #
+
+  def test_pdf_create
+    begin
+      output_file = "#{CURRENT_DIR}/test.swf"
+      flash_object = FlashObject.new(PDF_FILE)
+      flash_object.jpegquality(80)
+      flash_object.save(output_file)
+
+      assert(File.exist?(output_file))
+    ensure
+      File.delete(output_file)
+    end
+  end
+  def test_pdf_create_with_password
+    output_file = "#{CURRENT_DIR}/test_password.swf"
+    begin
+      flash_object = FlashObject.new(PDF_PASSW_PROTECTED)
+      flash_object.jpegquality(80)
+      flash_object.password("test")
+      flash_object.save(output_file)
+      assert(File.exist?(output_file))
+    ensure
+      File.delete(output_file)
+    end
+  end
+
+  def test_pdf_create_with_password_without_save_declaration
+    output_file = "#{CURRENT_DIR}/test_password.swf"
+    begin
+      flash_object = FlashObject.new(PDF_PASSW_PROTECTED)
+      flash_object.jpegquality(80)
+      flash_object.password("test")
+      flash_object.output(output_file)
+      flash_object.save()
+      assert(File.exist?(output_file))
+    ensure
+      File.delete(output_file)
+    end
+  end
+
+  def test_font_create
+    output_file = "#{CURRENT_DIR}/arial.swf"
+    begin
+      flash_object = FlashObject.new(FONT_FILE)
+      flash_object.save(output_file)
+      assert(File.exist?(output_file))
+    ensure
+      File.delete(output_file)
+    end
+  end
+
+  def test_gif_create
+    output_file = "#{CURRENT_DIR}/gif.swf"
+    begin
+      flash_object = FlashObject.new(GIF_FILE)
+      flash_object.save(output_file)
+      assert(File.exist?(output_file))
+    ensure
+      File.delete(output_file)
+    end
+  end
+
+  def test_png_create
+    output_file = "#{CURRENT_DIR}/png.swf"
+    begin
+      flash_object = FlashObject.new(PNG_FILE)
+      flash_object.save(output_file)
+      assert(File.exist?(output_file))
+    ensure
+      File.delete(output_file)
+    end
+  end
+
+  def test_jpg_create
+    output_file = "#{CURRENT_DIR}/jpg.swf"
+    begin
+      flash_object = FlashObject.new(JPG_FILE)
+      flash_object.save(output_file)
+      assert(File.exist?(output_file))
+    ensure
+      File.delete(output_file)
+    end
+  end
+
+   def test_create_from_blob
+    output_file = "#{CURRENT_DIR}/jpg.swf"
+    begin
+      tt = File.open(JPG_FILE, "rb")
+      flash_object = FlashObject.from_blob(tt.read, 'jpg')
+      flash_object.quality(80)
+      flash_object.save(output_file)
+    ensure
+      File.delete(output_file)
+    end
+  end
+
+   def test_creating_viewer
+   output_file = "#{CURRENT_DIR}/jpg.swf"
+      output_file = "#{CURRENT_DIR}/test_viewer.swf"
+    begin
+      flash_object = FlashObject.new(PDF_FILE)
+      flash_object.jpegquality(80)
+      flash_object.viewer(VIEW_SWF)
+      flash_object.save(output_file)
+      assert(File.exist?(output_file))
+    ensure
+      File.delete(output_file)
+    end
+   end
+
+
+  #
+  # Testing errors and bad types
+  #
+
+  def test_file_not_exist
+    assert_raise(FlashToolError) { flash_object = FlashObject.new("nofile.jpg")   }
+  end
+
+  def test_wrong_file_type
+    assert_raise(FlashToolError) {flash_object = FlashObject.new("bad_ext.txt")}
+  end
+
+
+end
+

metadata

@@ -0,0 +1,87 @@
+--- !ruby/object:Gem::Specification 
+name: flash_tool
+version: !ruby/object:Gem::Version 
+  prerelease: false
+  segments: 
+  - 0
+  - 5
+  - 0
+  version: 0.5.0
+platform: ruby
+authors: 
+- Bojan Milosavljevic
+autorequire: 
+bindir: bin
+cert_chain: []
+
+date: 2010-03-20 00:00:00 +01:00
+default_executable: 
+dependencies: []
+
+description: |-
+  A ruby wrapper for swftool command line tool. http://www.swftools.org/ 
+  Flash tool is small and mini tool for creating swf files from pdfs, pictures and
+  fonts and parsing data from flash files.
+email: milboj@gmail.com
+executables: []
+
+extensions: []
+
+extra_rdoc_files: 
+- README.rdoc
+files: 
+- .gitignore
+- .loadpath
+- .project
+- MIT-LICENSE
+- README.rdoc
+- Rakefile
+- VERSION
+- flash_tool.gemspec
+- lib/flash_tool.rb
+- test/25-1.gif
+- test/bad_ext.txt
+- test/bad_swf.swf
+- test/jpeg.swf
+- test/liberationserif_bold.ttf
+- test/rfxview.swf
+- test/test.jpg
+- test/test.pdf
+- test/test.png
+- test/test_flash_data.rb
+- test/test_flash_tool.rb
+- test/test_with_password.pdf
+- test/tester.swf
+has_rdoc: true
+homepage: http://github.com/milboj/flash_tool
+licenses: []
+
+post_install_message: 
+rdoc_options: 
+- --charset=UTF-8
+require_paths: 
+- lib
+required_ruby_version: !ruby/object:Gem::Requirement 
+  requirements: 
+  - - ">="
+    - !ruby/object:Gem::Version 
+      segments: 
+      - 0
+      version: "0"
+required_rubygems_version: !ruby/object:Gem::Requirement 
+  requirements: 
+  - - ">="
+    - !ruby/object:Gem::Version 
+      segments: 
+      - 0
+      version: "0"
+requirements: []
+
+rubyforge_project: flashtool
+rubygems_version: 1.3.6
+signing_key: 
+specification_version: 3
+summary: Simple and mini tool for creating swf (flash) files from pdf, jpg, png and gif with swftools
+test_files: 
+- test/test_flash_tool.rb
+- test/test_flash_data.rb