wordlist 0.1.1 → 1.0.1

data/lib/wordlist/list_methods.rb

@@ -0,0 +1,462 @@
+# frozen_string_literal: true
+require 'wordlist/operators'
+require 'wordlist/modifiers'
+
+module Wordlist
+  #
+  # List operator and modifier methods.
+  #
+  # @since 1.0.0
+  #
+  module ListMethods
+    #
+    # @group Operators
+    #
+
+    #
+    # Lazily enumerates over the first wordlist, then the second.
+    #
+    # @param [Enumerable] other
+    #   The other wordlist to concat.
+    #
+    # @return [Operators::Concat]
+    #   The lazily concatenated wordlists.
+    #
+    # @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 concat(other)
+      Operators::Concat.new(self,other)
+    end
+
+    alias + concat
+
+    #
+    # Lazily enumerates over every word in the first wordlist, that is not in
+    # the second wordlist.
+    #
+    # @param [Enumerable] other
+    #   The other wordlist to subtract.
+    #
+    # @return [Operators::Subtract]
+    #   The lazy subtraction of the two wordlists.
+    #
+    # @example
+    #   wordlist1 = Wordlist::Words["foo", "bar", baz", "qux"]
+    #   wordlist2 = Wordlist::Words["bar", "qux"]
+    #   (wordlist1 - wordlist2).each do |word|
+    #     puts word
+    #   end
+    #   # foo
+    #   # baz
+    #
+    # @api public
+    #
+    def subtract(other)
+      Operators::Subtract.new(self,other)
+    end
+
+    alias - subtract
+
+    #
+    # Lazily enumerates over the combination of the words from two wordlists.
+    #
+    # @param [Enumerable] other
+    #   The other wordlist to combine with.
+    #
+    # @return [Operators::Product]
+    #   The lazy product of the two wordlists.
+    #
+    # @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 product(other)
+      Operators::Product.new(self,other)
+    end
+
+    alias * product
+
+    #
+    # Lazily enumerates over every combination of words in the wordlist.
+    #
+    # @param [Integer] exponent
+    #   The number of times the wordlist will be combined with itself.
+    #
+    # @return [Operators::Power]
+    #   The lazy combination of the wordlist.
+    #
+    # @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 power(exponent)
+      Operators::Power.new(self,exponent)
+    end
+
+    alias ** power
+
+    #
+    # Lazily enumerates over every word that belongs to both wordlists.
+    #
+    # @param [Enumerable] other
+    #   The other wordlist to intersect with.
+    #
+    # @return [Operators::Intersect]
+    #   The lazy intersection of the two wordlists.
+    #
+    # @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 intersect(other)
+      Operators::Intersect.new(self,other)
+    end
+
+    alias & intersect
+
+    #
+    # Lazily enumerates over words from both wordlists, filtering out any
+    # duplicates.
+    #
+    # @param [Enumerable] other
+    #   The other wordlist to union with.
+    #
+    # @return [Operators::Union]
+    #   The lazy union of the two wordlists.
+    #
+    # @example
+    #   wordlist1 = Wordlist::Words["foo", "bar", "baz", "qux"]
+    #   wordlist2 = Wordlist::Words["xyz", "bar", "abc", "qux"]
+    #   (wordlist1 | wordlist2).each do |word|
+    #     puts word
+    #   end
+    #   # foo
+    #   # bar
+    #   # baz
+    #   # qux
+    #   # xyz
+    #   # abc
+    #
+    # @api public
+    #
+    def union(other)
+      Operators::Union.new(self,other)
+    end
+
+    alias | union
+
+    #
+    # Lazily enumerates over only the unique words in the wordlist, filtering
+    # out duplicates.
+    #
+    # @return [Operators::Unique]
+    #   The lazy uniqueness of the wordlist.
+    #
+    # @example
+    #   wordlist= Wordlist::Words["foo", "bar", "baz", "qux"]
+    #   (wordlist + wordlist).uniq.each do |word|
+    #     puts word
+    #   end
+    #   # foo
+    #   # bar
+    #   # baz
+    #   # qux
+    #
+    # @api public
+    #
+    def uniq
+      Operators::Unique.new(self)
+    end
+
+    #
+    # @group Modifiers
+    #
+
+    #
+    # Lazily calls `String#tr` on each word in the wordlist.
+    #
+    # @param [String] chars
+    #   The characters or character range to replace.
+    #
+    # @param [String] replace
+    #   The characters or character range to use as the replacement.
+    #
+    # @return [Tr]
+    #   The lazy `String#tr` modification of the wordlist.
+    #
+    # @example
+    #   wordlist = Wordlist::Words["foo", "bar", "baz"]
+    #   wordlist.capitalize.each do |word|
+    #     puts word
+    #   end
+    #   # Foo
+    #   # Bar
+    #   # Baz
+    #
+    # @api public
+    #
+    def tr(chars,replace)
+      Modifiers::Tr.new(self,chars,replace)
+    end
+
+    #
+    # Lazily calls `String#sub` on each word in the wordlist.
+    #
+    # @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.
+    #
+    # @return [Sub]
+    #   The lazy `String#sub` modification of the wordlist.
+    #
+    # @example
+    #   wordlist = Wordlist::Words["foo", "bar", "baz"]
+    #   wordlist.sub(/o/, '0').each do |word|
+    #     puts word
+    #   end
+    #   # f0o
+    #   # bar
+    #   # baz
+    #
+    # @api public
+    #
+    def sub(pattern,replace=nil,&block)
+      if replace
+        Modifiers::Sub.new(self,pattern,replace,&block)
+      else
+        Modifiers::Sub.new(self,pattern,&block)
+      end
+    end
+
+    #
+    # Lazily calls `String#gsub` on each word in the wordlist.
+    #
+    # @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.
+    #
+    # @return [Gsub]
+    #   The lazy `String#gsub` modification of the wordlist.
+    #
+    # @example
+    #   wordlist = Wordlist::Words["Foo", "BAR", "bAz"]
+    #   wordlist.gsub(/o/,'0').each do |word|
+    #     puts word
+    #   end
+    #   # f00
+    #   # bar
+    #   # baz
+    #
+    # @api public
+    #
+    def gsub(pattern,replace=nil,&block)
+      if replace
+        Modifiers::Gsub.new(self,pattern,replace,&block)
+      else
+        Modifiers::Gsub.new(self,pattern,&block)
+      end
+    end
+
+    #
+    # Lazily calls `String#capitalize` on each word in the wordlist.
+    #
+    # @return [Capitalize]
+    #   The lazy `String#gsub` modification of the wordlist.
+    #
+    # @example
+    #   wordlist = Wordlist::Words["foo", "bar", "baz"]
+    #   wordlist.capitalize.each do |word|
+    #     puts word
+    #   end
+    #   # Foo
+    #   # Bar
+    #   # Baz
+    #
+    # @api public
+    #
+    def capitalize
+      Modifiers::Capitalize.new(self)
+    end
+
+    #
+    # Lazily calls `String#upcase` on each word in the wordlist.
+    #
+    # @return [Upcase]
+    #   The lazy `String#gsub` modification of the wordlist.
+    #
+    # @example
+    #   wordlist = Wordlist::Words["foo", "bar", "baz"]
+    #   wordlist.upcase.each do |word|
+    #     puts word
+    #   end
+    #   # FOO
+    #   # BAR
+    #   # BAZ
+    #
+    # @api public
+    #
+    def upcase
+      Modifiers::Upcase.new(self)
+    end
+
+    #
+    # Lazily calls `String#downcase` on each word in the wordlist.
+    #
+    # @return [Downcase]
+    #   The lazy `String#gsub` modification of the wordlist.
+    #
+    # @example
+    #   wordlist = Wordlist::Words["Foo", "BAR", "bAz"]
+    #   wordlist.downcase.each do |word|
+    #     puts word
+    #   end
+    #   # foo
+    #   # bar
+    #   # baz
+    #
+    # @api public
+    #
+    def downcase
+      Modifiers::Downcase.new(self)
+    end
+
+    #
+    # Lazily performs every combination of a string substitution on every word
+    # in the wordlist.
+    #
+    # @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.
+    #
+    # @return [Mutate]
+    #   The lazy `String#gsub` modification of the wordlist.
+    #
+    # @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 mutate(pattern,replace=nil,&block)
+      if replace
+        Modifiers::Mutate.new(self,pattern,replace,&block)
+      else
+        Modifiers::Mutate.new(self,pattern,&block)
+      end
+    end
+
+    #
+    # Lazily enumerates over every uppercase/lowercase variation of the word.
+    #
+    # @return [EachCase]
+    #   The lazy `String#gsub` modification of the wordlist.
+    #
+    # @example
+    #   wordlist = Wordlist::Words["foo", "bar"]
+    #   wordlist.mutate_case.each do |word|
+    #     puts word
+    #   end
+    #  # foo
+    #  # Foo
+    #  # fOo
+    #  # foO
+    #  # FOo
+    #  # FoO
+    #  # fOO
+    #  # FOO
+    #  # bar
+    #  # Bar
+    #  # bAr
+    #  # baR
+    #  # BAr
+    #  # BaR
+    #  # bAR
+    #  # BAR
+    #
+    # @api public
+    #
+    def mutate_case
+      Modifiers::MutateCase.new(self)
+    end
+  end
+
+  Operators::Operator.send :include, ListMethods
+  Modifiers::Modifier.send :include, ListMethods
+end

