chars 0.2.0 → 0.2.4

data/lib/chars/char_set.rb

@@ -1,28 +1,85 @@
 require 'set'
 
 module Chars
-  class CharSet < SortedSet
+  class CharSet < Set
 
     #
     # Creates a new CharSet object.
     #
-    # @param [Array<String, Integer, Range>] chars
+    # @param [Array<String, Integer, Enumerable>] arguments
     #   The chars for the CharSet.
     #
-    def initialize(*chars)
+    # @raise [TypeError]
+    #   One of the arguments was not a {String}, {Integer} or `Enumerable`.
+    #
+    def initialize(*arguments)
       super()
 
-      merge_chars = lambda { |element|
-        if element.kind_of?(String)
-          element.each_byte(&merge_chars)
-        elsif element.kind_of?(Integer)
-          self << element
-        elsif element.kind_of?(Enumerable)
-          element.each(&merge_chars)
+      @chars = Hash.new { |hash,key| hash[key] = key.chr(Encoding::UTF_8) }
+
+      arguments.each do |subset|
+        case subset
+        when String, Integer
+          self << subset
+        when Enumerable
+          subset.each { |char| self << char }
+        else
+          raise(TypeError,"arguments must be a String, Integer or Enumerable")
+        end
+      end
+    end
+
+    #
+    # Initializes the copy of another {CharSet} object.
+    #
+    # @param [CharSet] other
+    #   The other {CharSet} object.
+    #
+    def initialize_copy(other)
+      @chars = other.instance_variable_get('@chars').dup
+    end
+
+    #
+    # Creates a new {CharSet}.
+    #
+    # @see #initialize
+    #
+    # @since 0.2.1
+    #
+    def self.[](*arguments)
+      new(*arguments)
+    end
+
+    #
+    # Adds a character to the set.
+    #
+    # @param [String, Integer] other
+    #   The character(s) or byte to add.
+    #
+    # @return [CharSet]
+    #   The modified character set.
+    #
+    # @raise [TypeError]
+    #   The argument was not a {String} or {Integer}.
+    #
+    # @since 0.2.1
+    #
+    def <<(other)
+      case other
+      when String
+        other.each_char do |char|
+          byte = char.ord
+
+          @chars[byte] = char
+          super(byte)
         end
-      }
 
-      merge_chars.call(chars)
+        return self
+      when Integer
+        super(other)
+      else
+        raise(TypeError,"can only append Strings and Integers")
+      end
     end
 
     alias include_byte? include?
@@ -32,100 +89,104 @@ module Chars
     alias map_bytes map
 
     #
-    # Determines if a character is contained within the character set.
+    # Determines if a character is contained within the {CharSet}.
     #
     # @param [String] char
     #   The character to search for.
     #
     # @return [Boolean]
     #   Specifies whether the character is contained within the
-    #   character set.
+    #   {CharSet}.
     #
     def include_char?(char)
-      if char.respond_to?(:each_byte)
-        char.each_byte.any? { |b| include?(b) }
+      unless char.empty?
+        @chars.has_value?(char) || include_byte?(char.ord)
       else
         false
       end
     end
 
     #
-    # The characters within the character set.
+    # The characters within the {CharSet}.
     #
     # @return [Array<String>]
-    #   All the characters within the character set.
+    #   All the characters within the {CharSet}.
     #
     def chars
-      map { |b| b.chr }
+      map { |byte| @chars[byte] }
     end
 
     #
-    # Iterates over every character within the character set.
+    # Iterates over every character within the {CharSet}.
     #
     # @yield [char]
     #   If a block is given, it will be passed each character in the
-    #   character set.
+    #   {CharSet}.
     #
     # @yieldparam [String] char
-    #   Each character in the character set.
+    #   Each character in the {CharSet}.
     #
     # @return [Enumerator]
     #   If no block is given, an enumerator object will be returned.
     #
     def each_char
-      return enum_for(:each_char) unless block_given?
+      return enum_for(__method__) unless block_given?
 
-      each { |b| yield b.chr }
+      each { |byte| yield @chars[byte] }
     end
 
     #
-    # Selects characters from the character set.
+    # Selects characters from the {CharSet}.
     #
     # @yield [char]
     #   If a block is given, it will be used to select the characters
-    #   from the character set.
+    #   from the {CharSet}.
     #
     # @yieldparam [String] char
     #   The character to select or reject.
     #
     # @return [Array<String>]
-    #   The selected characters from the character set.
+    #   The selected characters from the {CharSet}.
     #
     def select_chars(&block)
-      chars.select(&block)
+      each_char.select(&block)
     end
 
     #
-    # Maps the characters of the character set.
+    # Maps the characters of the {CharSet}.
     #
     # @yield [char]
     #   The given block will be used to transform the characters within
