redcar-dev 0.12.17dev

data/plugins/edit_view_swt/lib/edit_view_swt/document.rb

@@ -0,0 +1,224 @@
+
+module Redcar
+  class EditViewSWT
+    class Document
+      include Redcar::Observable
+      attr_reader :jface_document
+
+      def initialize(model, swt_mate_document)
+        @model          = model
+        @swt_mate_document = swt_mate_document
+        @jface_document = swt_mate_document.mateText.get_document
+      end
+
+      def right_click(edit_view)
+        menu = Menu.new
+        Redcar.plugin_manager.objects_implementing(:edit_view_context_menus).each do |object|
+          case object.method(:edit_view_context_menus).arity
+          when 0
+            menu.merge(object.edit_view_context_menus)
+          when 1
+            menu.merge(object.edit_view_context_menus(edit_view))
+          else
+            puts("Invalid edit_view_context_menus hook detected in "+object.class.name)
+          end
+        end
+        Application::Dialog.popup_menu(menu, :pointer)
+      end
+      
+      def attach_modification_listeners
+        jface_document.add_document_listener(DocumentListener.new(@model))
+        styledText.add_selection_listener(SelectionListener.new(@model))
+        styledText.add_caret_listener(CaretListener.new(@model))
+      end
+
+      def single_line?
+        @swt_mate_document.mateText.isSingleLine
+      end
+
+      def to_s
+        jface_document.get
+      end
+
+      def length
+        jface_document.length
+      end
+
+      def line_count
+        jface_document.get_number_of_lines
+      end
+
+      def get_line_delimiter
+        styledText.get_line_delimiter
+      end
+
+      def line_at_offset(offset)
+        jface_document.get_line_of_offset(offset)
+      end
+
+      def offset_at_line(line_ix)
+        line_ix = [line_ix, line_count - 1].min
+        jface_document.get_line_offset(line_ix)
+      end
+
+      def get_line(line_ix)
+        line_info = jface_document.get_line_information(line_ix)
+        jface_document.get(line_info.offset, line_info.length)
+      end
+
+      def get_range(start, length)
+        jface_document.get(start, length)
+      end
+
+      def replace(offset, length, text)
+        @model.verify_text(offset, offset+length, text)
+        jface_document.replace(offset, length, text)
+        @model.modify_text
+      end
+
+      def text=(text)
+        @model.verify_text(0, length, text)
+        top_pixel   = styledText.getTopPixel
+        caret       = cursor_offset
+        line        = line_at_offset(caret)
+        caret       = caret - offset_at_line(line)
+
+        styledText.setRedraw(false)
+        styledText.setText(text)
+
+        unless line > line_count - 1
+          # The documents new text is still longer than our previous position, restore position
+          line_offset = offset_at_line(line)
+          styledText.setCaretOffset([line_offset + caret, offset_at_line(line + 1) - 1].min)
+          styledText.setTopPixel(top_pixel)
+        end
+
+        styledText.setRedraw(true)
+        @model.modify_text
+        notify_listeners(:set_text)
+      end
+
+      def cursor_offset
+        styledText.get_caret_offset
+      end
+
+      def selection_offset
+        range = styledText.get_selection_range
+        range.x == cursor_offset ? range.x + range.y : range.x
+      end
+
+      def cursor_offset=(offset)
+        styledText.set_caret_offset(offset)
+      end
+
+      def selection_range
+        range = styledText.get_selection_range
+        range.x...(range.x + range.y)
+      end
+
+      def selection_ranges
+        ranges = styledText.get_selection_ranges
+        ranges.to_a.each_slice(2).map do |from, length|
+          from...(from + length)
+        end
+      end
+
+      def set_selection_range(cursor_offset, selection_offset)
+        if block_selection_mode?
+          start_offset, end_offset = *[cursor_offset, selection_offset].sort
+          start_location = styledText.getLocationAtOffset(start_offset)
+          end_location   = styledText.getLocationAtOffset(end_offset)
+          styledText.set_block_selection_bounds(
+            start_location.x,
+            start_location.y,
+            end_location.x - start_location.x,
+            end_location.y - start_location.y + styledText.get_line_height
+          )
+        else
+          styledText.set_selection_range(selection_offset, cursor_offset - selection_offset)
+        end
+        @model.selection_range_changed(cursor_offset, selection_offset)
+      end
+
+      @markStruct ||= Struct.new(:location, :category) # save away the parent class
+      class Mark < @markStruct
+        def get_offset;      location.get_offset;      end
+        def get_line;        location.get_line;        end
+        def get_line_offset; location.get_line_offset; end
+        def inspect;         "<Mark #{get_line}:#{get_line_offset} (#{get_offset})>"; end
+      end
+
+      def create_mark(offset, gravity)
+        line = line_at_offset(offset)
+        line_offset = offset - offset_at_line(line)
+        case gravity
+        when :left
+          category = "lefts"
+        when :right
+          category = "rights"
+        end
+  			location = @swt_mate_document.get_text_location(line, line_offset)
+				@swt_mate_document.add_text_location(category, location)
+				Mark.new(location, category)
+      end
+
+      def delete_mark(mark)
+        @swt_mate_document.remove_text_location(mark.category, mark.location)
+      end
+
+      def block_selection_mode?
+        styledText.get_block_selection
+      end
+
+      def block_selection_mode=(bool)
+        styledText.set_block_selection(bool)
+      end
+
+      def styledText
+        @swt_mate_document.mateText.getControl
+      end
+
+      def scope_at(line, line_offset)
+        @swt_mate_document.mateText.scope_at(line, line_offset)
+      end
+
+      class CaretListener
+        def initialize(model)
+          @model = model
+        end
+
+        def caret_moved(event)
+          @model.cursor_moved(event.caretOffset)
+        end
+      end
+
+      class SelectionListener
+        def initialize(model)
+          @model = model
+        end
+
+        def widget_default_selected(e)
+          @model.selection_range_changed(e.x, e.y)
+        end
+
+        def widget_selected(e)
+          @model.selection_range_changed(e.x, e.y)
+        end
+      end
+
+      class DocumentListener
+        def initialize(model)
+          @model = model
+        end
+
+        def document_about_to_be_changed(e)
+          @model.about_to_be_changed(e.offset, e.length, e.text)
+        end
+
+        def document_changed(e)
+          @model.changed(e.offset, e.length, e.text)
+        end
+      end
+    end
+  end
+end

