char_tree 1.0.0

data/MIT-LICENSE

@@ -0,0 +1,20 @@
+Copyright 2012 Miguel Adolfo Barroso
+
+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,3 @@
+= CharTree
+
+This project rocks and uses MIT-LICENSE.

data/Rakefile

@@ -0,0 +1,9 @@
+require 'bundler'
+Bundler::GemHelper.install_tasks
+
+task :default => :test
+
+desc "Run all tests"
+task :test do
+  exec "rspec --color"
+end

data/lib/char_tree.rb

@@ -0,0 +1,2 @@
+require File.expand_path('../char_tree/node', __FILE__)
+require File.expand_path('../char_tree/dictionary', __FILE__)

data/lib/char_tree/dictionary.rb

@@ -0,0 +1,292 @@
+# encoding: utf-8
+module CharTree
+  class Dictionary
+    def initialize(file = false)
+    	@callbacks 	    = {}
+    	@f 					    = false
+    	@first 			    = nil
+    	@size 			    = 0
+    	@n					    = 0
+    	@results		    = []
+    	@searching      = false
+    	@use_set        = false
+    	@set_chars      = {}
+      @pattern        = '*'
+
+    	if file
+    		@file = file
+    	else
+    		root = File.expand_path('../../..', __FILE__)
+    		@file = "#{root}/tmp/dictionary.bda"
+    	end
+    	pattern
+    end
+
+		# File management
+		def file_path
+			@file
+		end
+
+    def delete
+    	File.delete(@file) if File.file?(@file)
+  	end
+
+    def create
+    	return if @f
+    	delete
+    	@f = File.new(@file, "w+b")
+    	n = create_node
+    	write n
+    	close
+  	end
+
+  	def open
+  	  return if @f
+			@f = File.new(@file, "r+b")
+			first
+  	end
+
+  	def close
+  		@f.close if @f
+  		@f = false
+  		@first = nil
+  	end
+
+		def empty?
+			File.zero?(@file)
+		end
+
+    # Callbacks
+    $callbacks = {}
+
+ 	  def self.event(name, method_name)
+ 	  	$callbacks[name] = [] unless $callbacks[name]
+      $callbacks[name] << method_name
+		end
+    # Callbacks end
+
+
+		# Words
+		def add(word)
+		  return unless @f
+			add_char(encode(word).split(""), @first)
+		end
+
+		# Search
+		def use_set
+			@use_set = true
+		end
+
+		def no_use_set
+			@use_set = false
+		end
+
+		def use_set?
+			@use_set
+		end
+
+		def set(chars = [])
+			use_set
+			@set_chars = {}
+			chars.each do |c|
+        c = '8' if (c  == 'CH')
+        c = '1' if (c  == 'LL')
+        c = '4' if (c  == 'RR')
+				@set_chars[c] = @set_chars[c] ? @set_chars[c] + 1 : 1
+			end
+		end
+
+		def pattern(pattern = '*')
+		  @pattern = "^#{pattern}$"
+		  @pattern = @pattern.gsub('*', '.*')
+		  @pattern = @pattern.gsub('?', '.')
+      @pattern = @pattern.gsub('CH', '8')
+      @pattern = @pattern.gsub('LL', '1')
+      @pattern = @pattern.gsub('RR', '4')
+		end
+
+
+		def search(min = 1, max = 999)
+		  return unless @f
+			return if searching?
+			decode(search_next_chars(@first, '', min, max))
+		end
+
+		def search_all(min = 1, max = 999)
+		  return unless @f
+			return if searching?
+			@searching = true
+			search_next_chars(@first, '', min, max)
+			@searching = false
+		end
+
+		# Results
+		def searching?
+			@searching
+		end
+
+		def results?
+			@results.count > 0
+		end
+
+		def total_results
+			@results.count
+		end
+
+		def next_result
+			@results.shift
+		end
+
+		private
+    def encode(word)
+      word = word.upcase
+      word = word.gsub('CH', '8')
+      word = word.gsub('LL', '1')
+      word = word.gsub('RR', '4')
+      word
+    end
+
+    def decode(word)
+      return false unless word
+      word = word.gsub('8', 'CH')
+      word = word.gsub('1', 'LL')
+      word = word.gsub('4', 'RR')
+      word
+    end
+
+		# Results
+		def add_result(word)
+		  word = decode(word)
+			@results << word
+			run_event_for	:found, word
+		end
+
+    # Callbacks
+    def run_event_for(name, *args)
+    	return unless $callbacks[name.to_sym]
+      $callbacks[name.to_sym].each do |callback|
+        if callback.kind_of? Symbol
+          self.send(callback, *args)
+        else
+          self.instance_exec(*args, &callback)
+        end
+      end
+    end
+    # Callbacks end
+
+		# Nodes
+		def first
+			return if @first
+  		@size  = CharTree::SIZE
+			@n = File.size(@file) / @size
+			@first = read
+		end
+
+		def write(node)
+		  @f.seek(@size*node.id-@size, IO::SEEK_SET)
+			@f.write node.to_b
+		end
+
+		def read(id = 1)
+		  @f.seek(@size*id-@size, IO::SEEK_SET)
+		  node = CharTree::Node.new
+			node.from_b(@f.read(@size))
+			node
+		end
+
+		def create_node(up = 0, up_position = 0)
+			@n += 1
+      node = CharTree::Node.new(@n, up, up_position)
+    end
+
+		def add_char(chars, node = @first, save = false)
+			c = chars.shift
+      node.go_for c
+      if chars.count > 0
+        if node.down > 0
+          return add_char(chars, read(node.down))
+        else
+          new_node = create_node(node.id, node.position)
+          node.down = new_node.id
+          add_char(chars, new_node, true)
+          save = true
+        end
+      else
+        save = true unless node.complete?
+        node.complete
+      end
+
+      write node if save
+      return save
+		end
+
+    def undo_set(char, return_value)
+      if use_set? && char && @set_chars[char]
+        @set_chars[char] = @set_chars[char] + 1
+      end
+      return_value
+    end
+
+    def do_set(char, ignore_wildcard = false)
+      if (!ignore_wildcard && @set_chars[' '] && @set_chars[' '] > 0)
+        @set_chars[' '] -= 1
+        return ' '
+      end
+      if (@set_chars[char] && @set_chars[char] > 0)
+        @set_chars[char] -= 1
+        return char
+      end
+      return false
+    end
+
+		def search_next_chars(node = @first, word = '', min = 1, max = 999)
+		  return false unless node.first_char
+      return search_next_chars_by_alternate(node, word, min, max)
+	  end
+
+    def search_next_chars_by_alternate(node, word, min, max, wildcard = false)
+    	if use_set? && !wildcard
+    	  set_char = do_set(node.chr)
+        if set_char == ' '
+          position = node.position
+          new_word = search_next_chars_by_alternate(node, word, min, max, true)
+          undo_set(set_char, false)
+          node.go position
+          if new_word && !searching?
+            return new_word
+          end
+          set_char = do_set(node.chr, true)
+     		end
+    		unless set_char
+				  return undo_set(set_char, false) unless node.next_char
+		      return undo_set(set_char, search_next_chars_by_alternate(node, word, min, max))
+   			end
+   		else
+   		  set_char = false
+   		end
+
+      current_word = word + node.chr
+      return undo_set(set_char, false) if current_word.length > max
+      if node.complete? && current_word.length >= min
+        if current_word.match(@pattern)
+        	if searching?
+        		add_result current_word
+        	else
+        		return undo_set(set_char, current_word)
+        	end
+        end
+      end
+
+      if node.down?
+        new_word = search_next_chars(read(node.down), current_word, min, max)
+        if new_word && (new_word.match(@pattern) == nil)
+          new_word = false
+        end
+        return undo_set(set_char, new_word) if new_word
+      end
+		  return undo_set(set_char, false) unless node.next_char
+		  undo_set(set_char, false)
+      return search_next_chars_by_alternate(node, word, min, max, wildcard)
+    end
+  end
+end

