wordlist 0.1.1 → 1.0.1

data/lib/wordlist/modifiers/mutate.rb

@@ -0,0 +1,134 @@
+# frozen_string_literal: true
+require 'wordlist/modifiers/sub'
+
+module Wordlist
+  module Modifiers
+    #
+    # Lazily enumerates through every combination of a string substitution
+    # on every word in the wordlist.
+    #
+    # @since 1.0.0
+    #
+    class Mutate < Sub
+
+      #
+      # Enumerates over every mutation of every word in the wordlist.
+      #
+      # @yield [word]
+      #   The given block will be passed each mutation of each word.
+      #
+      # @yieldparam [String] word
+      #   A mutated word.
+      #
+      # @return [Enumerator]
+      #   If no block is given, an Enumerator object will be returned.
+      #
+      # @example
+      #   wordlist = Wordlist::Words["foo", "bar", "baz"]
+      #   wordlist.mutate(/[oa]/, {'o' => '0', 'a' => '@'}).each do |word|
+      #     puts word
+      #   end
+      #   # foo
+      #   # f0o
+      #   # fo0
+      #   # f00
+      #   # bar
+      #   # b@r
+      #   # baz
+      #   # b@z
+      #
+      # @api public
+      #
+      def each
+        return enum_for(__method__) unless block_given?
+
+        @wordlist.each do |word|
+          yield word
+
+          matches = all_matches(word)
+
+          each_combination(matches) do |selected_matches|
+            new_word = word.dup
+            offset   = 0
+
+            selected_matches.each do |match|
+              index, end_index = match.offset(0)
+              length = end_index - index
+
+              matched_string = match[0]
+              replace_string = substitute(matched_string)
+
+              new_word[index+offset,length] = replace_string
+
+              offset += (replace_string.length - length)
+            end
+
+            yield new_word
+          end
+        end
+      end
+
+      private
+
+      #
+      # Finds all matches of the {#pattern} within a string.
+      #
+      # @param [String] string
+      #   The given string.
+      #
+      # @return [Array<MatchData>]
+      #   The array of all found non-overlapping matches.
+      #
+      def all_matches(string)
+        offset  = 0
+        matches = []
+
+        while (match = string.match(@pattern,offset))
+          index, end_index = match.offset(0)
+
+          matches << match
+
+          offset = end_index
+        end
+
+        return matches
+      end
+
+      #
+      # Enumerates through every combination of every match.
+      #
+      # @param [Array<MatchData>] matches
+      #   The array of matches.
+      #
+      # @yield [matches]
+      #   The given block will be passed each combination of the matches.
+      #
+      # @yieldparam [Array<MatchData>] matches
+      #   A combination of the matches.
+      #
+      def each_combination(matches,&block)
+        (1..matches.length).each do |count|
+          matches.combination(count,&block)
+        end
+      end
+
+      #
+      # Returns the replacement string for a matched substring.
+      #
+      # @param [String] matched
+      #   The matched substring.
+      #
+      # @return [String]
+      #   The replacement string.
+      #
+      def substitute(matched)
+        case @replace
+        when Hash   then @replace[matched].to_s
+        when nil    then @block.call(matched)
+        else             @replace
+        end
+      end
+
+    end
+  end
+end

data/lib/wordlist/modifiers/mutate_case.rb

@@ -0,0 +1,26 @@
+# frozen_string_literal: true
+require 'wordlist/modifiers/mutate'
+
+module Wordlist
+  module Modifiers
+    #
+    # Lazily enumerates through every possible upper/lower-case variation of
+    # each word in the wordlist.
+    #
+    # @since 1.0.0
+    #
+    class MutateCase < Mutate
+
+      #
+      # Initializes the case mutator.
+      #
+      # @param [Enumerable] wordlist
+      #   The wordlist to modify.
+      #
+      def initialize(wordlist)
+        super(wordlist,/[[:alpha:]]/) { |letter| letter.swapcase }
+      end
+
+    end
+  end
+end

data/lib/wordlist/modifiers/sub.rb