-    #   the character set.
+    #   the {CharSet}.
     #
     # @yieldparam [String] char
-    #   Each character in the character set.
+    #   Each character in the {CharSet}.
     #
     # @return [Array<String>]
-    #   The mapped characters of the character set.
+    #   The mapped characters of the {CharSet}.
     #
     def map_chars(&block)
-      chars.map(&block)
+      each_char.map(&block)
     end
 
+    #
+    # Returns a random byte from the {CharSet}.
     #
     # @return [Integer]
-    #   A random byte from the character set.
+    #   A random byte value.
     #
     def random_byte
       self.entries[rand(self.length)]
     end
 
+    #
+    # Returns a random character from the {CharSet}.
     #
     # @return [String]
-    #   A random char from the character set.
+    #   A random char value.
     #
     def random_char
-      random_byte.chr
+      @chars[random_byte]
     end
 
     #
@@ -138,13 +199,13 @@ module Chars
     #   The block will receive the random bytes.
     #
     # @yieldparam [Integer] byte
-    #   The random byte from the character set.
+    #   The random byte from the {CharSet}.
     #
     # @return [Enumerator]
     #   If no block is given, an enumerator object will be returned.
     #
     def each_random_byte(n,&block)
-      return enum_for(:each_random_byte,n) unless block_given?
+      return enum_for(__method__,n) unless block_given?
 
       n.times { yield random_byte }
       return nil
@@ -160,19 +221,19 @@ module Chars
     #   The block will receive the random characters.
     #
     # @yieldparam [String] char
-    #   The random character from the character set.
+    #   The random character from the {CharSet}.
     #
     # @return [Enumerator]
     #   If no block is given, an enumerator object will be returned.
     #
     def each_random_char(n,&block)
-      return enum_for(:each_random_char,n) unless block_given?
+      return enum_for(__method__,n) unless block_given?
 
-      each_random_byte(n) { |b| yield b.chr }
+      each_random_byte(n) { |byte| yield @chars[byte] }
     end
 
     #
-    # Creates an Array of random bytes from the character set.
+    # Creates an Array of random bytes from the {CharSet}.
     #
     # @param [Integer, Array, Range] length
     #   The length of the Array of random bytes.
@@ -181,15 +242,18 @@ module Chars
     #   The randomly selected bytes.
     #
     def random_bytes(length)
-      if (length.kind_of?(Array) || length.kind_of?(Range))
-        Array.new(length.sort_by { rand }.first) { random_byte }
+      case length
+      when Array
+        Array.new(length.sample) { random_byte }
+      when Range
+        Array.new(rand(length)) { random_byte }
       else
         Array.new(length) { random_byte }
       end
     end
 
     #
-    # Creates an Array of random non-repeating bytes from the character set.
+    # Creates an Array of random non-repeating bytes from the {CharSet}.
     #
     # @param [Integer, Array, Range] length
     #   The length of the Array of random non-repeating bytes.
@@ -198,15 +262,20 @@ module Chars
     #   The randomly selected non-repeating bytes.
     #
     def random_distinct_bytes(length)
-      if (length.kind_of?(Array) || length.kind_of?(Range))
-        self.entries.sort_by { rand }.slice(0...(length.sort_by { rand }.first))
+      shuffled_bytes = bytes.shuffle
+
+      case length
+      when Array
+        shuffled_bytes[0,length.sample]
+      when Range
+        shuffled_bytes[0,rand(length)]
       else
-        self.entries.sort_by { rand }.slice(0...length) 
+        shuffled_bytes[0,length]
       end
     end
 
     #
-    # Creates an Array of random characters from the character set.
+    # Creates an Array of random characters from the {CharSet}.
     #
     # @param [Integer, Array, Range] length
     #   The length of the Array of random characters.
@@ -215,12 +284,12 @@ module Chars
     #   The randomly selected characters.
     #
     def random_chars(length)
-      random_bytes(length).map { |b| b.chr }
+      random_bytes(length).map { |byte| @chars[byte] }
     end
 
     #
     # Creates a String containing randomly selected characters from the
-    # character set.
+    # {CharSet}.
     #
     # @param [Integer, Array, Range] length
     #   The length of the String of random characters.
@@ -236,7 +305,7 @@ module Chars
 
     #
     # Creates an Array of random non-repeating characters from the
-    # character set.
+    # {CharSet}.
     #
     # @param [Integer, Array, Range] length
     #   The length of the Array of random non-repeating characters.
@@ -245,12 +314,12 @@ module Chars
     #   The randomly selected non-repeating characters.
     #
     def random_distinct_chars(length)
-      random_distinct_bytes(length).map { |b| b.chr }
+      random_distinct_bytes(length).map { |byte| @chars[byte] }
     end
 
     #
     # Creates a String containing randomly selected non-repeating
