flash_tool 0.5.0 → 0.6.0

data/lib/flash_tool/flash.rb

@@ -0,0 +1,114 @@
+module FlashTool
+
+  
+  class Flash
+
+    attr :input
+    attr :args
+
+    # Path to file
+    attr_reader :output_path
+
+    # Hash with informations about generated file
+    attr_reader :info
+
+
+    #
+    # This is basic method for generating command in swf tools
+    # ==Example
+    #  something = Flash.new("document.pdf","pdf2swf")do |f|
+    #     f.rate(24)
+    #     f.save("outputs.swf"
+    #  end
+    #
+    # It is much easer to use other classes
+    # *FlashObject - for work converting from other formats
+    # *FlashScirpt - for generating files from scripts
+    # *FlashCombine - for combining files
+    #
+    def initialize(input, command ,tempfile = nil, &block)
+      @args = []
+      @tempfile = tempfile
+      @input = input
+      @command = command
+      yield self if block_given?
+      raise FlashToolError, "File not found" unless File.exist?(input)
+    end
+
+
+
+    # Save swf file from documents
+    # This method creates and run command
+    # Output path can be defined in save method or in method output before
+    # otherwise default file name will be same as input name document with swf extension
+    def save(output_path=nil)
+      to_output_path(output_path)
+      run_command(@command,*@args << @input)
+      @info = FlashTool.flash_info(@output_path)
+    end
+
+
+
+    # Setting options from command
+    # List of commands and options can find here http://wiki.swftools.org/index.php/Main_Page
+    # Optins with  "-" can't be executed in shorter form
+    #
+    def method_missing(symbol, *args)
+      @output_path = args.to_s if symbol.to_s == "output"
+      @args << ("--#{symbol}")
+      @args +=(args)
+    end
+
+
+    protected
+
+    # This method runs command
+    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
+
+    private
+
+    # set output path before saveing
+    def to_output_path(output_path) #:nodoc:
+      unless @output_path
+        if output_path
+          @output_path = output_path
+        else 
+          @output_path = parse_nil_path(@input)
+        end
+        @args << "--output"
+        @args << @output_path
+      end
+    end
+
+
+
+    # Parsing file name and push new exetesnion if filename is not setted
+    def parse_nil_path path #:nodoc:
+      path = path.split('.')
+      path.pop if path.length > 1
+      path.push("swf")
+      path.join('.')
+
+    end
+
+  end
+
+
+end

data/lib/flash_tool/flash_combine.rb

@@ -0,0 +1,82 @@
+require File.dirname(__FILE__) + '/flash.rb'
+module FlashTool
+
+  #
+  # This class work with tool swfcombine it is basic http://www.swftools.org/swfcombine.html
+  # You can use every opticons for this command.
+  # For adding master and slave swf files you must use methods master and slave
+  # If you trying to use options
+  #
+  class FlashCombine < Flash
+
+
+    #
+    # Take two or more SWF files, and combine them into a new SWF file.
+    # Can be used with or without master swf file
+    #
+    # ==Use
+    # 
+    #  combinated_file = FlashTool::FlashCombine.new
+    #  combinated_file.master("master.swf")
+    #  combinated_file.slave("viewport","slave.swf") #viewport is name of frame where can be placed slave
+    #  combinated_file.rate(24)
+    #  combinated_file.save("merged.swf")
+    #
+    #  cominated_file = FlashTool::FlashCombine.new do |f|
+    #   f.master("master.swf")
+    #   f.slave("viewport","slave.swf")
+    #   f.output("merged.swf")
+    #   f.save
+    #  end
+    #
+    def initialize(&block)
+      @args = []
+      @slaves = []
+      @command = "swfcombine"
+      yield self if block_given?
+    end
+
+    #
+    # With this method you will set master swf file for combining
+    #
+    # Can be only one master file
+    #
+    # Raise FlashToolError
+    #
+    def master(file)
+      raise(FlashToolError, "Can be only one master swf file" ) if @master
+      @master = file
+    end
+    
+    #
+    # With this method you will set slave swf file for combining 
+    # 
+    # Can be only one master file
+    # 
+    def slave(name, file)
+      @slaves += ["#{name}=#{file}"]
+    end
+
+    #
+    # Method save generate and run swfcombine command and generates file
+    # Outputh path must be setted here or with method outputh before
+    #
+    # Raise error if output_path is not set.
+    # 
+    def save(output_path=nil)
+      raise FlashToolError, "No output file name " if !@output_path and !output_path
+      to_output_path(output_path)
+      combiner
+      run_command(@command,*@args)
+      @info = FlashTool.flash_info(@output_path)
+    end
+
+
+    private
+    def combiner
+      @args.unshift(@master, @slaves)      
+    end
+
+
+  end
+end

