ronin-support 0.5.2 → 1.0.0.beta1

data/lib/ronin/support/text/typo/generator.rb

@@ -0,0 +1,161 @@
+# frozen_string_literal: true
+#
+# Copyright (c) 2006-2022 Hal Brodigan (postmodern.mod3 at gmail.com)
+#
+# ronin-support is free software: you can redistribute it and/or modify
+# it under the terms of the GNU Lesser General Public License as published
+# by the Free Software Foundation, either version 3 of the License, or
+# (at your option) any later version.
+#
+# ronin-support is distributed in the hope that it will be useful,
+# but WITHOUT ANY WARRANTY; without even the implied warranty of
+# MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
+# GNU Lesser General Public License for more details.
+#
+# You should have received a copy of the GNU Lesser General Public License
+# along with ronin-support.  If not, see <https://www.gnu.org/licenses/>.
+#
+
+require 'ronin/support/text/typo/exceptions'
+
+module Ronin
+  module Support
+    module Text
+      module Typo
+        #
+        # Geneerates one or more typos based on a series of substitution rules.
+        #
+        # @api public
+        #
+        # @since 1.0.0
+        #
+        class Generator
+
+          # The typo substitution rules.
+          #
+          # @return [Array<(Regexp, String)>]
+          attr_reader :rules
+
+          #
+          # Initializes the typo substitution rules.
+          #
+          # @param [Array<(Regexp, String)>] rules
+          #   The typo pattern patterns and substition strings for the
+          #   generator.
+          #
+          def initialize(rules)
+            @rules = rules
+          end
+
+          #
+          # Creates a new generator.
+          #
+          # @param [Array<(Regexp, String)>] rules
+          #   The typo pattern patterns and substition strings for the
+          #   generator.
+          #
+          # @return [Generator]
+          #   The newly created typo generator.
+          #
+          # @example
+          #   Text::Typo::Generator[
+          #     [/(?<=\w)o(?=\w)/, 'oo'],
+          #     [/(?<=\w)l(?=\w)/, 'll'],
+          #     [/(?<=\w)s(?=\w)/, 'ss']
+          #   ]
+          #
+          def self.[](*rules)
+            new(rules)
+          end
+
+          #
+          # Combines the typo generator's rules with another typo generator's
+          # rules.
+          #
+          # @param [Generator] other
+          #   The other typo generator.
+          #
+          # @return [Generator]
+          #   The new typo generator object.
+          #
+          def +(other)
+            Generator.new(@rules + other.rules)
+          end
+
+          #
+          # Performs a random typo substitution of the given word.
+          #
+          # @param [String] word
+          #   The original word.
+          #
+          # @return [String]
+          #   The random typoed version of the original word.
+          #
+          # @raise [NoTypoPossible]
+          #   No possible typo substitutions were found in the word.
+          #
+          def substitute(word)
+            matching_rules = @rules.select do |regexp,replace|
+              word =~ regexp
+            end
+
+            if matching_rules.empty?
+              raise(NoTypoPossible,"no possible typo substitution found in word: #{word.inspect}")
+            end
+
+            regexp, replace = matching_rules.sample
+
+            return word.sub(regexp,replace)
+          end
+
+          #
+          # Enumerates over every possible typo substition for the given word.
+          #
+          # @param [String] word
+          #   The original word to typo.
+          #
+          # @yield [typo_word]
+          #   If a block is given, it will be passed each typo variation of the
+          #   original word.
+          # 
+          # @yieldparam [String] typo_word
+          #   One of the typoed variations of the original word.
+          #
+          # @return [Enumerator]
+          #   If no block is given, an Enumrator object will be returned.
+          #
+          def each_substitution(word)
+            return enum_for(__method__,word) unless block_given?
+
+            @rules.each do |regexp,replace|
+              offset = 0
+
+              while (match = word.match(regexp,offset))
+                start, stop = match.offset(0)
+
+                new_string = word.dup
+                new_string[start...stop] = replace
+                yield new_string
+
+                offset = stop
+              end
+            end
+
+            return nil
+          end
+
+          #
+          # Converts the generator into the Array of substitution rules.
+          #
+          # @return [Array<(Regexp, String)>]
+          #   The Array of patterns and substitution strings.
+          #
+          def to_a
+            @rules
+          end
+
+        end
+      end
+    end
+  end
+end