-    # characters from the character set.
+    # characters from the {CharSet}.
     #
     # @param [Integer, Array, Range] length
     #   The length of the String of random non-repeating characters.
@@ -264,10 +333,9 @@ module Chars
       random_distinct_chars(length).join
     end
 
-
     #
     # Finds sub-strings within given data that are made of characters within
-    # the character set.
+    # the {CharSet}.
     #
     # @param [String] data
     #   The data to find sub-strings within.
@@ -283,77 +351,108 @@ module Chars
     #   sub-strings within the data, or to just return the matched
     #   sub-strings themselves.
     #
-    def strings_in(data,options={})
-      min_length = (options[:length] || 4)
+    # @yield [match,(index)]
+    #   The given block will be passed every matched sub-string, and the
+    #   optional index.
+    #
+    # @yield [String] match
+    #   A sub-string containing the characters from the {CharSet}.
+    #
+    # @yield [Integer] index
+    #   The index the sub-string was found at.
+    #
+    # @return [Array, Hash]
+    #   If no block is given, an Array or Hash of sub-strings is returned.
+    #
+    def strings_in(data,options={},&block)
+      unless block
+        if options[:offsets]
+          found = {}
+          block = lambda { |offset,substring| found[offset] = substring }
+        else
+          found = []
+          block = lambda { |substring| found << substring }
+        end
 
-      if options[:offsets]
-        found = {}
-        found_substring = lambda { |offset,substring|
-          found[offset] = substring
-        }
-      else
-        found = []
-        found_substring = lambda { |offset,substring|
-          found << substring
-        }
+        strings_in(data,options,&block)
+        return found
       end
 
-      return found if data.length < min_length
+      min_length = options.fetch(:length,4)
+      return if data.length < min_length
 
       index = 0
 
       while index <= (data.length - min_length)
-        if self === data[index...(index + min_length)]
+        if self === data[index,min_length]
           sub_index = (index + min_length)
 
-          while self.include_char?(data[sub_index..sub_index])
+          while self.include_char?(data[sub_index,1])
             sub_index += 1
           end
 
-          found_substring.call(index,data[index...sub_index])
+          match = data[index...sub_index]
+
+          case block.arity
+          when 2
+            yield match, index
+          else
+            yield match
+          end
+
           index = sub_index
         else
           index += 1
         end
       end
-
-      return found
     end
 
     #
-    # Creates a new CharSet object by unioning the character set with
-    # another character set.
+    # Creates a new CharSet object by unioning the {CharSet} with another
+    # {CharSet}.
     #
-    # @param [CharSet, Array, Range] other_set
-    #   The other character set to union with.
+    # @param [CharSet, Array, Range] set
+    #   The other {CharSet} to union with.
     #
     # @return [CharSet]
-    #   The unioned character sets.
+    #   The unioned {ChraSet}.
     #
-    def |(other_set)
-      super(CharSet.new(other_set))
+    def |(set)
+      set = CharSet.new(set) unless set.kind_of?(CharSet)
+
+      return super(set)
     end
 
     alias + |
 
     #
     # Compares the bytes within a given string with the bytes of the
-    # character set.
+    # {CharSet}.
     #
-    # @param [String] string
-    #   The string to compare with the character set.
+    # @param [String, Enumerable] other
+    #   The string to compare with the {CharSet}.
     #
     # @return [Boolean]
     #   Specifies whether all of the bytes within the given string are
-    #   included in the character set.
+    #   included in the {CharSet}.
     #
     # @example
     #   Chars.alpha === "hello"
     #   # => true
     #
-    def ===(string)
-      if string.respond_to?(:each_byte)
-        string.each_byte.all? { |b| include?(b) }
+    def ===(other)
+      case other
+      when String
+        other.each_char.all? { |char| include_char?(char) }
+      when Enumerable
+        other.all? do |element|
+          case element
+          when String
+            include_char?(element)
+          when Integer
+            include_byte?(element)
+          end
+        end
       else
         false
       end
@@ -362,22 +461,22 @@ module Chars
     alias =~ ===
 
     #
-    # Inspects the character set.
+    # Inspects the {CharSet}.
     #
     # @return [String]
-    #   The inspected character set.
+    #   The inspected {CharSet}.
     #
     def inspect
-      "#<#{self.class.name}: {" + map { |b|
-        case b
+      "#<#{self.class.name}: {" + map { |byte|
+        case byte
         when (0x07..0x0d), (0x20..0x7e)
-          b.chr.dump
+          @chars[byte].dump
         when 0x00
           # sly hack to make char-sets more friendly
           # to us C programmers
           '"\0"'
         else
-          "0x%02x" % b
+          sprintf("0x%02x",byte)
         end
       }.join(', ') + "}>"
     end