data/lib/flash_tool/flash_object.rb

@@ -0,0 +1,73 @@
+require File.dirname(__FILE__) + '/flash.rb'
+module FlashTool
+  class FlashObject < Flash
+    attr_reader :type
+    attr :input
+
+    # 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 will have problems with SWFTools installation  and with command wav2swf)
+    #
+    # type - is extension name string if your input file have other extension
+    #
+    # == Example
+    #  flash = FlashOjbect.new('path_to_file', 'png')
+    #
+    #  flash = FlashOjbect.new('path_to_file.jpg') do |f|
+    #  f.quality(80)
+    #  f.rate('24')
+    #  f.save('outputh_path')
+    #  end
+    #
+    # Raise exceptions
+    def initialize(input, type = nil, tempfile = nil, &block)
+      @type = type || input.split('.').last
+      @command = type_parser @type
+      super(input,@command,tempfile,&block)
+      
+    end
+
+
+    def self.from_blob(blob, ext, &block)
+      begin
+        tempfile = Tempfile.new(['flash_tool', ext.to_s])
+        tempfile.binmode
+        tempfile.write(blob)
+      ensure
+        tempfile.close if tempfile
+      end
+
+      return self.new(tempfile.path, ext ,tempfile, &block)
+    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" #TODO Test wav for converting
+        command = "wav2swf"
+      else
+        raise FlashToolError, "Invalid type"
+      end
+      return command
+    end
+
+ 
+  end
+
+end

data/lib/flash_tool/flash_script.rb

@@ -0,0 +1,36 @@
+require File.dirname(__FILE__) + '/flash.rb'
+module FlashTool
+
+
+
+  # Generates flash files from scripts and using swfc tool
+  # More about this http://wiki.swftools.org/index.php/Swfc
+  class FlashScript < Flash
+
+    def initialize(input, tempfile = nil, &block)
+      @command = "swfc"
+      super(input,@command,tempfile,&block)
+    end
+
+    # Creates and return flash from  input script
+    # Same as option cgi options, but don't create file
+    def cgi
+      @args << "--cgi"
+      run_command(@command,*@args << @input)
+    end
+
+    # Creates and return flash from  input script
+    def self.flash_data(input)
+      return self.new(input).cgi
+    end
+
+    # Creates flash from  input script
+    def self.create(input, output)
+      return self.new(input).save(output)
+    end
+
+
+  end
+
+
+end

data/test/test_files/bad.sc

@@ -0,0 +1 @@
+stuipid test

data/test/test_files/script.sc

@@ -0,0 +1,8 @@
+.flash filename="box.swf"
+    .box b1 100 100 color=yellow fill=red
+    .put b1 pin=center scale=0%
+    .frame 100
+    .change b1 pin=center scale=100%
+    .frame 200
+    .change b1 pin=center scale=0%
+.end

data/test/test_flash_combine.rb