@@ -0,0 +1,98 @@
+# frozen_string_literal: true
+require 'wordlist/modifiers/modifier'
+
+module Wordlist
+  module Modifiers
+    #
+    # Lazily calls `String#sub` on every word in the wordlist.
+    #
+    # @since 1.0.0
+    #
+    class Sub < Modifier
+
+      # The pattern to substitute.
+      #
+      # @return [Regexp, String]
+      attr_reader :pattern
+
+      # The replacement String or map of Strings.
+      #
+      # @return [String, Hash{String => String, nil}]
+      attr_reader :replace
+
+      # The optional block to call when replacing matched substrings.
+      #
+      # @return [Proc, nil]
+      attr_reader :block
+
+      #
+      # Initializes the `String#sub` modifier.
+      #
+      # @param [Regexp, String] pattern
+      #   The pattern to replace.
+      #
+      # @param [String, Hash, nil] replace
+      #   The characters or character range to use as the replacement.
+      #
+      # @yield [match]
+      #   The given block will be call to replace the matched substring,
+      #   if `replace` is nil.
+      #
+      # @yieldparam [String] match
+      #   A matched substring.
+      #
+      # @raise [TypeError]
+      #   The `replace` value was not a String, Hash, or `nil`.
+      #
+      def initialize(wordlist,pattern,replace=nil,&block)
+        super(wordlist)
+
+        @pattern = pattern
+        @replace = case replace
+                   when String, Hash, nil then replace
+                   else
+                     raise(TypeError,"no implicit conversion of #{replace.class} to String")
+                   end
+        @block   = block
+      end
+
+      #
+      # Enumerates over every `sub`ed word in the wordlist.
+      #
+      # @yield [word]
+      #   The given block will be passed each `sub`ed word.
+      #
+      # @yieldparam [String] word
+      #   A `sub`ed word.
+      #
+      # @return [Enumerator]
+      #   If no block is given, an Enumerator object will be returned.
+      #
+      # @example
+      #   wordlist = Wordlist::Words["foo", "bar", "baz"]
+      #   wordlist.sub(/o/, '0').each do |word|
+      #     puts word
+      #   end
+      #   # f0o
+      #   # bar
+      #   # baz
+      #
+      # @api public
+      #
+      def each
+        return enum_for(__method__) unless block_given?
+
+        if @replace
+          @wordlist.each do |word|
+            yield word.sub(@pattern,@replace)
+          end
+        else
+          @wordlist.each do |word|
+            yield word.sub(@pattern,&block)
+          end
+        end
+      end
+
+    end
+  end
+end

data/lib/wordlist/modifiers/tr.rb

@@ -0,0 +1,72 @@
+# frozen_string_literal: true
+require 'wordlist/modifiers/modifier'
+
+module Wordlist
+  module Modifiers
+    #
+    # Lazily calls `String#tr` on every word in the wordlist.
+    #
+    # @since 1.0.0
+    #
+    class Tr < Modifier
+
+      # The characters or character range to translate.
+      #
+      # @return [String]
+      attr_reader :chars
+
+      # The characters or character range to translate to.
+      #
+      # @return [String]
+      attr_reader :replace
+
+      #
+      # Initializes the `String#tr` modifier.
+      #
+      # @param [String] chars
+      #   The characters or character range to replace.
+      #
+      # @param [String] replace
+      #   The characters or character range to use as the replacement.
+      #
+      def initialize(wordlist,chars,replace)
+        super(wordlist)
+
+        @chars   = chars
+        @replace = replace
+      end
+
+      #
+      # Enumerates over every `tr`ed word in the wordlist.
+      #
+      # @yield [word]
+      #   The given block will be passed each `tr`ed word.
+      #
+      # @yieldparam [String] word
+      #   A `tr`ed word.
+      #
+      # @return [Enumerator]
+      #   If no block is given, an Enumerator object will be returned.
+      #
+      # @example
+      #   wordlist = Wordlist::Words["foo", "bar", "baz"]
+      #   wordlist.tr("oa", "0@").each do |word|
+      #     puts word
+      #   end
+      #   # f00
+      #   # b@r
+      #   # b@z
+      #
+      # @api public
+      #
+      def each
+        return enum_for(__method__) unless block_given?
+
+        @wordlist.each do |word|
+          yield word.tr(@chars,@replace)
+        end
+      end
+
+    end
+  end
+end

data/lib/wordlist/modifiers/upcase.rb

