huffman 0.0.1

checksums.yaml

@@ -0,0 +1,7 @@
+---
+SHA1:
+  metadata.gz: b1ca0edfc95c127d985761e93aef3955db7b072c
+  data.tar.gz: 158a85243dd28bd5e091324ea3f67a5d9f38f729
+SHA512:
+  metadata.gz: 470b5e0b2c8c63c5bc7f99c70c020e2716e5f1be2826d6d9af595d798d59d13e77b23945f7f9972dd01843a492b47a650c064419f5b899e1f1e93486204ee1cd
+  data.tar.gz: 7c57e085a01a7a5c138f291ab94602c2570a6ff3c8f4f46f496ea5d71ecb537d51b1fd9e484327117e59e855f6160fad08199ee64be41b07771ccc7f5c623fa9

data/.gitattributes

@@ -0,0 +1,22 @@
+# Auto detect text files and perform LF normalization
+* text=auto
+
+# Custom for Visual Studio
+*.cs     diff=csharp
+*.sln    merge=union
+*.csproj merge=union
+*.vbproj merge=union
+*.fsproj merge=union
+*.dbproj merge=union
+
+# Standard to msysgit
+*.doc	 diff=astextplain
+*.DOC	 diff=astextplain
+*.docx diff=astextplain
+*.DOCX diff=astextplain
+*.dot  diff=astextplain
+*.DOT  diff=astextplain
+*.pdf  diff=astextplain
+*.PDF	 diff=astextplain
+*.rtf	 diff=astextplain
+*.RTF	 diff=astextplain

data/.gitignore

@@ -0,0 +1,19 @@
+*.gem
+*.rbc
+.bundle
+.config
+.yardoc
+Gemfile.lock
+InstalledFiles
+_yardoc
+coverage
+doc/
+lib/bundler/man
+pkg
+rdoc
+spec/reports
+test/tmp
+test/version_tmp
+tmp
+huffman.log
+data/.*

data/.rspec

@@ -0,0 +1,2 @@
+--color
+--format progress

data/.ruby-version

@@ -0,0 +1 @@
+2.0.0-p247

data/.travis.yml

@@ -0,0 +1,4 @@
+rvm:
+  - 1.9.3
+  - 2.0.0
+  - 2.1.0

data/Gemfile

@@ -0,0 +1,4 @@
+source 'https://rubygems.org'
+
+# Specify your gem's dependencies in huffman.gemspec
+gemspec

data/LICENSE.txt

@@ -0,0 +1,22 @@
+Copyright (c) 2013 Martin Lagrange
+
+MIT License
+
+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.md