@@ -0,0 +1,88 @@
+require File.join(File.dirname(__FILE__), '../lib/flash_tool.rb')
+
+require 'test/unit'
+
+class Test_Flash_Combine < Test::Unit::TestCase
+  include FlashTool
+  CURRENT_DIR = File.dirname(File.expand_path(__FILE__)) + "/test_files/"
+  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"
+  VIEW_SWF  = CURRENT_DIR + "rfxview.swf"
+
+  def test_combine
+    output_file = "#{CURRENT_DIR}/merge.swf"
+    begin
+      inputs = VIEW_SWF
+      flash = FlashCombine.new()
+      flash.master(inputs)
+      flash.slave("viewport",TEST_SWF)
+      flash.save(output_file)
+      assert(File.exist?(output_file))
+      assert_kind_of(Hash, flash.info)
+      
+    ensure
+      File.delete(output_file)
+    end
+  end
+
+  def test_combine_block
+    output_file = "#{CURRENT_DIR}/merge.swf"
+    begin
+      inputs = VIEW_SWF
+      flash = FlashCombine.new() do |f|
+        f.master(inputs)
+        f.slave("viewport",TEST_SWF)
+        f.save(output_file)
+      end
+      assert_kind_of(Hash, flash.info)
+      assert(File.exist?(output_file))
+    ensure
+      File.delete(output_file)
+    end
+  end
+
+  def test_combine_without_save
+    output_file = "#{CURRENT_DIR}/merge.swf"
+    begin
+      inputs = VIEW_SWF
+      flash = FlashCombine.new() do |f|
+        f.slave("viewport",TEST_SWF)
+        f.method_missing("local-with-filesystem")
+        f.method_missing("rate",50)
+        f.master(inputs)        
+        f.output(output_file)
+        f.save()
+      end
+      assert_kind_of(Hash, flash.info)
+      assert(File.exist?(output_file))
+    ensure
+      File.delete(output_file)
+    end
+  end
+
+  def test_combine_no_output
+    inputs = VIEW_SWF
+    FlashCombine.new() do |f|
+      f.master(inputs)
+      f.slave("viewport",TEST_SWF)
+      f.output()
+      assert_raise(FlashToolError) {f.save()}
+    end
+  end
+
+  def test_bad_inputs
+    inputs = BAD_FILE
+    FlashCombine.new() do |f|
+      f.master(inputs)
+      f.slave("viewport",TEST_SWF)
+      f.output()
+      assert_raise(FlashToolError) {f.save()}
+
+    end
+
+  end      
+    
+end

data/test/test_flash_object.rb

@@ -0,0 +1,230 @@
+# 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__)) + "/test_files/"
+
+  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))
+      assert_equal output_file, flash_object.output_path      
+    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_blob.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)
+      assert(File.exist?(output_file))
+      assert_equal output_file, flash_object.output_path
+
+    ensure
+
+      File.delete(output_file)
+    end
+  end
+
+  def test_create_from_blob_block
+    output_file = "#{CURRENT_DIR}/jpg_block.swf"
+    begin
+    
+      tt = File.open(JPG_FILE, "rb")
+      flash_object = FlashObject.from_blob(tt.read, 'jpg') do |f|
+        f.quality(80)
+        f.output(output_file)
+        f.save()
+      end
+      assert(File.exist?(output_file))
+      assert_kind_of Hash, flash_object.info
+      assert_equal output_file, flash_object.output_path
+
+    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
+
+
+  def test_block
+    output_file = "#{CURRENT_DIR}/jpg.swf"
+    begin
+      flash_object = FlashObject.new(JPG_FILE) do |f|
+        f.quality(80)
+      end
+      flash_object.save(output_file)
+
+      assert(File.exist?(output_file))
+    ensure
+      File.delete(output_file)
+    end
+  end
+
+  def test_info
+    output_file = "#{CURRENT_DIR}/jpg.swf"
+    begin
+      flash_object = FlashObject.new(JPG_FILE)
+      assert_equal nil, flash_object.info
+      flash_object.output(output_file)
+      assert_equal nil, flash_object.info
+      flash_object.save()
+      assert_not_equal nil, flash_object.info
+
+    ensure
+      File.delete(output_file)
+    end
+  end
+
+  def test_without_outputh_path
+    begin
+      flash_object = FlashObject.new(JPG_FILE)
+      flash_object.save()
+      assert_equal("#{CURRENT_DIR}test.swf" , flash_object.output_path)
+    ensure
+      File.delete(flash_object.output_path)
+    end
+  end
+
+
+end
+