@@ -0,0 +1,46 @@
+# frozen_string_literal: true
+require 'wordlist/modifiers/modifier'
+
+module Wordlist
+  module Modifiers
+    #
+    # Lazily calls `String#upcase` on every word in the wordlist.
+    #
+    # @since 1.0.0
+    #
+    class Upcase < Modifier
+
+      #
+      # Enumerates over every `upcase`d word in the wordlist.
+      #
+      # @yield [word]
+      #   The given block will be passed each `upcase`d word.
+      #
+      # @yieldparam [String] word
+      #   A `upcase`d word.
+      #
+      # @return [Enumerator]
+      #   If no block is given, an Enumerator object will be returned.
+      #
+      # @example
+      #   wordlist = Wordlist::Words["foo", "bar", "baz"]
+      #   wordlist.upcase.each do |word|
+      #     puts word
+      #   end
+      #   # FOO
+      #   # BAR
+      #   # BAZ
+      #
+      # @api public
+      #
+      def each
+        return enum_for(__method__) unless block_given?
+
+        @wordlist.each do |word|
+          yield word.upcase
+        end
+      end
+
+    end
+  end
+end

data/lib/wordlist/modifiers.rb

@@ -0,0 +1,9 @@
+# frozen_string_literal: true
+require 'wordlist/modifiers/tr'
+require 'wordlist/modifiers/sub'
+require 'wordlist/modifiers/gsub'
+require 'wordlist/modifiers/capitalize'
+require 'wordlist/modifiers/upcase'
+require 'wordlist/modifiers/downcase'
+require 'wordlist/modifiers/mutate'
+require 'wordlist/modifiers/mutate_case'

data/lib/wordlist/operators/binary_operator.rb

@@ -0,0 +1,39 @@
+# frozen_string_literal: true
+require 'wordlist/operators/operator'
+
+module Wordlist
+  module Operators
+    #
+    # Binary operator base class.
+    #
+    # @since 1.0.0
+    #
+    class BinaryOperator < Operator
+
+      # The left operand.
+      #
+      # @return [Enumerable]
+      attr_reader :left
+
+      # The right operand.
+      #
+      # @return [Enumerable]
+      attr_reader :right
+
+      #
+      # Initializes the binary operator.
+      #
+      # @param [Enumerable] left
+      #   The left operand.
+      #
+      # @param [Enumerable] right
+      #   The right operand.
+      #
+      def initialize(left,right)
+        @left  = left
+        @right = right
+      end
+
+    end
+  end
+end

data/lib/wordlist/operators/concat.rb

@@ -0,0 +1,48 @@
+# frozen_string_literal: true
+require 'wordlist/operators/binary_operator'
+
+module Wordlist
+  module Operators
+    #
+    # Lazily enumerates over the first wordlist, then the second.
+    #
+    # @since 1.0.0
+    #
+    class Concat < BinaryOperator
+
+      #
+      # Enumerates over each word in both wordlists.
+      #
+      # @yield [word]
+      #   The given block will be passed each word from both wordlists.
+      #
+      # @yieldparam [String] word
+      #   A word from one of the wordlists.
+      #
+      # @return [Enumerator]
+      #   If no block is given, an Enumerator object will be returned.
+      #
+      # @example
+      #   wordlist1 = Wordlist::Words["foo", "bar", "baz"]
+      #   wordlist2 = Wordlist::Words["abc", "xyz"]
+      #   (wordlist1 + wordlist2).each do |word|
+      #     puts word
+      #   end
+      #   # foo
+      #   # bar
+      #   # baz
+      #   # abc
+      #   # xyz
+      #
+      # @api public
+      #
+      def each(&block)
+        return enum_for(__method__) unless block
+
+        @left.each(&block)
+        @right.each(&block)
+      end
+
+    end
+  end
+end

data/lib/wordlist/operators/intersect.rb

@@ -0,0 +1,56 @@
+# frozen_string_literal: true
+require 'wordlist/operators/binary_operator'
+require 'wordlist/unique_filter'
+
+module Wordlist
+  module Operators
+    #
+    # Lazily enumerates over every word that belongs to both wordlists.
+    #
+    # @since 1.0.0
+    #
+    class Intersect < BinaryOperator
+
+      #
+      # Enumerates over the intersection between two wordlists.
+      #
+      # @yield [word]
+      #   The given block will be passed each word from the intersection between
+      #   the two wordlists.
+      #
+      # @yieldparam [String] word
+      #   A word that belongs to both wordlists.
+      #
+      # @return [Enumerator]
+      #   If no block is given, an Enumerator object will be returned.
+      #
+      # @example
+      #   wordlist1 = Wordlist::Words["foo", "bar", "baz", "qux"]
+      #   wordlist2 = Wordlist::Words["xyz", "bar", "abc", "qux"]
+      #   (wordlist1 & wordlist2).each do |word|
+      #     puts word
+      #   end
+      #   # bar
+      #   # qux
+      #
+      # @api public
+      #
+      def each
+        return enum_for(__method__) unless block_given?
+
+        unique_filter = UniqueFilter.new
+
+        @left.each do |word|
+          unique_filter.add(word)
+        end
+
+        @right.each do |word|
+          if unique_filter.include?(word)
+            yield word
+          end
+        end
+      end
+
+    end
+  end
+end