data/lib/wordlist/modifiers/capitalize.rb

@@ -0,0 +1,46 @@
+# frozen_string_literal: true
+require 'wordlist/modifiers/modifier'
+
+module Wordlist
+  module Modifiers
+    #
+    # Lazily calls `String#capitalize` on every word in the wordlist.
+    #
+    # @since 1.0.0
+    #
+    class Capitalize < Modifier
+
+      #
+      # Enumerates over every capitalized word in the wordlist.
+      #
+      # @yield [word]
+      #   The given block will be passed each capitalized word.
+      #
+      # @yieldparam [String] word
+      #   A capitalized word from the wordlist.
+      #
+      # @return [Enumerator]
+      #   If no block is given, an Enumerator object will be returned.
+      #
+      # @example
+      #   wordlist = Wordlist::Words["foo", "bar", "baz"]
+      #   wordlist.capitalize.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.capitalize
+        end
+      end
+
+    end
+  end
+end

data/lib/wordlist/modifiers/downcase.rb

@@ -0,0 +1,46 @@
+# frozen_string_literal: true
+require 'wordlist/modifiers/modifier'
+
+module Wordlist
+  module Modifiers
+    #
+    # Lazily calls `String#downcase` on every word in the wordlist.
+    #
+    # @since 1.0.0
+    #
+    class Downcase < Modifier
+
+      #
+      # Enumerates over every `downcase`d word in the wordlist.
+      #
+      # @yield [word]
+      #   The given block will be passed each `downcase`d word.
+      #
+      # @yieldparam [String] word
+      #   A `downcase`d word.
+      #
+      # @return [Enumerator]
+      #   If no block is given, an Enumerator object will be returned.
+      #
+      # @example
+      #   wordlist = Wordlist::Words["Foo", "BAR", "bAz"]
+      #   wordlist.downcase.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.downcase
+        end
+      end
+
+    end
+  end
+end