data/plugins/edit_view_swt/lib/edit_view_swt/edit_tab.rb

@@ -0,0 +1,50 @@
+module Redcar
+  class EditViewSWT
+    class Tab < ApplicationSWT::Tab
+      include Redcar::Observable
+      
+      attr_reader :item, :edit_view
+      
+      def initialize(*args)
+        super
+        @model.add_listener(:changed_title) { |title| @item.text = title }
+      end
+      
+      # Focuses the CTabItem within the CTabFolder, and gives the keyboard
+      # focus to the EditViewSWT.
+      def focus
+        super
+        edit_view.focus
+      end
+      
+      # Close the EditTab, disposing of any resources along the way.
+      def close
+        @edit_view.dispose
+        @widget.dispose
+        super
+      end
+      
+      private
+      
+      def create_tab_widget
+        @widget = Swt::Widgets::Composite.new(notebook.tab_folder, Swt::SWT::NONE)
+        layout = Swt::Layout::GridLayout.new(1, false)
+        layout.verticalSpacing = 0
+        layout.marginHeight = 0
+        layout.horizontalSpacing = 0
+        layout.marginWidth = 0
+        @widget.layout = layout
+        @edit_view = EditViewSWT.new(model.edit_view, @widget)
+        
+        grid_data = Swt::Layout::GridData.new(
+                      Swt::Layout::GridData::FILL_BOTH | 
+                      Swt::Layout::GridData::VERTICAL_ALIGN_FILL |
+                      Swt::Layout::GridData::HORIZONTAL_ALIGN_FILL)
+        @edit_view.mate_text.get_control.parent.set_layout_data(grid_data)
+
+        @item.control = @widget
+        @widget.pack
+      end
+    end
+  end
+end