@@ -0,0 +1,80 @@
+![Huffman](http://www.mathworks.com/matlabcentral/fx_files/33212/1/huffman.png)
+
+[![Code Climate](https://codeclimate.com/repos/52c06ecae30ba036eb00347b/badges/adbbcd5f91fb73caf186/gpa.png)](https://codeclimate.com/repos/52c06ecae30ba036eb00347b/feed) [![Build Status](https://travis-ci.org/lagrangemartin/huffman.png?branch=master)](https://travis-ci.org/lagrangemartin/huffman)
+
+# The Huffman gem
+
+This gem allow you to encode and decode a text using the Huffman encoding compression algorithm.
+It can also generate and visualize the huffman tree as a png file.
+
+## Setup
+
+-Add this line to your application's Gemfile:
+Ajoutez cette ligne à votre Gemfile :
+
+```ruby
+gem 'huffman'
+```
+
+-And then execute:
+
+    $ bundle
+
+-Or install it yourself as:
+
+    $ gem install huffman
+
+
+-Install graphviz if you want to be able to visualize trees.
+
+## Usage
+
+
+Encode a text :
+
+```ruby
+Huffman.encode_text(txt) # return text_encoded, dictionnary
+Huffman.encode_text(txt) # return text_encoded, dictionnary
+```
+
+    
+Decode a text :
+```ruby
+Huffman.decode_text(encoded_txt, dictionnary) # return decoded_text
+```
+
+Encode a text file
+```ruby
+Huffman.encode_file(file_name) # write a file_name.huffman-encoded file and a file_name.huffman-dictionnary
+Huffman.encode_file(file_name) # write a file_name.huffman-encoded file and a file_name.huffman-dictionnary
+```
+
+Decode a text file :
+```ruby
+Huffman.decode_file(huffman_encoded_file_path,huffman-dictionnary_path) # write a huffman-encoded-back-to-original file
+```
+
+
+## Generate a Huffman tree
+
+![Huffman tree](http://img15.hostingpics.net/pics/575352tree.png)
+
+
+This gem give you the ability to generate and visualize the huffman tree.
+You have to install graphviz before.
+
+All you need to do is to optionally add some options to the encode_file and decode_file method :
+
+
+```ruby
+Huffman.encode_text(txt, tree_picture: true, tree_path: "my_trees/the_tree")     # or
+Huffman.encode_file(file_name, tree_picture: true, tree_path: "my_trees/the_tree") 
+```
+
+## Contributing
+
+1. Fork it
+2. Create your feature branch (`git checkout -b my-new-feature`)
+3. Commit your changes (`git commit -am 'Add some feature'`)
+4. Push to the branch (`git push origin my-new-feature`)
+5. Create new Pull Request

data/Rakefile

@@ -0,0 +1,13 @@
+require "bundler/gem_tasks"
+require "rspec/core/rake_task"
+
+RSpec::Core::RakeTask.new
+
+task :default => :spec
+task :test => :spec
+
+
+desc "Open an irb session preloaded with this library"
+task :console do
+  sh "irb -rubygems -I lib -r huffman.rb"
+end

data/huffman.gemspec

@@ -0,0 +1,29 @@
+# coding: utf-8
+lib = File.expand_path('../lib', __FILE__)
+$LOAD_PATH.unshift(lib) unless $LOAD_PATH.include?(lib)
+require 'huffman/version'
+
+Gem::Specification.new do |spec|
+  spec.name          = "huffman"
+  spec.version       = Huffman::VERSION
+  spec.authors       = ["Martin Lagrange", "Bastien Jorge"]
+  spec.email         = ["lagrangemartin@gmail.com", "bastien.jorge@gmail.com"]
+  spec.summary       = %q{Encode and decode a text using the Huffman encoding compression algorithm.}
+  spec.description   = %q{This gem allow you to encode and decode a text using the Huffman encoding compression algorithm. It can also generate and visualize the huffman tree as a png file.}
+  spec.homepage      = "http://github.com/lagrangemartin/huffman"
+  spec.license       = "MIT"
+
+  spec.files         = `git ls-files`.split($/)
+  spec.executables   = spec.files.grep(%r{^bin/}) { |f| File.basename(f) }
+  spec.test_files    = spec.files.grep(%r{^(test|spec|features)/})
+  spec.require_paths = ["lib"]
+
+  spec.add_development_dependency "bundler", "~> 1.3"
+  spec.add_development_dependency "rake"
+  spec.add_development_dependency "rspec"
+
+  spec.add_dependency "activesupport"
+  spec.add_dependency "ruby-graphviz"
+  spec.add_dependency "PriorityQueue"
+
+end

data/lib/huffman.rb

@@ -0,0 +1,79 @@
+# encoding: utf-8
+require 'active_support/all'
+require "huffman/version"
+require "huffman/letter_frequency"
+require "huffman/binary_stream"
+require "huffman/node"
+require "huffman/tree"
+require "huffman/log"
+
+
+module Huffman
+	# Caractère fin de transmission
+	EOT = 3.chr
+
+	extend self
+
+	def encode_text(txt, options={})
+		
+		options[:tree_picture] ||= false
+		options[:tree_path] ||= "tree"
+
+		frequencies = LetterFrequency.get_frequencies(txt)
+		tree = Tree.new(frequencies)
+		dictionnary = tree.dictionnary
+		tree.display_as_png(options[:tree_path]) if options[:tree_picture]
+		encoded_text = BinaryStream.get_bits_from_text(txt,dictionnary)	 
+		return encoded_text, dictionnary
+	
+	end
+
+	def decode_text(encoded_text,dictionnary)
+		BinaryStream.get_text_from_bits(encoded_text,dictionnary)
+	end
+
+	def encode_file(file_path, options = {})
+		
+		options[:tree_path] ||= file_path
+		txt = File.read(file_path).encode('UTF-8', :invalid => :replace)
+		txt = txt + EOT # On ajoute le marqueur EOT (enf of transmission 003)
+		encoded_text, dictionnary = encode_text(txt,options)	
+		encoded_file_name =file_path+".huffman-encoded"
+	
+		
+		File.open(encoded_file_name, 'wb' ){|f| f.write [encoded_text].pack("B*") }
+
+		dictionnary_stream = dictionnary.collect { |bin, char| bin+"\t"+char }.join('')
+
+		dictionnary_file_name = file_path+".huffman-dictionnary"
+		File.open(dictionnary_file_name, 'wb' ){|f| f.write dictionnary_stream }
+		
+		nil
+	end
+
+	def decode_file(file_path, dictionnary_file_path)
+		dictionnary, bits_buffer, next_char_is_the_symbol = {}, '',false
+
+		File.read(dictionnary_file_path).each_char do |c|
+			if c == "\t" 
+				next_char_is_the_symbol = true
+			elsif next_char_is_the_symbol
+				dictionnary[bits_buffer] = c
+				bits_buffer.clear
+				next_char_is_the_symbol = false
+			else
+				bits_buffer += c
+			end
+		end
+
+		encoded_text = File.read(file_path).unpack("B*").join
+		original_text = decode_text(encoded_text,dictionnary)
+		File.open(file_path+"-back-to-original", 'wb' ){|f| f.write original_text }
+		nil
+	end
+
+
+
+
+
+end

data/lib/huffman/binary_stream.rb

@@ -0,0 +1,26 @@
+module Huffman
+	module BinaryStream
+		extend self
+
+		def get_bits_from_text(txt,dictionnary)
+			dictionnary = dictionnary.invert
+			txt.each_char.map{|char|  ; dictionnary[char]}.join
+		end
+
+		def get_text_from_bits(bits,dictionnary)
+			original_text = '' ; buffer = ''
+			bits.each_char do |bit| 
+				buffer += bit
+				# Si il y'a une correspondance
+				if dictionnary[buffer] 
+					 # Si c'est le marqueur de fin EOF 
+				     return original_text if dictionnary[buffer] == EOT
+				    
+					 original_text += dictionnary[buffer] 
+					 buffer.clear
+				end
+			end
+			original_text
+		end
+	end
+end

data/lib/huffman/letter_frequency.rb

@@ -0,0 +1,11 @@
+module Huffman
+	module LetterFrequency
+		extend self
+
+		def get_frequencies(txt)
+			frequencies = Hash.new(0)
+			txt.each_char{|char| frequencies[char] += 1 }
+			frequencies
+		end
+	end
+end

data/lib/huffman/log.rb

@@ -0,0 +1,21 @@
+require "logger"
+	module Huffman
+	extend self		
+		class Log < Logger
+		 private_class_method :new
+
+		  @@logger = nil
+
+		  def self.instance()
+		    @@logger = new 'huffman.log' unless @@logger
+		    @@logger.datetime_format = "%d/%m %H:%M:%S:%6N"
+		    @@logger.formatter = proc do |severity, datetime, progname, msg|
+				  "#{datetime.strftime(@@logger.datetime_format)}: #{msg}\n"
+				end
+		    @@logger
+		  end
+		end
+		def log
+			Log.instance
+		end
+end

data/lib/huffman/node.rb

@@ -0,0 +1,63 @@
+module Huffman
+	class Node
+	    attr_accessor :value, :binary_value, :symbol, :left, :right
+	    # Set the getters and setters
+
+	    def initialize(value=nil, symbol=nil, left=nil, right=nil)
+	    	# The value of the node can't be nil
+	    	raise StandardError.new "The value of the node cannot be nil" if not value
+	        @value, @symbol, @left, @right, @binary_value = value, symbol, left, right, ''
+	    end
+
+
+	    # Le parametre &block signifie qu'on peut passer en paramètre de la fonction un bloc de codes
+	    # Soit en créeant un objet Proc.new avec du code, ou soit un lambda et en le passant en parametre => visit(:order)
+	    # Ou encore directement un bloc comme : visit{|node| puts node.value}
+	    # Ce bloc vas servir de visiteur et va permettre d'effectuer une action sur le bloc visité avec le mot clé "yield"
+
+	    def visit(order=:preorder, &block)
+
+	    	raise StandardError.new "Wrong order" if not [:preorder,:inorder,:postorder].include?(order)
+	    	case order
+	    		when :preorder 
+            		yield self
+            		@left.visit(order, &block) if left
+            		@right.visit(order, &block) if right
+        		when :inorder
+        			@left.visit(order, &block) if left
+        			yield self
+            		@right.visit(order, &block) if right
+        		when :postorder
+            		@left.visit(order, &block) if left
+            		@right.visit(order, &block) if right
+            		yield self
+            end
+	    end
+
+	    # Invokes the given block once for each node visited
+        # Creates a new array containing the values returned by the block.
+
+	    def visit_and_map(order=:preorder, &block)
+	    	array = []
+	    	visit(order){|node| array << yield(node)}
+	    	array
+	    end
+
+	    # Parcours les noeuds pour leur donner leur valeur binaire de Huffman 
+	    # Peut invoquer une action sur chaque noeud visité
+
+	    def set_binary_values(&block)
+	    	[@left,@right].each_with_index do |node,bit_value| 
+	    		if node
+	    			node.binary_value = @binary_value + bit_value.to_s
+		        	yield node if block_given?
+		       		node.set_binary_values(&block)
+	    		end
+	    	end
+	    end
+
+	    def leaf?
+	    	(not @left and not @right)
+	    end
+	end
+end

data/lib/huffman/tree.rb

@@ -0,0 +1,83 @@
+#coding: utf-8
+require 'priority_queue'
+require 'graphviz'
+
+
+module Huffman
+	class Tree
+
+		# Methodes délégués au noeud racine
+
+		delegate :visit,
+				 :visit_and_map,
+				 :set_binary_values, 
+				 :to => :@root
+
+		def initialize(frequencies)
+
+			# Liste de noeuds feuilles toujours triés par ordre croissant qui vont nous permettre de créer l'arbre de Huffman
+			nodes = PriorityQueue.new	
+
+			frequencies.map{ |freq| nodes.push(Node.new(freq[1], freq[0]), freq[1]) }
+
+			# Tant qu'il y'a pas plus qu'un seul noeud dans la liste
+			until nodes.length == 1
+				# 1) On créer un noeud dont ses fils sont les deux premiers noeuds du tableau triés de noeud et la valeur leur somme	
+				# On enlève les deux premiers noeuds
+				node1, node2 = nodes.delete_min.first, nodes.delete_min.first
+				# On créer un noeud parent
+				parent = Node.new(node1.value+node2.value,nil,node1,node2)
+				# 2) On ajoute le noeud à la liste 
+				nodes.push(parent, parent.value) 
+			end	
+			@root = nodes.delete_min.first
+			set_binary_values 
+		end
+
+		# On récupére la table de correspondance
+		def dictionnary
+			h = {}
+			#set_binary_values{|node| h[node.binary_value] = node.symbol if node.symbol}
+			# Equivalent mais plus rapide que :
+			# set_binary_values 
+			visit(:postorder){|node| h[node.binary_value] = node.symbol if node.symbol }
+			h
+		end
+
+
+		def display_as_png(path="tree")
+			# Create a new graph
+			g = GraphViz.new(:G)
+			visit(:postorder) do |node|
+				# C'est un noeud parent inventé
+				color = node.symbol ? "yellow" : "red"
+				symbol = case node.symbol
+					when EOT
+						"EOT"
+					when "\t"
+						"TAB"
+					when "\b"
+						"BACKSPACE"
+					when " "
+						"WHITESPACE"
+					when "\n"
+						"LINE RETURN"		
+					else 
+						"#{node.symbol ? node.symbol : ""}"
+				end
+
+				label = "#{node.value}"
+				label += "➠#{node.binary_value}" if not node.binary_value == '' 
+				label += "➡︎#{symbol}" if node.symbol
+
+				graphviz_node = g.add_nodes(node.__id__.to_s, label: label, "style" => "filled", "color" => color )
+				# On créer les arretes de ses enfants
+				g.add_edges(graphviz_node, g.get_node(node.left.__id__.to_s)) if node.left
+				g.add_edges(graphviz_node, g.get_node(node.right.__id__.to_s)) if node.right
+
+			end
+			g.output( :png => "#{path}.png" )
+
+		end
+	end
+end