hrules 0.0.1

checksums.yaml

@@ -0,0 +1,7 @@
+---
+SHA256:
+  metadata.gz: 1631b7b32ea2ebaf29bd6b5fe58c3aef7191d4022cdac8d9c51f08c8ce79c638
+  data.tar.gz: 7984c4f9d831c9504ae43188739f1b08c502fdacd079015938c955bc28053b81
+SHA512:
+  metadata.gz: 8ee81f8a9d9b3c823bfb55aea43d8305735157911a48e314c2c7345ec34820f379c7271b449b1d021b59c8c92c17a416c3c1759d2a3a5a60176b33c0083a1e67
+  data.tar.gz: bb7ce51c39e41748c5cede438e7f31b9f1296feceea946cfe194cf68fcab021d17dbad4744e59a6356d775d275a91e4004d0898f446c2fe7d2637c6b18ba5a99

data/lib/hrules.rb

@@ -0,0 +1,229 @@
+#!/usr/bin/env ruby
+ require 'active_support/inflector'
+
+rules = [
+	{character: "u", mutation: "upcase",                takes_param: false, param_count: 0},
+	{character: "l", mutation: "downcase",              takes_param: false, param_count: 0},
+	{character: "c", mutation: "capitalize",            takes_param: false, param_count: 0},
+	{character: "C", mutation: "inverted_capitalize",   takes_param: false, param_count: 0},
+	{character: "t", mutation: "swapcase",              takes_param: false, param_count: 0},
+	{character: "T", mutation: "toggle_at_position",    takes_param: true,  param_count: 1},
+	{character: "r", mutation: "reverse",               takes_param: false, param_count: 0},
+	{character: "d", mutation: "duplicate",             takes_param: false, param_count: 0},
+	{character: "p", mutation: "duplicate_n_times",     takes_param: true,  param_count: 1},
+	{character: "f", mutation: "reflect",               takes_param: false, param_count: 0},
+	{character: "{", mutation: "rotate_left",           takes_param: false, param_count: 0},
+	{character: "}", mutation: "rotate_right",          takes_param: false, param_count: 0},
+	{character: "$", mutation: "append_character",      takes_param: true,  param_count: 1},
+	{character: "^", mutation: "prepend_character",     takes_param: true,  param_count: 1},
+	{character: "[", mutation: "delete_first",          takes_param: false, param_count: 0},
+	{character: "]", mutation: "delete_last",           takes_param: false, param_count: 0},
+	{character: "D", mutation: "delete_at_position",    takes_param: true,  param_count: 1},
+	{character: "x", mutation: "extract_from_position", takes_param: true,  param_count: 2},
+	{character: "O", mutation: "omit_from_position",    takes_param: true,  param_count: 2},
+	{character: "i", mutation: "insert_at_x",           takes_param: true,  param_count: 2},
+	{character: "o", mutation: "overwrite_at_x",        takes_param: true,  param_count: 2},
+	{character: "'", mutation: "truncate_from_x",       takes_param: true,  param_count: 1},
+	{character: "s", mutation: "replace_with_char",     takes_param: true,  param_count: 2},
+	{character: "@", mutation: "purge_instances_of_x",  takes_param: true,  param_count: 1},
+	{character: "z", mutation: "dup_first_n_times",     takes_param: true,  param_count: 1},
+	{character: "Z", mutation: "dup_last_n_times",      takes_param: true,  param_count: 1},
+	{character: "q", mutation: "duplicate_all",         takes_param: false, param_count: 0},
+	{character: "*", mutation: "swap",                  takes_param: true,  param_count: 2},
+	{character: "E", mutation: "titlecase",             takes_param: false, param_count: 0},
+	{character: "y", mutation: "dup_block_forward",     takes_param: true,  param_count: 1},
+	{character: "Y", mutation: "dup_block_back",        takes_param: true,  param_count: 1},
+]
+
+class String
+
+	def duplicate
+		return "#{self}#{self}"
+	end
+
+	def inverted_capitalize
+		self.capitalize.swapcase
+	end
+
+	def toggle_at_position(position)
+		if self[position.to_i] then self[position.to_i] = self[position.to_i]&.upcase end
+		return self
+	end
+
+	def duplicate_n_times(times)
+		return self * times.to_i
+	end
+
+	def reflect
+		"#{self}#{self.reverse}"
+	end
+
+	def rotate_left
+		self.split("").rotate(1).join("")
+	end
+
+	def rotate_right
+		self.split("").rotate(-1).join("")
+	end
+
+	def append_character(character)
+		"#{self}#{character}"
+	end
+
+	def prepend_character(character)
+		"#{character}#{self}"
+	end
+
+	def delete_first
+		self[1..-1]
+	end
+
+	def delete_last
+		self[0..-2]
+	end
+
+	def delete_at_position(position)
+		self.split("").reject.with_index { |v, i| i == position.to_i }.join("")
+	end
+
+	def extract_from_position(positions)
+		start_p, end_p = positions[0].to_i, positions[1].to_i
+		self[start_p..end_p]
+	end
+
+	def omit_from_position(positions)
+		start_p, end_p = positions[0].to_i, positions[1].to_i
+		range = (start_p..end_p).to_a
+		self.split("").reject.with_index { |v, i| range.include?(i) }.join("")
+	end
+
+	def insert_at_x(positions)
+		loc, char = positions[0].to_i, positions[1]
+		if loc.between?(0, (self.length - 1))
+			self.insert(loc, char)
+		end
+		self
+	end
+
+	def overwrite_at_x(positions)
+		loc, char = positions[0].to_i, positions[1]
+		self[loc] = char
+		self
+	rescue IndexError
+		self
+	end
+
+	def truncate_from_x(position)
+		self[0..position.to_i]
+	rescue IndexError
+		self
+	end
+
+	def replace_with_char(characters)
+		replace, replace_with = characters.split("")[0], characters.split("")[1]
+		self.gsub(replace, replace_with)
+	rescue IndexError
+		self
+	end
+
+	def purge_instances_of_x(character)
+		self.gsub(character, "")
+	rescue IndexError
+		self
+	end
+
+	def dup_first_n_times(times)
+		self[0] = self[0] * times.to_i
+		return self
+	rescue IndexError
+		self
+	end
+
+	def dup_last_n_times(times)
+		self[-1] = (self[-1] + (self[-1] * times.to_i))
+		return self
+	rescue IndexError
+		self
+	end
+
+	def duplicate_all
+		returned = ""
+		self.split("").each.with_index do |v, i|
+			returned << self[i] = v * 2
+		end
+		returned
+	rescue IndexError
+		self
+	end
+
+	def mutate(rule_string)
+		to_return = self
+		skip      = 0
+		rule_string.each_char.with_index do |character, index|
+			if index < skip
+				next
+			end
+			rule = Rules.find_rule(character)
+			next unless rule
+			if rule.takes_parameters?
+				thing     = rule_string[ ((index +1 )..(index + rule.param_count)) ]
+				to_return = to_return.send(rule.mutation, thing )
+				skip      = index + rule.param_count + 1
+			else
+				to_return = to_return.send(rule.mutation)
+			end
+		end
+		return to_return
+	end
+
+	def swap(characters)
+		pos1, pos2 = characters.split("")[0].to_i, characters.split("")[1].to_i
+		if pos1.between?(0, (self.length - 1)) and pos2.between?(0, (self.length - 1)) 
+			self[pos1] = self[pos2]
+		end
+		self
+	rescue IndexError
+		self
+	end
+
+	def dup_block_back(position)
+		block = self[position.to_i..-1]
+		self.insert(-1, block) if block
+		self
+	end
+
+	def dup_block_forward(position)
+		block = self[0..position.to_i]
+		self.insert(0, block) if block
+		self
+	end
+end
+
+
+class Rules
+	@@rules = []
+	attr_accessor :character, :mutation, :takes_param, :param_count
+
+	def initialize(character, mutation, takes_param, param_count)
+		@character   = character
+		@mutation    = mutation
+		@takes_param = takes_param
+		@param_count = param_count
+		@@rules << self
+	end
+
+	def self.find_rule(character)
+		@@rules.select { |r| r.character == character }.first
+	end
+
+	def takes_parameters?
+		self.takes_param
+	end
+
+	def self.all_rules
+		@@rules
+	end
+end
+
+
+rules.each { |r| Rules.new(r[:character], r[:mutation], r[:takes_param], r[:param_count]) }