data/plugins/edit_view_swt/lib/edit_view_swt/word_movement.rb

@@ -0,0 +1,68 @@
+
+module Redcar
+  class EditViewSWT
+    class WordMoveListener
+      MOVE_FORWARD_RE = /\s{3,}|[^\w]{2,}|(\s|[^\w])?\w+/
+    
+      def initialize(controller)
+        @controller = controller
+      end
+      
+      def get_next_offset(e)
+        if [Swt::SWT::MOVEMENT_WORD, Swt::SWT::MOVEMENT_WORD_END].include? e.movement
+          e.newOffset = next_offset(e.offset, e.lineOffset, e.lineText)
+          # SWT gets pissy without this:
+          if e.newOffset == e.lineOffset + e.lineText.chars.length + 1
+            e.newOffset += 1
+          end
+        end
+      end
+      
+      def next_offset(chars_offset, chars_line_offset, line_text)
+        if chars_offset == chars_line_offset + line_text.chars.length
+          chars_offset + 1
+        else
+          future_text = line_text.chars[(chars_offset - chars_line_offset)..-1].to_s
+          if future_text == nil or future_text == ""
+            chars_line_offset + line_text.chars.length
+          else
+            if md = future_text.match(MOVE_FORWARD_RE)
+              chars_match_end = future_text.byte_offset_to_char_offset(md.end(0))
+              chars_offset + chars_match_end
+            else
+              chars_line_offset + line_text.chars.length
+            end
+          end
+        end
+      end
+      
+      def get_previous_offset(e)
+        if [Swt::SWT::MOVEMENT_WORD, Swt::SWT::MOVEMENT_WORD_START].include? e.movement
+          e.newOffset = previous_offset(e.offset, e.lineOffset, e.lineText)
+          # SWT gets pissy without this:
+          if e.newOffset == e.lineOffset - 1
+            e.newOffset -= 1
+          end
+        end
+      end
+      
+      def previous_offset(chars_offset, chars_line_offset, line_text)
+        if chars_offset == chars_line_offset
+          chars_offset - 1
+        else
+          future_text = line_text.chars[0..(chars_offset - chars_line_offset - 1)].reverse.to_s
+          if future_text == nil or future_text == ""
+            chars_line_offset
+          else
+            if md = future_text.match(MOVE_FORWARD_RE)
+              chars_match_end = future_text.byte_offset_to_char_offset(md.end(0))
+              chars_offset - chars_match_end
+            else
+              chars_line_offset
+            end
+          end
+        end
+      end
+    end
+  end
+end

data/plugins/edit_view_swt/plugin.rb

@@ -0,0 +1,9 @@
+
+Plugin.define do
+  name    "edit_view_swt"
+  version "1.0"
+  file    "lib", "edit_view_swt"
+  object  "Redcar::EditViewSWT"
+  dependencies "core", ">0",
+               "application_swt", ">0"
+end

data/plugins/edit_view_swt/spec/edit_view_swt/word_movement_spec.rb