data/lib/ronin/support/text/typo.rb

@@ -0,0 +1,260 @@
+# frozen_string_literal: true
+#
+# Copyright (c) 2006-2022 Hal Brodigan (postmodern.mod3 at gmail.com)
+#
+# ronin-support is free software: you can redistribute it and/or modify
+# it under the terms of the GNU Lesser General Public License as published
+# by the Free Software Foundation, either version 3 of the License, or
+# (at your option) any later version.
+#
+# ronin-support is distributed in the hope that it will be useful,
+# but WITHOUT ANY WARRANTY; without even the implied warranty of
+# MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
+# GNU Lesser General Public License for more details.
+#
+# You should have received a copy of the GNU Lesser General Public License
+# along with ronin-support.  If not, see <https://www.gnu.org/licenses/>.
+#
+
+require 'ronin/support/text/typo/generator'
+
+module Ronin
+  module Support
+    module Text
+      #
+      # Generates typos in words.
+      #
+      # @api public
+      #
+      # @since 1.0.0
+      #
+      module Typo
+        # Typo generator that repeats characters.
+        OMIT_CHARS = Generator[
+          [/(?<=\w)ae(?=\w)/, 'e'],
+          [/(?<=\w)dd(?=\w)/, 'd'],
+          [/(?<=\w)rr(?=\w)/, 'r'],
+          [/(?<=\w)ll(?=\w)/, 'l'],
+          [/(?<=\w)mm(?=\w)/, 'm'],
+          [/(?<=\w)ss(?=\w)/, 's'],
+          [/(?<=\w)oo(?=\w)/, 'o'],
+          [/(?<=\w)ous/,  'us'],
+          [/(?<=\w)ous/,  'os'],
+          [/(?<=\w)ious/, 'uos'],
+          [/(?<=\w)ious/, 'ios'],
+          [/[_-]/, '']
+        ]
+
+        # Typo generator that repeats characters.
+        REPEAT_CHARS = Generator[
+          [/(?<=\w)o(?=\w)/, 'oo'],
+          [/(?<=\w)l(?=\w)/, 'll'],
+          [/(?<=\w)s(?=\w)/, 'ss']
+        ]
+
+        # Typo generator that swaps neighboring characters.
+        SWAP_CHARS = Generator[
+          [/(?<=\w)au(?=\w)/, 'ua'],
+          [/(?<=\w)ua(?=\w)/, 'au'],
+          [/(?<=\w)ie(?=\w)/, 'ei'],
+          [/(?<=\w)ei(?=\w)/, 'ie'],
+          [/(?<=\w)th(?=\w)/, 'ht'],
+          [/(?<=\w)ht(?=\w)/, 'th'],
+          [/(?<=\w)il(?=\w)/, 'li'],
+          [/(?<=\w)ou(?=\w)/, 'uo']
+        ]
+
+        # Typo generator that swaps different symbols.
+        SWAP_SYMBOLS = Generator[
+          [/_/, '-'],
+          [/-/, '_']
+        ]
+
+        # Typo generator that changes the suffix of words.
+        CHANGE_SUFFIX = Generator[
+          [/er$/,   'ar'],
+          [/ar$/,   'er'],
+          [/el$/,   'le'],
+          [/al$/,   'al'],
+          [/es$/,   's'],
+          [/s$/,    ''],
+          [/ent$/,  'ant'],
+          [/ant$/,  'ent'],
+          [/able$/, 'ible'],
+          [/ible$/, 'able'],
+          [/ence$/, 'ense'],
+          [/ense$/, 'ence'],
+          [/ance$/, 'anse'],
+          [/anse$/, 'ance'],
+          [/ier$/,  'er'],
+          [/ion$/,  'on']
+        ]
+
+        # Default typo generator.
+        #
+        # @note Does not include the {SWAP_SYMBOLS} typo rules.
+        DEFAULT = Generator.new(
+          OMIT_CHARS.rules + REPEAT_CHARS.rules + SWAP_CHARS.rules +
+          CHANGE_SUFFIX.rules
+        )
+
+        #
+        # Typo generator that repeats characters.
+        #
+        # @return [Generator]
+        #
+        # @see OMIT_CHARS
+        #
+        def self.omit_chars
+          OMIT_CHARS
+        end
+
+        #
+        # Typo generator that repeats characters.
+        #
+        # @return [Generator]
+        #
+        # @see REPEAT_CHARS
+        #
+        def self.repeat_chars
+          REPEAT_CHARS
+        end
+
+        #
+        # Typo generator that swaps neighboring characters.
+        #
+        # @return [Generator]
+        #
+        # @see SWAP_CHARS
+        #
+        def self.swap_chars
+          SWAP_CHARS
+        end
+
+        #
+        # Typo generator that swaps different symbols.
+        #
+        # @return [Generator]
+        #
+        # @see SWAP_SYMBOLS
+        #
+        def self.swap_symbols
+          SWAP_SYMBOLS
+        end
+
+        #
+        # Typo generator that changes the suffix of words.
+        #
+        # @return [Generator]
+        #
+        # @see CHANGE_SUFFIX
+        #
+        def self.change_suffix
+          CHANGE_SUFFIX
+        end
+
+        #
+        # Builds a set of typo substitution rules.
+        #
+        # @param [Hash{Symbol => Boolean}] kwargs
+        #   Additional typo options.
+        #
+        # @option kwargs [Boolean] :omit_chars
+        #   Whether to enable/disable omission of repeated characters.
+        #
+        # @option kwargs [Boolean] :repeat_chars
+        #   Whether to enable/disable repeatition of single characters.
+        #
+        # @option kwargs [Boolean] :swap_chars
+        #   Whether to enable/disable swapping of certain common character
+        #   pairs.
+        #
+        # @option kwargs [Boolean] :change_suffix
+        #   Whether to enable/disable changing the suffixes of words.
+        #
+        # @return [Generator]
+        #   The typo generator.
+        #
+        def self.generator(**kwargs)
+          if kwargs.empty?
+            DEFAULT
+          else
+            rules = []
+            rules.concat(OMIT_CHARS.rules)    if kwargs[:omit_chars]
+            rules.concat(REPEAT_CHARS.rules)  if kwargs[:repeat_chars]
+            rules.concat(SWAP_CHARS.rules)    if kwargs[:swap_chars]
+            rules.concat(SWAP_SYMBOLS.rules)  if kwargs[:swap_symbols]
+            rules.concat(CHANGE_SUFFIX.rules) if kwargs[:change_suffix]
+
+            Generator.new(rules)
+          end
+        end
+
+        #
+        # Returns a random typo substitution for the given word.
+        #
+        # @param [String] word
+        #   The given String.
+        #
+        # @param [Hash{Symbol => Boolean}] kwargs
+        #   Additional keyword arguments.
+        #
+        # @option kwargs [Boolean] omit
+        #   Enables/disables omission of repeated characters.
+        #
+        # @option kwargs [Boolean] repeat
+        #   Enables/disables repeatition of single characters.
+        #
+        # @option kwargs [Boolean] swap
+        #   Enables/disables swapping of certain common character pairs.
+        #
+        # @option kwargs [Boolean] suffix
+        #   Enables/disables changing the suffixes of words.
+        #
+        # @return [String]
+        #   A random typo of the given word.
+        #
+        def self.substitute(word,**kwargs)
+          generator(**kwargs).substitute(word)
+        end
+
+        #
+        # Enumerates over every typo mistake for the given word.
+        #
+        # @param [String] word
+        #   The given String.
+        #
+        # @param [Hash{Symbol => Boolean}] kwargs
+        #   Additional keyword arguments.
+        #
+        # @option kwargs [Boolean] omit
+        #   Enables/disables omission of repeated characters.
+        #
+        # @option kwargs [Boolean] repeat
+        #   Enables/disables repeatition of single characters.
+        #
+        # @option kwargs [Boolean] swap
+        #   Enables/disables swapping of certain common character pairs.
+        #
+        # @option kwargs [Boolean] suffix
+        #   Enables/disables changing the suffixes of words.
+        #
+        # @yield [typoed]
+        #   If a block is given, it will be passed each possible typo of the
+        #   original String.
+        #
+        # @yieldparam [String]
+        #   A modified version of the original String.
+        #
+        # @return [Enumerator]
+        #   If no block is given, an Enumerator will be returned.
+        #
+        def self.each_substitution(word,**kwargs,&block)
+          generator(**kwargs).each_substitution(word,&block)
+        end
+      end
+    end
+  end
+end
+
+require 'ronin/support/text/typo/core_ext'