data/lib/char_tree/node.rb

@@ -0,0 +1,230 @@
+# encoding: utf-8
+module CharTree
+
+  CHARS  		= 30
+  MAX    		= CHARS - 1
+  BYTES_L 	= 4
+  BYTES_C 	= 1
+  GROUPS_L 	= 2
+  GROUPS_C 	= 1
+  SIZE	 		= 2 * BYTES_L + 1 * BYTES_C + CHARS * BYTES_L * GROUPS_L + CHARS * BYTES_C * GROUPS_C
+
+  class Node
+	  def initialize(id = 0, up = 0, up_position = 0, complete = 0, down = 0, down_position = 0)
+	    @current 				= 0
+	    @id							= id
+			@up   					= up
+			@up_position  	= up_position
+		  @complete 			= [complete]*CHARS
+			@down 					= [down]*CHARS
+			@down_position 	= [down_position]*CHARS
+	  end
+
+	  def size
+	    SIZE
+	  end
+
+    def first
+      @current = 0
+    end
+
+    def last
+      @current = MAX
+    end
+
+    def next
+      @current += 1
+      if @current > MAX
+        @current = MAX
+        return false
+      end
+      return true
+    end
+
+    def next?
+    	@current < MAX
+  	end
+
+    def previous
+      @current -= 1
+      if @current < 0
+        @current = 0
+        return false
+      end
+      return true
+    end
+
+    def previous?
+    	@current > 0
+  	end
+
+    def current
+    	@current
+  	end
+
+    def position
+    	@current
+  	end
+
+    def next_char
+      previous_current = @current
+      return false unless next?
+      self.next
+      return true if down? || complete?
+      return true if next_char
+      @current = previous_current
+      return false
+    end
+
+    def previous_char
+      previous_current = @current
+      return false unless previous?
+      self.previous
+      return true if down? || complete?
+      return true if previous_char
+      @current = previous_current
+      return false
+    end
+
+    def first_char
+      previous_current = @current
+      self.first
+      return true if down? || complete?
+      return true if next_char
+      @current = previous_current
+      return false
+    end
+
+    def last_char
+      previous_current = @current
+      self.last
+      return true if down? || complete?
+      return true if previous_char
+      @current = previous_current
+      return false
+    end
+
+    def position_for(char)
+      c = char.capitalize[0]
+      return MAX - 3  if c == '8' # Ch
+      return MAX - 2  if c == '1' # Ll
+      return MAX - 1  if c == '4' # Rr
+      p = c.ord - 65
+      p = MAX if p > MAX
+      p
+  	end
+
+    def go(position)
+      @current = position if position <= MAX
+    end
+
+    def go_for(char)
+      @current = position_for(char)
+    end
+
+    def chr
+    	chr_for(@current)
+    end
+
+    def chr_for(position)
+      return '8' if position == MAX - 3 # Ch
+      return '1' if position == MAX - 2 # Ll
+      return '4' if position == MAX - 1 # Rr
+      return 'Ñ' if position == MAX
+      return (65+position).chr
+    end
+
+	  def id=(id)
+	  	@id = up
+	  end
+
+	  def id
+	  	@id
+	  end
+
+	  def complete
+	  	@complete[@current] = 1
+	  end
+
+	  def not_complete
+	  	@complete[@current] = 0
+	  end
+
+	  def complete?
+	  	@complete[@current] > 0
+	  end
+
+	  def up=(up)
+	  	@up = up
+	  end
+
+	  def up
+	  	@up
+	  end
+
+	  def up_position=(up_position)
+	  	@up_position = up_position
+	  end
+
+	  def up_position
+	  	@up_position
+	  end
+
+	  def down=(down)
+	  	@down[@current] = down
+	  end
+
+	  def down
+	  	@down[@current]
+	  end
+
+	  def down?
+	  	@down[@current] > 0
+	  end
+
+	  def down_position=(down_position)
+	  	@down_position[@current] = down_position
+	  end
+
+	  def down_position
+	  	@down_position[@current]
+	  end
+
+    def to_b
+    	d  = [@id].pack("L")
+      d += [@up].pack("L")
+      d += [@up_position].pack("C")
+      d += array_to_b :L, @complete
+      d += array_to_b :L, @down
+      d += array_to_b :C, @down_position
+      d
+    end
+
+    def from_b(binary)
+    	@id       			= binary[BYTES_L*0..BYTES_L*1+BYTES_C*0].unpack("L")[0]
+			@up   					= binary[BYTES_L*1..BYTES_L*2+BYTES_C*0].unpack("L")[0]
+			@up_position  	= binary[BYTES_L*2..BYTES_L*2+BYTES_C*1].unpack("C")[0]
+		  @complete 			= array_from_b :L, BYTES_L, binary[(BYTES_L*2+BYTES_C+CHARS*BYTES_L*0+CHARS*BYTES_C*0)..(BYTES_L*2+BYTES_C+CHARS*BYTES_L*1+CHARS*BYTES_C*0-1)]
+			@down 					= array_from_b :L, BYTES_L, binary[(BYTES_L*2+BYTES_C+CHARS*BYTES_L*1+CHARS*BYTES_C*0)..(BYTES_L*2+BYTES_C+CHARS*BYTES_L*2+CHARS*BYTES_C*0-1)]
+			@down_position 	= array_from_b :C, BYTES_C, binary[(BYTES_L*2+BYTES_C+CHARS*BYTES_L*2+CHARS*BYTES_C*0)..(BYTES_L*2+BYTES_C+CHARS*BYTES_L*2+CHARS*BYTES_C*1-1)]
+    end
+
+    private
+    def array_to_b(type, array)
+      r = ''
+      array.each {|i|
+        r += [i].pack(type.to_s)
+      }
+      r
+    end
+
+    def array_from_b(type, size, binary)
+      array = []
+      CHARS.times do |i|
+        array << binary[(size*i)..(size*(i+1)-1)].unpack(type.to_s)[0]
+      end
+      array
+    end
+	end
+end
+