@@ -0,0 +1,29 @@
+require File.join(File.dirname(__FILE__), "..", "spec_helper")
+
+describe Redcar::EditViewSWT::WordMoveListener do
+  before do
+    @word = Redcar::EditViewSWT::WordMoveListener.new(nil)
+  end
+  
+  describe "moving forwards" do
+    it "should move over a word to the next non-word char" do
+      @word.next_offset(0, 0, "foo.bar").should == 3
+    end
+  
+    it "should move over a symbol and a word to the next non-word char" do
+      @word.next_offset(0, 0, ".foo.bar").should == 4
+    end
+  
+    it "should move over multiple symbols to the next word" do
+      @word.next_offset(0, 0, "..foo.bar").should == 2
+    end
+  
+    it "should move over a space and the next word " do
+      @word.next_offset(0, 0, " foo.bar").should == 4
+    end
+  
+    it "should move over multiple spaces to the next word " do
+      @word.next_offset(0, 0, "  foo.bar").should == 2
+    end
+  end
+end

data/plugins/edit_view_swt/spec/spec_helper.rb

@@ -0,0 +1,5 @@
+$:.push File.join(File.dirname(__FILE__), '..', '..', '..', 'lib')
+
+require 'redcar'
+Redcar.environment = :test
+Redcar.load_unthreaded

data/plugins/encryption/encryption.rb

@@ -0,0 +1,52 @@
+
+
+module Encryption
+  def self.encrypt(text, password)
+    EncryptionTools.encrypt_and_armour(text, password)
+  end
+  
+  def self.decrypt(text, password)
+    EncryptionTools.dearmour_and_decrypt(text, password)
+  end
+  
+  def self.menus
+    Redcar::Menu::Builder.build do
+      sub_menu "Plugins" do
+        sub_menu "Encryption", :priority => 55 do
+          item "Encrypt Document", EncryptDocumentCommand
+          item "Decrypt Document", DecryptDocumentCommand
+        end
+      end
+    end
+  end
+
+  def self.lazy_load
+    require File.dirname(__FILE__) + "/jarmor-1.1"
+    require File.dirname(__FILE__) + "/ezcrypto"
+  end
+
+  class DecryptDocumentCommand < Redcar::EditTabCommand
+    def execute
+      Encryption.lazy_load
+      result = Redcar::Application::Dialog.input("Password", "Enter password")
+      return if result[:button] == :cancel
+      pw = result[:value]
+      begin
+        doc.text = Encryption.decrypt(doc.to_s, pw)
+      rescue => e
+        Redcar::Application::Dialog.message_box("Couldn't decrypt!", :type => :error)
+      end
+    end
+  end
+  
+  class EncryptDocumentCommand < Redcar::EditTabCommand
+    def execute
+      Encryption.lazy_load
+      result = Redcar::Application::Dialog.input("Password", "Enter password")
+      return if result[:button] == :cancel
+      pw = result[:value]
+      doc.text = Encryption.encrypt(doc.to_s, pw)
+    end
+  end
+end
+

data/plugins/encryption/ezcrypto.rb