data/lib/ronin/{formatting → support}/text.rb

@@ -1,7 +1,6 @@
+# frozen_string_literal: true
 #
-# Copyright (c) 2006-2021 Hal Brodigan (postmodern.mod3 at gmail.com)
-#
-# This file is part of ronin-support.
+# Copyright (c) 2006-2022 Hal Brodigan (postmodern.mod3 at gmail.com)
 #
 # ronin-support is free software: you can redistribute it and/or modify
 # it under the terms of the GNU Lesser General Public License as published
@@ -17,4 +16,11 @@
 # along with ronin-support.  If not, see <https://www.gnu.org/licenses/>.
 #
 
-require 'ronin/formatting/extensions/text'
+require 'ronin/support/text/patterns'
+require 'ronin/support/text/random'
+require 'ronin/support/text/entropy'
+require 'ronin/support/text/homoglyph'
+require 'ronin/support/text/typo'
+require 'ronin/support/text/erb'
+require 'ronin/support/text/mixin'
+require 'ronin/support/text/core_ext'

data/lib/ronin/support/version.rb

@@ -1,7 +1,6 @@
+# frozen_string_literal: true
 #
-# Copyright (c) 2006-2021 Hal Brodigan (postmodern.mod3 at gmail.com)
-#
-# This file is part of ronin-support.
+# Copyright (c) 2006-2022 Hal Brodigan (postmodern.mod3 at gmail.com)
 #
 # ronin-support is free software: you can redistribute it and/or modify
 # it under the terms of the GNU Lesser General Public License as published