data/lib/char_tree/version.rb

@@ -0,0 +1,3 @@
+module CharTree
+  VERSION = "1.0.0"
+end

data/lib/tasks/char_tree_tasks.rake

@@ -0,0 +1,4 @@
+# desc "Explaining what the task does"
+# task :char_tree do
+#   # Task goes here
+# end

metadata

@@ -0,0 +1,64 @@
+--- !ruby/object:Gem::Specification
+name: char_tree
+version: !ruby/object:Gem::Version
+  version: 1.0.0
+  prerelease: 
+platform: ruby
+authors:
+- Miguel Adolfo Barroso
+autorequire: 
+bindir: bin
+cert_chain: []
+date: 2012-02-05 00:00:00.000000000Z
+dependencies:
+- !ruby/object:Gem::Dependency
+  name: rspec
+  requirement: &16837060 !ruby/object:Gem::Requirement
+    none: false
+    requirements:
+    - - ! '>='
+      - !ruby/object:Gem::Version
+        version: '0'
+  type: :development
+  prerelease: false
+  version_requirements: *16837060
+description: Dictionary functions for word permutation search.
+email:
+- mabarroso@mabarroso.com
+executables: []
+extensions: []
+extra_rdoc_files: []
+files:
+- lib/char_tree/version.rb
+- lib/char_tree/node.rb
+- lib/char_tree/dictionary.rb
+- lib/tasks/char_tree_tasks.rake
+- lib/char_tree.rb
+- MIT-LICENSE
+- Rakefile
+- README.rdoc
+homepage: https://github.com/mabarroso/char_tree
+licenses: []
+post_install_message: 
+rdoc_options: []
+require_paths:
+- lib
+required_ruby_version: !ruby/object:Gem::Requirement
+  none: false
+  requirements:
+  - - ! '>='
+    - !ruby/object:Gem::Version
+      version: '0'
+required_rubygems_version: !ruby/object:Gem::Requirement
+  none: false
+  requirements:
+  - - ! '>='
+    - !ruby/object:Gem::Version
+      version: '0'
+requirements: []
+rubyforge_project: 
+rubygems_version: 1.8.10
+signing_key: 
+specification_version: 3
+summary: Binary file dictionary for word permutation search.
+test_files: []