@@ -0,0 +1,652 @@
+require 'openssl'
+require 'digest/sha2'
+require 'digest/sha1'
+require 'base64'
+
+class EncryptionTools
+  def self.dearmour_and_decrypt(data, pw)
+    encrypted = EncryptionTools.dearmour(data.gsub("\n", ""))
+    EncryptionTools.decrypt(encrypted, pw)
+  end
+  
+  def self.encrypt_and_armour(data, pw)
+    encrypted = EncryptionTools.encrypt(data, pw)
+    "\n" + EncryptionTools.armour(encrypted)
+  end
+  
+  def self.dearmour(data)
+    stream = java.io.ByteArrayInputStream.new(java.lang.String.new(data).getBytes)
+    armour = org.spaceroots.jarmor.Base64Decoder.new(stream)
+    encrypted = ""
+    while (byte = armour.read) != -1
+      encrypted << byte
+    end
+    armour.close
+    encrypted
+  end
+  
+  def self.decrypt(data, pw)
+    key = EzCrypto::Key.with_password pw, "system salt"
+    key.decrypt(data)
+  end
+  
+  def self.encrypt(data, pw)
+    key = EzCrypto::Key.with_password pw, "system salt"
+    key.encrypt(data)
+  end
+  
+  def self.armour(data)
+    stream = java.io.ByteArrayOutputStream.new
+    armour = org.spaceroots.jarmor.Base64Encoder.new(stream, 80, java.lang.String.new("").getBytes, java.lang.String.new("\n").getBytes)
+    data.each_byte {|byte| armour.write(byte) }
+    armour.close
+    stream.toString
+  end
+end
+
+module EzCrypto #:nodoc:
+
+=begin rdoc
+The Key is the only class you need to understand for simple use.
+
+=== Algorithms
+
+The crypto algorithms default to aes-128-cbc however on any of the class methods you can change it to one of the standard openssl cipher names using the
+optional <tt>:algorithm=>alg name</tt> parameter.
+
+Eg. 
+    Key.new @raw, :algorithm=>"des"
+    Key.generate :algorithm=>"blowfish"
+    Key.with_password @pwd,@salt,:algorithm=>"aes256"    
+
+
+== License
+
+ActiveCrypto and EzCrypto are released under the MIT license.
+
+
+== Support
+
+To contact the author, send mail to pelleb@gmail.com
+
+Also see my blogs at:
+http://stakeventures.com and
+http://neubia.com
+
+This project was based on code used in my project StakeItOut, where you can securely share web services with your partners.
+https://stakeitout.com
+
+(C) 2005 Pelle Braendgaard
+
+=end
+
+  class Key
+
+    attr_reader :raw, :algorithm
+
+    @@block_size = 512
+
+=begin rdoc
+Set the block-size for IO-operations (default: 512 bytes)
+=end
+    def self.block_size=(size)
+      @@block_size = size
+    end
+
+=begin rdoc
+Return the block-size for IO-operations.
+=end
+    def self.block_size
+      @@block_size
+    end
+
+
+=begin rdoc
+Initialize the key with raw unencoded binary key data. This needs to be at least
+16 bytes long for the default aes-128 algorithm.
+=end
+    def initialize(raw,options = {})
+      @raw=raw
+      @algorithm=options[:algorithm]||"aes-128-cbc"
+    end
+
+=begin rdoc
+Generate random key.
+=end
+    def self.generate(options = {})
+      Key.new(EzCrypto::Digester.generate_key(calculate_key_size(options[:algorithm])),options)
+    end
+
+=begin rdoc
+Create key generated from the given password and salt
+=end
+    def self.with_password(password,salt,options = {})
+      Key.new(EzCrypto::Digester.get_key(password,salt,calculate_key_size(options[:algorithm])),options)
+    end
+
+=begin rdoc
+Initialize the key with Base64 encoded key data.
+=end
+    def self.decode(encoded,options = {})
+      Key.new(Base64.decode64(encoded),options)
+    end
+
+=begin rdoc
+Encrypts the data with the given password and a salt. Short hand for:
+
+  key=Key.with_password(password,salt,options)
+  key.encrypt(data)
+
+=end
+    def self.encrypt_with_password(password,salt,data,options = {})
+      key=Key.with_password(password,salt,options)
+      key.encrypt(data)
+    end
+
+=begin rdoc
+Decrypts the data with the given password and a salt. Short hand for:
+
+  key=Key.with_password(password,salt,options)
+  key.decrypt(data)
+
+
+=end
+    def self.decrypt_with_password(password,salt,data,options = {})
+      key=Key.with_password(password,salt,options)
+      key.decrypt(data)
+    end
+
+=begin rdoc
+Given an algorithm this calculates the keysize. This is used by both
+the generate and with_password methods. This is not yet 100% complete.
+=end
+    def self.calculate_key_size(algorithm)
+      if !algorithm.nil?
+        algorithm=~/^([[:alnum:]]+)(-(\d+))?/
+        if $3
+          size=($3.to_i)/8
+        else
+          case $1
+            when "bf"
+              size = 16
+            when "blowfish"
+              size = 16
+            when "des"
+              size = 8
+            when "des3"
+              size = 24
+            when "aes128"
+              size = 16
+            when "aes192"
+              size = 24
+            when "aes256"
+              size = 32
+            when "rc2"
+              size = 16
+            when "rc4"
+              size = 16
+            else
+              size = 16
+            end
+        end
+      end
+      if size.nil?
+        size = 16
+      end
+
+      size
+    end
+
+=begin rdoc
+returns the Base64 encoded key.
+=end
+    def encode
+      Base64.encode64(@raw).chop
+    end
+
+=begin rdoc
+returns the Base64 encoded key. Synonym for encode.
+=end
+    def to_s
+      encode
+    end
+
+=begin rdoc
+Encrypts the data and returns it in encrypted binary form.
+=end
+    def encrypt(data)
+      if data==nil || data==""
+        nil
+      else
+        encrypter("")
+        @cipher.encrypt(data)
+      end
+    end
+
+=begin rdoc
+Encrypts the data and returns it in encrypted Base64 encoded form.
+=end
+    def encrypt64(data)
+      Base64.encode64(encrypt(data))
+    end
+
+=begin rdoc
+Decrypts the data passed to it in binary format.
+=end
+    def decrypt(data)
+      if data==nil || data==""
+        nil
+      else
+        decrypter("")
+        @cipher.gulp(data)
+      end
+#    rescue
+#      puts @algorithm
+#      puts self.encode
+#      puts data.size
+#      throw $!
+    end
+
+=begin rdoc
+Decrypts a Base64 formatted string
+=end
+    def decrypt64(data)
+      decrypt(Base64.decode64(data))
+    end
+    
+=begin rdoc
+Allows keys to be marshalled
+=end
+    def marshal_dump
+       "#{self.algorithm}$$$#{self.encode}"
+    end
+    
+=begin rdoc
+Allows keys to be unmarshalled
+=end
+    def marshal_load(s) 
+       a, r = s.split '$$$'
+       @algorithm = a
+       @raw = Base64.decode64(r)
+    end
+
+=begin rdoc
+Create a file with minimal permissions, and yield
+it to a block. By default only the owner may read it.
+=end
+    def safe_create(file, mod=0400, mask=0066)
+      begin
+        old_umask = File.umask
+        File.umask(mask)
+        File.open(file, File::CREAT | File::EXCL | File::WRONLY) do |f|
+          yield(f) if block_given?
+        end
+      ensure
+        File.umask(old_umask)
+      end
+      File.chmod(mod, file) if File.exists?(file)
+      File.size(file)
+    end
+
+
+=begin rdoc
+Overwrite a file with zero values before removing it's filesystem inode.
+This is not very safe :-)
+=end
+    def safe_delete(file)
+      begin
+        to_clear = File.size(file)
+        zeroes   = Array.new(Key.block_size, "\0").join
+        File.chmod(0600, file)
+        File.open(file, File::WRONLY) do |f|
+          f.rewind
+          while to_clear > 0
+            f.write(zeroes)
+            to_clear -= Key.block_size
+          end
+          f.flush
+        end
+      ensure
+        File.delete(file) if File.exists?(file)
+      end
+      return !File.exists?(file)
+    end
+
+
+=begin rdoc
+Open a file readonly and yield it to a block.
+=end
+    def safe_read(file)
+      File.open(file, File::RDONLY) do |i|
+        yield(i) if block_given?
+      end
+    end
+
+    private :safe_create, :safe_read, :safe_delete
+
+=begin rdoc
+Load a key from a yaml_file generated via Key#store.
+=end
+    def self.load(filename)
+      require 'yaml'
+      hash = YAML::load_file(filename)
+      req = proc { |k| hash[k] or raise "Missing element #{k} in #{filename}" }
+      key = self.new Base64.decode64(req.call(:key)) , :algorithm => req.call(:algorithm)
+      return key
+    end
+
+
+=begin rdoc
+Save the key data into a file, try to do this in a secure manner.
+NOTE: YAML::store & friends are not used to encance control over
+the generated file format.
+=end
+    def store(filename)
+      safe_create(filename) do |f|
+        selfenc = self.encode
+        f.puts "---"
+        f.puts ":EZCRYPTO KEY FILE: KEEP THIS SECURE !"
+        f.puts ":created: #{Time.now}"
+        f.puts ":algorithm: #{@algorithm}"
+        f.puts ":key: #{selfenc}"
+      end
+    end
+
+
+=begin rdoc
+Get a Encrypter object. You have to call #final on it by yourself!
+=end
+    def encrypter(target='')
+      @cipher = EzCrypto::Encrypter.new(self,target,@algorithm)
+    end
+
+
+=begin rdoc
+Get a Decrypter object. You have to call #final on it by yourself!
+=end
+    def decrypter(target='')
+      @cipher = EzCrypto::Decrypter.new(self,target,@algorithm)
+    end
+
+=begin rdoc
+Create a Decrypter object and yield it to a block.
+You must *not* call #final by yourself, the method
+does this.
+=end
+    def on_decrypter(target='', &block)
+      decrypter(target)
+      on_cipher(&block)
+    end
+
+=begin rdoc
+Create an Encrypter object and yield it to a block.
+You must *not* call #final by yourself, the method
+does this.
+=end
+    def on_encrypter(target='', &block)
+      encrypter(target)
+      on_cipher(&block)
+    end
+
+
+=begin rdoc
+Helper method, yields the current cipher to a block.
+=end
+    def on_cipher(&block)
+      begin
+        block.call @cipher
+      ensure
+        @cipher.final
+      end
+    end
+
+    private :on_cipher
+
+
+=begin rdoc
+Encrypt a file 'inplace' and add a suffix
+see #cipher_file.
+IMPORTANT: The inputfile will be deleted by default.
+=end
+    def encrypt_file(src, tgt=nil, options = {} )
+      options = { :suffix => '.ez', :autoclean => 'true' }.update(options)
+      tgt = "#{src}#{options[:suffix]}" unless tgt
+      cipher_file :on_encrypter, src, tgt, options[:autoclean]
+    end
+
+
+=begin rdoc
+Decrypt a file 'inplace' and remove a suffix
+see #cipher_file
+IMPORTANT: The inputfile will be deleted by default.
+=end
+    def decrypt_file(src, tgt=nil, options = {} )
+      options = { :suffix => '.ez', :autoclean => 'true' }.update(options)
+      unless tgt
+        tgt = src
+        tgt = tgt.gsub(/#{options[:suffix]}$/, '')
+      end
+      cipher_file :on_decrypter, src, tgt, options[:autoclean]
+    end
+
+
+=begin rdoc
+uses either  #on_decrypter or #on_encrypter to transform a given sourcefile
+to a targetfile. the sourcefile is deleted after sucessful transformation
+the delete_source is 'true'.
+=end
+    def cipher_file(method, sourcefile, targetfile, delete_source)
+      raise(ArgumentError, "source == target #{sourcefile}") if sourcefile == targetfile
+      safe_create(targetfile,0600) do |o|
+        self.send(method, o) do |c|
+          safe_read(sourcefile) do |i|
+            loop do
+              buffer = i.read(Key.block_size) or break
+              c << buffer
+            end
+          end
+        end
+      end
+      safe_delete(sourcefile) if delete_source && File.exists?(targetfile)
+      return targetfile
+    end
+    
+    private :cipher_file
+    
+  end
+  
+=begin rdoc
+Abstract Wrapper around OpenSSL's Cipher object. Extended by Encrypter and Decrypter.
+  
+You probably should be using the Key class instead.
+
+Warning! The interface may change.
+
+=end
+  class CipherWrapper #:nodoc:
+
+=begin rdoc
+  
+=end
+    def initialize(key,target,mode,algorithm)
+      @cipher = OpenSSL::Cipher::Cipher.new(algorithm)  
+      if mode
+        @cipher.encrypt
+      else
+        @cipher.decrypt
+      end
+      @cipher.key=key.raw
+      @cipher.padding=1
+      @target=target
+      @finished=false
+    end
+    
+    
+    def to_target(data)
+      return data
+    end
+    
+=begin rdoc
+Process the givend data with the cipher.
+=end
+    def update(data)
+      reset if @finished
+      @target<< to_target(@cipher.update(data))
+    end
+
+=begin rdoc
+  
+=end
+    def <<(data)
+      update(data)
+    end
+    
+=begin rdoc
+Finishes up any last bits of data in the cipher and returns the final result.
+=end
+    def final
+      @target<< to_target(@cipher.final)
+      @finished=true
+      @target
+    end
+    
+=begin rdoc
+Processes the entire data string using update and performs a final on it returning the data.
+=end
+    def gulp(data)
+      update(data)
+      final 
+#    rescue
+#      breakpoint
+    end  
+
+=begin rdoc
+  
+=end
+    def reset(target="")
+      @target=target
+      @finished=false
+    end
+  end
+
+=begin rdoc
+Wrapper around OpenSSL Cipher for Encryption use.
+
+You probably should be using Key instead.
+
+Warning! The interface may change.
+
+=end
+  class Encrypter<EzCrypto::CipherWrapper #:nodoc:
+
+=begin rdoc
+  
+=end
+    def initialize(key,target="",algorithm="aes-128-cbc")
+      super(key,target,true,algorithm)
+    end
+    
+=begin rdoc
+  
+=end    
+    def encrypt(data)    
+      gulp(data)
+    end
+  end
+
+=begin rdoc
+Wrapper around OpenSSL Cipher for Decryption use.
+
+You probably should be using Key instead.
+
+Warning! The interface may change.
+=end
+  class Decrypter<EzCrypto::CipherWrapper #:nodoc:
+=begin rdoc
+  
+=end
+    def initialize(key,target="",algorithm="aes-128-cbc")
+      super(key,target,false,algorithm)
+    end
+    
+=begin rdoc
+  
+=end    
+    def decrypt(data)
+      gulp(data)
+    end
+  end
+
+=begin rdoc
+
+=end
+  class Digester    
+=begin rdoc
+Various handy Digest methods. 
+
+Warning! The interface may change.
+=end
+    def self.get_key(password,salt,size)
+        digest(salt+password,size)
+    end
+  
+=begin rdoc
+  
+=end
+    def self.generate_key(size=16)
+        key=OpenSSL::Random.random_bytes(size)
+        digest(key,size)
+    end
+  
+=begin rdoc
+  
+=end
+    def self.generate_key64(size=32)
+        key=OpenSSL::Random.random_bytes(size)
+        digest64(key,size)
+    end   
+=begin rdoc
+
+=end
+    def self.generate_hexkey(size=40)
+        key=OpenSSL::Random.random_bytes(size)
+        hexdigest(key,size)
+    end   
+    
+=begin rdoc
+  
+=end
+    def self.digest(data,size=16)
+      if size==0
+        ""
+      elsif size<=16
+        Digest::SHA1.digest(data)[0..(size-1)]
+      else
+        Digest::SHA256.digest(data)[0..(size-1)]
+      end
+    end
+
+=begin rdoc
+
+=end
+    def self.hexdigest(data,size=40)
+      if size==0
+        ""
+      elsif size<=40
+        Digest::SHA1.hexdigest(data)[0..(size-1)]
+      else
+        Digest::SHA256.hexdigest(data)[0..(size-1)]
+      end
+    end
+    
+=begin rdoc
+  
+=end
+    def self.digest64(data,size=16)
+      Base64.encode64(digest(data,size))
+    end
+	end
+
+end
+
+