metadata

@@ -0,0 +1,45 @@
+--- !ruby/object:Gem::Specification
+name: hrules
+version: !ruby/object:Gem::Version
+  version: 0.0.1
+platform: ruby
+authors:
+- Aidan Damerell
+autorequire: 
+bindir: bin
+cert_chain: []
+date: 2019-11-11 00:00:00.000000000 Z
+dependencies: []
+description: A simple addition to the String class in Ruby to mutate based on Hashcat-style
+  rules
+email: aidan.damerell@icloud.com
+executables: []
+extensions: []
+extra_rdoc_files: []
+files:
+- lib/hrules.rb
+homepage: https://rubygems.org/gems/hrules
+licenses:
+- MIT
+metadata: {}
+post_install_message: 
+rdoc_options: []
+require_paths:
+- lib
+required_ruby_version: !ruby/object:Gem::Requirement
+  requirements:
+  - - ">="
+    - !ruby/object:Gem::Version
+      version: '0'
+required_rubygems_version: !ruby/object:Gem::Requirement
+  requirements:
+  - - ">="
+    - !ruby/object:Gem::Version
+      version: '0'
+requirements: []
+rubyforge_project: 
+rubygems_version: 2.7.8
+signing_key: 
+specification_version: 4
+summary: Hashcat rules in Ruby
+test_files: []