data/lib/wordlist/operators/operator.rb

@@ -0,0 +1,29 @@
+module Wordlist
+  module Operators
+    #
+    # Operator base class.
+    #
+    # @since 1.0.0
+    #
+    class Operator
+
+      include Enumerable
+
+      #
+      # Place-holder method.
+      #
+      # @yield [word]
+      #
+      # @yieldparam [String] word
+      #
+      # @return [Enumerator]
+      #
+      # @abstract
+      #
+      def each(&block)
+        raise(NotImplementedError,"#{self.class}#each was not implemented")
+      end
+
+    end
+  end
+end

data/lib/wordlist/operators/power.rb

@@ -0,0 +1,73 @@
+# frozen_string_literal: true
+require 'wordlist/operators/binary_operator'
+require 'wordlist/operators/product'
+
+module Wordlist
+  module Operators
+    #
+    # Lazily enumerates over every combination of words in the wordlist.
+    #
+    # @since 1.0.0
+    #
+    class Power < BinaryOperator
+
+      # The product of the wordlist with itself.
+      #
+      # @return [Product]
+      attr_reader :wordlists
+
+      alias exponent right
+
+      #
+      # Initializes the power operator.
+      #
+      # @param [Enumerable] wordlist
+      #
+      # @param [Integer] exponent
+      #
+      def initialize(wordlist,exponent)
+        super(wordlist,exponent)
+
+        @wordlists = wordlist
+
+        (exponent - 1).times do
+          @wordlists = Product.new(wordlist,@wordlists)
+        end
+      end
+
+      #
+      # Enumerates over every combination of words from the wordlist.
+      #
+      # @yield [string]
+      #   The given block will be passed each combination of words from the
+      #   wordlist.
+      #
+      # @yieldparam [String] string
+      #   A combination of words from the wordlist.
+      #
+      # @return [Enumerator]
+      #   If no block is given, an Enumerator object will be returned.
+      #
+      # @example
+      #   wordlist = Wordlist::Words["foo", "bar"]
+      #   (wordlist ** 3).each do |word|
+      #     puts word
+      #   end
+      #   # foofoofoo
+      #   # foofoobar
+      #   # foobarfoo
+      #   # foobarbar
+      #   # barfoofoo
+      #   # barfoobar
+      #   # barbarfoo
+      #   # barbarbar
+      #
+      # @api public
+      #
+      def each(&block)
+        @wordlists.each(&block)
+      end
+
+    end
+  end
+end

data/lib/wordlist/operators/product.rb

@@ -0,0 +1,51 @@
+# frozen_string_literal: true
+require 'wordlist/operators/binary_operator'
+
+module Wordlist
+  module Operators
+    #
+    # Lazily enumerates over the combination of the words from two wordlists.
+    #
+    # @since 1.0.0
+    #
+    class Product < BinaryOperator
+
+      #
+      # Enumerates over every combination of the words from the two wordlist.
+      #
+      # @yield [string]
+      #   The given block will be passed each combination of words from the
+      #   two wordlist.
+      #
+      # @yieldparam [String] string
+      #   A combination of two words from the two wordlists.
+      #
+      # @return [Enumerator]
+      #   If no block is given, an Enumerator object will be returned.
+      #
+      # @example
+      #   wordlist1 = Wordlist::Words["foo", "bar"]
+      #   wordlist2 = Wordlist::Words["ABC", "XYZ"]
+      #   (wordlist1 * wordlist2).each do |word|
+      #     puts word
+      #   end
+      #   # fooABC
+      #   # fooXYZ
+      #   # barABC
+      #   # barXYZ
+      #
+      # @api public
+      #
+      def each
+        return enum_for(__method__) unless block_given?
+
+        @left.each do |word1|
+          @right.each do |word2|
+            yield word1 + word2
+          end
+        end
+      end
+
+    end
+  end
+end