data/lib/wordlist/modifiers/gsub.rb

@@ -0,0 +1,52 @@
+# frozen_string_literal: true
+require 'wordlist/modifiers/sub'
+
+module Wordlist
+  module Modifiers
+    #
+    # Lazily calls `String#gsub` on every word in the wordlist.
+    #
+    # @since 1.0.0
+    #
+    class Gsub < Sub
+
+      #
+      # Enumerates over every `gsub`ed word in the wordlist.
+      #
+      # @yield [word]
+      #   The given block will be passed each `gsub`ed word.
+      #
+      # @yieldparam [String] word
+      #   A `gsub`ed word from the wordlist.
+      #
+      # @return [Enumerator]
+      #   If no block is given, an Enumerator object will be returned.
+      #
+      # @example
+      #   wordlist = Wordlist::Words["Foo", "BAR", "bAz"]
+      #   wordlist.gsub(/o/,'0').each do |word|
+      #     puts word
+      #   end
+      #   # f00
+      #   # bar
+      #   # baz
+      #
+      # @api public
+      #
+      def each
+        return enum_for(__method__) unless block_given?
+
+        if @replace
+          @wordlist.each do |word|
+            yield word.gsub(@pattern,@replace)
+          end
+        else
+          @wordlist.each do |word|
+            yield word.gsub(@pattern,&block)
+          end
+        end
+      end
+
+    end
+  end
+end

data/lib/wordlist/modifiers/modifier.rb

@@ -0,0 +1,44 @@
+module Wordlist
+  module Modifiers
+    #
+    # Modifier base class.
+    #
+    # @since 1.0.0
+    #
+    class Modifier
+
+      include Enumerable
+
+      # The wordlist to modify.
+      #
+      # @return [Enumerable]
+      attr_reader :wordlist
+
+      #
+      # Initializes the modifier.
+      #
+      # @param [Enumerable] wordlist
+      #   The wordlist to modify.
+      #
+      def initialize(wordlist)
+        @wordlist = wordlist
+      end
+
+      #
+      # Enumerates over every modification of every word in the wordlist.
+      #
+      # @yield [word]
+      #
+      # @yieldparam [String] word
+      #
+      # @return [Enumerator]
+      #
+      # @abstract
+      #
+      def each(&block)
+        raise(NotImplementedError,"#{self.class}##{__method__} was not implemented")
+      end
+
+    end
+  end
+end