@@ -20,6 +19,6 @@
 module Ronin
   module Support
     # ronin-support version
-    VERSION = '0.5.2'
+    VERSION = '1.0.0.beta1'
   end
 end

data/lib/ronin/support.rb

@@ -1,7 +1,6 @@
+# frozen_string_literal: true
 #
-# Copyright (c) 2006-2021 Hal Brodigan (postmodern.mod3 at gmail.com)
-#
-# This file is part of ronin-support.
+# Copyright (c) 2006-2022 Hal Brodigan (postmodern.mod3 at gmail.com)
 #
 # ronin-support is free software: you can redistribute it and/or modify
 # it under the terms of the GNU Lesser General Public License as published
@@ -17,13 +16,19 @@
 # along with ronin-support.  If not, see <https://www.gnu.org/licenses/>.
 #
 
-require 'ronin/extensions'
-require 'ronin/formatting'
-require 'ronin/fuzzing'
-require 'ronin/binary'
-require 'ronin/network'
-require 'ronin/path'
-require 'ronin/templates'
-require 'ronin/support/inflector'
-require 'ronin/support/support'
+require 'ronin/support/binary'
+require 'ronin/support/cli'
+require 'ronin/support/core_ext'
+require 'ronin/support/crypto'
+require 'ronin/support/encoding'
+require 'ronin/support/mixin'
+require 'ronin/support/network'
+require 'ronin/support/path'
+require 'ronin/support/text'
 require 'ronin/support/version'
+
+module Ronin
+  module Support
+    include Mixin
+  end
+end

data/ronin-support.gemspec

@@ -33,8 +33,9 @@ Gem::Specification.new do |gem|
   gem.default_executable = gem.executables.first if Gem::VERSION < '1.7.'
 
   gem.extensions       = glob[gemspec['extensions'] || 'ext/**/extconf.rb']
-  gem.test_files       = glob[gemspec['test_files'] || '{test/{**/}*_test.rb']
   gem.extra_rdoc_files = glob[gemspec['extra_doc_files'] || '*.{txt,md}']
+  # exclude test files from the packages gem
+  gem.files           -= glob[gemspec['test_files'] || 'spec/{**/}*']
 
   gem.require_paths = Array(gemspec.fetch('require_paths') {
     %w[ext lib].select { |dir| File.directory?(dir) }