phoenix_password 0.2.0 → 1.0.0

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA1:
-  metadata.gz: 62fc2d5162961619812bc5c72b25b055c27c5540
-  data.tar.gz: 68c1882f3687bdfe8163cedcbccfec2a0afe27ef
+  metadata.gz: 2d4eac9a6ff94dc2cc0f4b165c051afdcfb63e75
+  data.tar.gz: 53c8b1891a2847b09068067a7e6092a9545062bb
 SHA512:
-  metadata.gz: '0588f9c5423c5b85cac84ee81621c93e5812f9641b7ea801f1473ed014eb3d4060a071fa30bb63e5df431c59668846e7a722d70919c5d47e2adfc0f71e1cea6e'
-  data.tar.gz: 4ccba59a3c45a9a8cd79dc58d1b9243b1bfafab37b39d1f3d2116987497180a0867dd86ba3a0fdcf2d29d1274a3a8b688cba13fa0c96847807a48095e8fb9be2
+  metadata.gz: db1bfaec1ef9a45cf271b078d977e5d8dbc2b9c0bded7fe24cb07742a1dc83b6e385905c8e304ebf745072f4168a6298cf07bf932e9c1b4c436c7beb489010b2
+  data.tar.gz: 3b04f52dacf88299c4ae586ea8fc50d9a7f3d74fa1284c67545a7569aa81a57c37cbbc5e4e47d84887d0acf0f9a230c4f82f96e6883cac826750919cbcb968c3

metadata

@@ -1,14 +1,14 @@
 --- !ruby/object:Gem::Specification
 name: phoenix_password
 version: !ruby/object:Gem::Version
-  version: 0.2.0
+  version: 1.0.0
 platform: ruby
 authors:
 - Spiros Avlonitis
 autorequire: 
 bindir: exe
 cert_chain: []
-date: 2017-06-11 00:00:00.000000000 Z
+date: 2017-06-20 00:00:00.000000000 Z
 dependencies:
 - !ruby/object:Gem::Dependency
   name: bundler
@@ -60,16 +60,7 @@ email:
 executables: []
 extensions: []
 extra_rdoc_files: []
-files:
-- ".gitignore"
-- ".rspec"
-- CODE_OF_CONDUCT.md
-- Gemfile
-- LICENSE.txt
-- README.md
-- Rakefile
-- lib/phoenix_password.rb
-- lib/phoenix_password/version.rb
+files: []
 homepage: https://github.com/spirosavlonitis/phoenix_password
 licenses:
 - MIT
@@ -90,7 +81,7 @@ required_rubygems_version: !ruby/object:Gem::Requirement
       version: '0'
 requirements: []
 rubyforge_project: 
-rubygems_version: 2.6.11
+rubygems_version: 2.6.12
 signing_key: 
 specification_version: 4
 summary: PhoenixPassword is an all purpose password genrator.

data/.gitignore

@@ -1,17 +0,0 @@
-/.bundle/
-/.yardoc
-/Gemfile.lock
-/_yardoc/
-/coverage/
-/doc/
-/pkg/
-/spec/reports/
-/tmp/
-/*.gem
-
-/.travis.yml
-/bin
-/*.gemspec
-
-# rspec failure tracking
-.rspec_status

data/.rspec

@@ -1,2 +0,0 @@
---format documentation
---color

data/CODE_OF_CONDUCT.md

@@ -1,74 +0,0 @@
-# Contributor Covenant Code of Conduct
-
-## Our Pledge
-
-In the interest of fostering an open and welcoming environment, we as
-contributors and maintainers pledge to making participation in our project and
-our community a harassment-free experience for everyone, regardless of age, body
-size, disability, ethnicity, gender identity and expression, level of experience,
-nationality, personal appearance, race, religion, or sexual identity and
-orientation.
-
-## Our Standards
-
-Examples of behavior that contributes to creating a positive environment
-include:
-
-* Using welcoming and inclusive language
-* Being respectful of differing viewpoints and experiences
-* Gracefully accepting constructive criticism
-* Focusing on what is best for the community
-* Showing empathy towards other community members
-
-Examples of unacceptable behavior by participants include:
-
-* The use of sexualized language or imagery and unwelcome sexual attention or
-advances
-* Trolling, insulting/derogatory comments, and personal or political attacks
-* Public or private harassment
-* Publishing others' private information, such as a physical or electronic
-  address, without explicit permission
-* Other conduct which could reasonably be considered inappropriate in a
-  professional setting
-
-## Our Responsibilities
-
-Project maintainers are responsible for clarifying the standards of acceptable
-behavior and are expected to take appropriate and fair corrective action in
-response to any instances of unacceptable behavior.
-
-Project maintainers have the right and responsibility to remove, edit, or
-reject comments, commits, code, wiki edits, issues, and other contributions
-that are not aligned to this Code of Conduct, or to ban temporarily or
-permanently any contributor for other behaviors that they deem inappropriate,
-threatening, offensive, or harmful.
-
-## Scope
-
-This Code of Conduct applies both within project spaces and in public spaces
-when an individual is representing the project or its community. Examples of
-representing a project or community include using an official project e-mail
-address, posting via an official social media account, or acting as an appointed
-representative at an online or offline event. Representation of a project may be
-further defined and clarified by project maintainers.
-
-## Enforcement
-
-Instances of abusive, harassing, or otherwise unacceptable behavior may be
-reported by contacting the project team at spirosa84@hotmail.com. All
-complaints will be reviewed and investigated and will result in a response that
-is deemed necessary and appropriate to the circumstances. The project team is
-obligated to maintain confidentiality with regard to the reporter of an incident.
-Further details of specific enforcement policies may be posted separately.
-
-Project maintainers who do not follow or enforce the Code of Conduct in good
-faith may face temporary or permanent repercussions as determined by other
-members of the project's leadership.
-
-## Attribution
-
-This Code of Conduct is adapted from the [Contributor Covenant][homepage], version 1.4,
-available at [http://contributor-covenant.org/version/1/4][version]
-
-[homepage]: http://contributor-covenant.org
-[version]: http://contributor-covenant.org/version/1/4/

data/Gemfile

@@ -1,4 +0,0 @@
-source 'https://rubygems.org'
-
-# Specify your gem's dependencies in phoenix_password.gemspec
-gemspec

data/LICENSE.txt

@@ -1,21 +0,0 @@
-The MIT License (MIT)
-
-Copyright (c) 2017 Spiros Avlonitis
-
-Permission is hereby granted, free of charge, to any person obtaining a copy
-of this software and associated documentation files (the "Software"), to deal
-in the Software without restriction, including without limitation the rights
-to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
-copies of the Software, and to permit persons to whom the Software is
-furnished to do so, subject to the following conditions:
-
-The above copyright notice and this permission notice shall be included in
-all copies or substantial portions of the Software.
-
-THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
-IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
-FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
-AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
-LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
-OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN
-THE SOFTWARE.

data/README.md

@@ -1,127 +0,0 @@
-# PhoenixPassword
-
-The PhoenixPassword generator gem is intended to be used 
-in password recovery operations or random password generation
-purposes.
-
-## Installation
-
-Add this line to your application's Gemfile:
-
-```ruby
-gem 'phoenix_password'
-```
-
-And then execute:
-
-    $ bundle
-
-Or install it yourself as:
-
-    $ gem install phoenix_password
-
-## Usage
-In order to generate combinations simply add the minimum of the required options
-here is an irb example:
-
-```ruby
-irb(main):001:0> require 'phoenix_password'
-=> true
-irb(main):002:0>  PhoenixPassword.combinations({:piped=>true,:characters=>[0,1,2,3,4,5,6,7,8,9],:cmb_length=>[6],:type=>'matching'})
-```
-001273
-
-001274
-
-001275
-
-.....
-
-## Manual
-This is a list of the options available to you and what they do
-
-```ruby	
-:piped=>(true or false)
-```
-Lets you decide whether you want to pipe the results to an other program
-or write them to a file.
-
-```ruby
-:cmb_length=>([5] or [5,6])
-```
-Set the length of the possible combinations to be generated if
-there is more than one value first all the combinations with the
-starting value are generated and then once done combinations of
-the following length are generated till all the values have been used.
-
-```ruby
-:characters=>["e","x","m","p","l","e",1]
-```
-Sets the characters that will be used in the combination generation process.
-
-```ruby
-:extra_chars=>["x",1] (Optional)
-```
-Set extra characters to be used one at a time if the initial characters,minimum value 1 char.
-Note that when etxra_chars are used only combinations that include them will be written to file.
-	
-```ruby
-:type=>("matching" or "unique")
-```
-Sets which type of combinations to be generated.
-Matching: Characters repeating them selves any number of times xx or xxx
-Unique:Characters are different in every position xz or xzx
-
-```ruby
-:match_limit=> 2 (:optional)
-```
-Set the max matching characters for each combination example:
-
-2 = xxabc, axxbc,abxxc,abcxx
-
-3 = xxxab, axxxb,abxxx
-
-Note that you can set the limit to more than 3 but file size info will
-not be accurate.
-
-```ruby
-:skip_first=>(true |false) (Optional)
-```
-Used with extra_chars allows you to skip the first iteration with the
-main characters thus starting from the extra characters.Useful if you
-want to continue from where you left off.
-
-```ruby
-:uniqueness_type=>("repeat"|"singe") (Optional)
-```
-If not set all possible unique combinations are generated i.e reappearing char xzx,single char xyz
-When set to repeat only reappearing character combinations are generated xzx
-When set to single only single character appearance combinations are generated xzy.
-
-
-```ruby
-:cap_limit=>1 or more (optional)
-
-```
-When used it ensures that each combination generated will contain only the amount of capital letters specified.
-
-**Note that file size and combination estimates  when using match_limit may not be accurate**
-
-
-
-
-## Development
-
-After checking out the repo, run `bin/setup` to install dependencies. Then, run `rake spec` to run the tests. You can also run `bin/console` for an interactive prompt that will allow you to experiment.
-
-To install this gem onto your local machine, run `bundle exec rake install`. To release a new version, update the version number in `version.rb`, and then run `bundle exec rake release`, which will create a git tag for the version, push git commits and tags, and push the `.gem` file to [rubygems.org](https://rubygems.org).
-
-## Contributing
-
-Bug reports and pull requests are welcome on GitHub at https://github.com/[USERNAME]/phoenix_password. This project is intended to be a safe, welcoming space for collaboration, and contributors are expected to adhere to the [Contributor Covenant](http://contributor-covenant.org) code of conduct.
-
-
-## License
-
-The gem is available as open source under the terms of the [MIT License](http://opensource.org/licenses/MIT).
-

data/Rakefile

@@ -1,6 +0,0 @@
-require "bundler/gem_tasks"
-require "rspec/core/rake_task"
-
-RSpec::Core::RakeTask.new(:spec)
-
-task :default => :spec

data/lib/phoenix_password/version.rb

@@ -1,3 +0,0 @@
-class PhoenixPassword
-  VERSION = "0.2.0"
-end

data/lib/phoenix_password.rb

@@ -1,770 +0,0 @@
-require "phoenix_password/version"
-
-class PhoenixPassword
-	def self.generate_combinations(data)
-		characters=data[:characters]
-		if !data[:extra_chars].nil?
-			characters.push(data[:extra_chars][data[:iteration]-1])  if data[:iteration] != 0
-		end
-		combination=Array.new(data[:cmb_length],data[:characters].first)
-		combination_length=combination.length
-		i=0
-		possible_combinations=characters.length**combination_length
-		chars_used=Array.new(data[:cmb_length],0)
-		
-		while i < possible_combinations/characters.length
-			x=1
-			change_count=1
-			while x < combination_length
-				if chars_used[x] == characters.length
-					chars_used[x] = 0
-				end
-				if combination[x] == characters.last && combination[x+1] == characters.last
-					change_count +=1
-					if change_count == combination_length -1
-						chars_used[0] += 1
-					end
-				end
-				x +=1
-			end
-
-			y=0
-			until y == combination_length
-				combination[y]=characters[chars_used[y]]
-				y+=1
-			end
-
-			combinations=[]
-			if data[:extra_chars].nil? || data[:iteration] == 0
-				
-			 combinations.<<(combination.join())
-			 if combination.last != characters.first
-				reverse_comb=combination.reverse
-				combinations.<<(reverse_comb.join())
-				reverse_comb.pop
-				reverse_compare=reverse_comb
-				reverse_comb=reverse_comb.join()
-		        check_match= matching_check({:combination=>reverse_comb,:match_limit=>data[:match_limit],:cap_limit=>data[:cap_limit]})
-				characters.each do |char|
-					next if char == characters.first
-					if  data[:type] == "unique"
-						combinations.<<("%s%s"%[reverse_comb,char])
-					else
-						if check_match
-							combinations.<<("%s%s"%[reverse_comb,char])	
-						else							
-						  combinations.<<("%s%s"%[reverse_comb,char]) if char == reverse_compare.last
-						end
-					end
-				end
-			 end
-
-			else
- 			  	combinations << combination.join() if combination.include?(characters.last)
-		     if combination.last != characters.first
-					reverse_comb=combination.reverse 
-				    reverse_comb.pop
-				    reverse_compare=reverse_comb
-				    reverse_comb=reverse_comb.join
-				if reverse_comb.include?(characters.last)
-		        	check_match= matching_check({:combination=>reverse_comb,:match_limit=>data[:match_limit],:cap_limit=>data[:cap_limit]}) if data[:type] == 'matching'
-					characters.each do |char|
-						if  data[:type] == "unique"
-							combinations.<<("%s%s"%[reverse_comb,char])
-						elsif check_match
-							combinations.<<("%s%s"%[reverse_comb,char])
-						else							
-						    combinations.<<("%s%s"%[reverse_comb,char]) if char == reverse_compare.last
-						end
-					end
-				else						
-				  combinations.<<("%s%s"%[reverse_comb,characters.last])				
-				end
-			 end
-			end
-
-			yield(combinations) if combinations.length >= 1
-
-			z=combination_length-1
-			while 1 < z
-				if  z == combination_length-1
-					chars_used[z-1] +=1	if combination[z] == characters.last 
-				else
-					diff=(combination_length-1)-z
-					last_chars=0
-					count_diff=1
-					while count_diff <= diff
-						if combination[z] == characters.last && combination[z+count_diff] == characters.last
-							last_chars +=1
-						end
-						count_diff +=1
-					end
-					if last_chars == (combination_length-1)-z
-						chars_used[z-1] +=1
-					end
-				end
-				z-=1
-			end
-			chars_used[combination_length-1] +=1
-			i+=1
-		end
-		return characters
-	end
-	
-	def self.matching_combinations(info)
-		data={:characters=>info[:characters],:cmb_length=>info[:cmb_length],:type=>info[:type]}
-	    unless info[:extra_chars].nil?
-	   	 	 data[:extra_chars]=info[:extra_chars]
-	    end
-
-		matching_file=create_file(info) if !info[:piped]
-
-		char_sum=data[:characters].length
-		total_characters=data[:characters].length
-		unless data[:extra_chars].nil?
-			total_characters=data[:characters].length+data[:extra_chars].length
-			data[:iteration]=0
-			if info[:skip_first] || !info[:piped]
-				data[:iteration] +=1
-				char_sum +=1
-			end
-		end
-		
-		matching=0
-		begin
-		 generate_combinations(data) do |combinations|
-		  combinations.each do |combination|
-			if matching_check({:combination=>combination,:match_limit=>info[:match_limit],:cap_limit=>info[:cap_limit]})
-				 if info[:piped]
-						puts combination
-				 else
-					matching_file.puts(combination)
-				 end
-			 matching +=1
-			end
-		  end
-		 end
-			data[:iteration]+=1 unless data[:iteration].nil?
-			char_sum +=1
-		rescue => e
-			raise
-	    end while char_sum <= total_characters
-		matching_file.close unless matching_file.nil?
-		return matching
-	end
-
-	def self.matching_check(info)
-		combination=info[:combination]
-		if info[:cap_limit]
-		  caps=combination.scan(/[A-Z]/)
-		  return false if caps.length == 0 || caps.length > info[:cap_limit]
-		end
-		i=0
-		x=0
-		u=0
-		while i < (combination.length-1)
-			if combination[i] == combination[i+1]
-  	 	      return true if info[:match_limit].nil?
-		 	  if i == 0
-		 	     x +=1
-		 	  elsif combination[i] == combination[i-1] 	|| combination[i] == combination[i+info[:match_limit]] 
-		 	  	 x+=1		 	  			
-		 	  end
-		 	else 
-		 		u +=1
-			end
-		    if x == info[:match_limit] || u == combination.length-1
-			 return false
-		    end
-			i+=1
-		end
-		return true
-	end
-
-	def self.unique_combinations(info)
-	   data={:characters=>info[:characters],:cmb_length=>info[:cmb_length],:type=>info[:type],:uniqueness_type=>info[:uniqueness_type]}
-	   unless info[:extra_chars].nil?
-	   		data[:extra_chars]=info[:extra_chars]
-	   end
-
- 	   unique_file=create_file(info) unless info[:piped]
-
-	   total_characters=data[:characters].length
-	   char_sum= data[:characters].length
-	   unless data[:extra_chars].nil?
-			total_characters=data[:characters].length+data[:extra_chars].length
-			data[:iteration]=0
-			if info[:skip_first] || !info[:piped]
-				data[:iteration]+=1
-				char_sum +=1
-			end
-	   end
-	   unique_combs=0
-	   uniqueness=info[:uniqueness_type]
-	   begin
-		generate_combinations(data) do |combinations|
-		  combinations.each do |combination|
-			 unique_chars=check_uniqueness(combination,uniqueness,info[:cap_limit])
-		 	 if unique_chars == combination.length-1
-				if info[:piped]
-				  puts combination 
-				else	
-				  unique_file.puts(combination)
-				end
-			    unique_combs= unique_combs+1
-			 end
-		  end
-		end
-		data[:iteration] +=1 if !data[:iteration].nil?
-		char_sum +=1
-		rescue => e
-			raise
-		end while char_sum <= total_characters
-		
-		unless unique_file.nil?
-			unique_file.close
-		end
-
-		return unique_combs
-	end
-
-	def self.check_uniqueness(combination,uniqueness,cap_limit)
-	    if cap_limit
-		  caps=combination.scan(/[A-Z]/)
-		  return 0 if caps.length == 0 || caps.length > cap_limit
-		end
-		i=0
-		unique_chars=0
-		chars_check=[]
-		while i < (combination.length-1)
-			if combination[i] != combination[i+1]
-			  if uniqueness.nil?
-			     unique_chars+=1
-			  elsif uniqueness == "single"
-				   if i == 0
-				   	  unique_chars+=1
-				   	  chars_check.push(combination[i])
-				   elsif !chars_check.include?(combination[i])
-				   		chars_check << combination[i]
-				   		if !chars_check.include?(combination[i+1])
-				   			unique_chars +=1
-				   		else
-				   			return 0
-				   		end
-				   end
-			  elsif uniqueness == "repeat"
-				   	if i == 0
-				   	  unique_chars+=1
-				   	  chars_check.push(combination[i])
-				   	elsif chars_check.include?(combination[i])
-				   	   unique_chars+=1
-				   	elsif i == (combination.length-2)
-				   		#since in last iteration compare against the next character as well
-				   		unique_chars +=1 if chars_check.include?(combination[i]) || chars_check.include?(combination[i+1])
-				   	else  							   		
-				   		chars_check.push(combination[i])
-				   	end
-
-				   	return combination.length-1 if i == (combination.length-2) && unique_chars > 1
-			  end
-			else
-			 return 0
-			end
-			i+=1
-		end
-		return unique_chars
-	end
-
-	def self.get_single_combs(data)
-		i=0
-		single_combinations=0
-		extra_singe=0
-		extra_chars=data[:characters].length+data[:extra_chars].length if !data[:extra_chars].nil?
-		while i < data[:cmb_length]-1
-			if i == 0
-				single_combinations=(data[:characters].length-1)*data[:characters].length
-				extra_singe=extra_chars*(extra_chars-1) if !extra_chars.nil?
-			else
-				single_combinations=single_combinations*(data[:characters].length-(i+1))
-				extra_singe=extra_singe*(extra_chars-(i+1)) if !extra_chars.nil?
-			end
-			i+=1
-		end
-		return extra_singe - single_combinations if !data[:extra_chars].nil?
-		return single_combinations
-	end
-
-	def self.get_combinations(data)
-		if data[:extra_chars].nil?
-			base=data[:characters].length
-		else
-			old_base=data[:characters].length
-			old_combinations=old_base**data[:cmb_length]
-			x=0
-			post_matches=0
-			while x < data[:cmb_length]-1
-				if x == 0
-					post_matches=old_base
-				elsif x == 1
-					post_matches=(old_base**x)+(1*(old_base-1))
-				else
-					post_matches=(old_base**x)+(post_matches*(old_base-1))
-				end
-				x+=1
-			end
-			old_matches=old_base*post_matches
-			base=data[:characters].length+data[:extra_chars].length
-		end
-		previous_matches=0
-		i=0
-
-		while i < data[:cmb_length]-1
-			if i==0
-				previous_matches=base
-			elsif i== 1
-				previous_matches=(base**i)+(1*(base-1))
-			else
-				previous_matches=(base**i)+(previous_matches*(base-1))
-			end
-			i+=1
-		end
-		matches=base*previous_matches
-
-		if data[:type]=='unique'
-		    possible_combinations=base**data[:cmb_length]
-			if data[:uniqueness_type].nil?
-			   return (possible_combinations-matches)-(old_combinations-old_matches) if !data[:extra_chars].nil?
-			   return possible_combinations-matches
-			else
-			   single_combs=get_single_combs(data)
-			   if data[:uniqueness_type]=="single"
-				  return single_combs
-			   elsif data[:uniqueness_type]=="repeat"
-				   return ((possible_combinations-matches)-(old_combinations-old_matches))-single_combs if !data[:extra_chars].nil?
-				   return (possible_combinations-matches)-single_combs
-			   end
-			end
-		else
-			return matches-old_matches  if !data[:extra_chars].nil?
-			return matches
-		end
-		return 0
-	end
-
-	def self.get_above_limit(data)
-		if data[:extra_chars].nil?
-			base=data[:characters].length
-		else
-			old_base=data[:characters].length
-			previous_matches=0
-		    previous_mult=0
-		    i=0
-		    while i < (data[:cmb_length] -1)
-		    	if i == (data[:match_limit]-1)
-		    	   previous_matches=old_base
-				   old_matches=previous_matches
-		    	elsif i == data[:match_limit]
-		    		previous_matches=previous_matches+(1*(old_base-1))
-		    		previous_mult=1
-		    	else
-		    		temp_mult=previous_matches
-		    		previous_matches=(old_base**(i-1)+previous_mult*(old_base-1))+(previous_matches*(old_base-1))
-					previous_mult=temp_mult
-		    	end
-
-		    	i+=1
-		    end
-
-		    old_matches=old_base*previous_matches if data[:cmb_length] != (data[:match_limit]+1)
-			base=data[:characters].length+data[:extra_chars].length
-		end
-
-		previous_matches=0
-		previous_mult=0
-		i=1
-		while i < (data[:cmb_length] -1)
-			if i == (data[:match_limit]-1)
-				previous_matches=base
-				return previous_matches if data[:cmb_length] == (data[:match_limit]+i) && data[:extra_chars].nil?
-			elsif i == data[:match_limit]
-				previous_matches=previous_matches+(1*(base-1))
-				previous_mult=1
-			else
-				temp_mult=previous_matches
-				previous_matches=(base**(i-1))+(previous_mult*(base-1))+(previous_matches*(base-1))
-				previous_mult=temp_mult
-
-			end
-			i+=1
-		end
-		
-		unless data[:extra_chars].nil?
-			return base-old_base if data[:cmb_length] == (data[:match_limit]+1)
-			return (base*previous_matches)-old_matches
-		else
-		    return base*previous_matches
-		end
-	end
-
-	def self.cap_limit_matching(data)
-		cap_data={}
-			total_chars=data[:characters].join()
-			caps_matched= total_chars.scan(/[A-Z]/)
-			cap_data[:characters]=[]
-			data[:characters].each do |char|
-				next if caps_matched.include?(char)
-				cap_data[:characters].push(char)
-			end
-			base=cap_data[:characters].length
-			cap_matches=0
-			case data[:cmb_length]
-			  when 3
-				cap_matches += base*2
-			  when 4
-				  	cap_matches+=get_combinations({:characters=>cap_data[:characters],:cmb_length=>data[:cmb_length]-1})*2
-				  	cap_matches+=(base**2)*2
-			  else
-			  	cap_matches+=get_combinations({:characters=>cap_data[:characters],:cmb_length=>data[:cmb_length]-1})*2			  	
-			  	cap_matches+=(get_combinations({:characters=>cap_data[:characters],:cmb_length=>data[:cmb_length]-2})*base)*(data[:cmb_length]-2)
-			end
-
-		if !data[:extra_chars].nil?
-			all_chars=data[:characters]+data[:extra_chars]
-			new_cap_matches=cap_limit_matching({:cmb_length=>data[:cmb_length],:characters=>all_chars})
-			return	new_cap_matches-(cap_matches*caps_matched.length)
-		else
-  		  return cap_matches*caps_matched.length		
-		end
-
-	end
-
-	def self.cap_limit_matching_l(data)
-		cap_data={}		
-		total_chars=data[:characters].join()
-		caps_matched= total_chars.scan(/[A-Z]/)
-		cap_data[:characters]=[]
-		data[:characters].each do |char|
-			next if caps_matched.include?(char)
-			cap_data[:characters].push(char)
-		end
-		base=cap_data[:characters].length
-		cap_matches=0
-		no_limit_matches=get_combinations({:characters=>cap_data[:characters],:cmb_length=>data[:cmb_length]-1})
-		case data[:cmb_length]
-		  when 3
-			cap_matches += base*2
-		  when 4
-			 cap_matches+=(no_limit_matches-get_above_limit({:characters=>cap_data[:characters],:cmb_length=>data[:cmb_length]-1,:match_limit=>data[:match_limit]}))*2
-			 cap_matches+=(base**2)*2
-		  else
-
-		  	#XXA
-		  	cap_matches+=(no_limit_matches-get_above_limit({:characters=>cap_data[:characters],:cmb_length=>data[:cmb_length]-1,:match_limit=>data[:match_limit]}))*2
-		  	no_limit_matches=get_combinations({:characters=>cap_data[:characters],:cmb_length=>data[:cmb_length]-2})
-		  	#XAX
-		  	cap_matches+=((no_limit_matches-get_above_limit({:characters=>cap_data[:characters],:cmb_length=>data[:cmb_length]-2,:match_limit=>data[:match_limit]}))*base)*2
-		  	x=data[:cmb_length]-4
-		  	if x == 1
-				cap_matches +=get_combinations({:characters=>cap_data[:characters],:cmb_length=>data[:cmb_length]-2})*base
-		  	elsif x == 2
-				grt_half_no_limit=get_combinations({:characters=>cap_data[:characters],:cmb_length=>data[:cmb_length]-3})
-				grt_half_limit =grt_half_no_limit-get_above_limit({:characters=>cap_data[:characters],:match_limit=>data[:match_limit],:cmb_length=>data[:cmb_length]-3})
-				cap_matches +=(((grt_half_limit*base**2)+(base*base**3))-(grt_half_no_limit*base))*2
-		  	else
-		  		#AXX
-				i=3
-				p=0
-				l=0
-				begin
-					grt_half=get_combinations({:characters=>cap_data[:characters],:cmb_length=>data[:cmb_length]-(3+l)})
-					grt_half_limit =grt_half-get_above_limit({:characters=>cap_data[:characters],:match_limit=>data[:match_limit],:cmb_length=>data[:cmb_length]-(3+l)})
-					if i == 3
-						if data[:cmb_length] <=8							
-								cap_matches +=(((grt_half_limit*base**2)+(base*base**(x+1)))-(grt_half*base))*2
-							else
-							cap_matches +=((grt_half_limit*((base**2)-base))+(base*base**(x+1)))*2
-
-						end 
-					else
-						lsr_half=get_combinations({:characters=>cap_data[:characters],:cmb_length=>i-1})
-						lsr_half_limit=lsr_half-get_above_limit(:characters=>cap_data[:characters],:match_limit=>data[:match_limit],:cmb_length=>i-1)
-						cap_matches +=(((grt_half_limit*(base**(2+p)))+(lsr_half_limit*base**(x+1-p)))-(grt_half*lsr_half))*2
-						  	
-					end
-					p+=1
-					l+=1
-					i+=1
-				end while i < (data[:cmb_length]/2.0).ceil
-
-
-
-				if x%2 == 1
-					no_limit_matches=get_combinations({:characters=>cap_data[:characters],:cmb_length=>x-(p-1)})
-					half_point=(((no_limit_matches-get_above_limit({:characters=>cap_data[:characters],:cmb_length=>x-(p-1),:match_limit=>data[:match_limit]})))*base**(x-(p-1)))*2
-					if data[:cmb_length] == 7
- 				    	cap_matches+=half_point-((half_point/base))
-					else
-						half_no_limit=get_combinations(:characters=>cap_data[:characters],:cmb_length=>x-1)							
-						half_no_limit_b=get_combinations(:characters=>cap_data[:characters],:cmb_length=>x-2)
-
-						if data[:cmb_length] >= 9 && data[:extra_chars].nil?
-							puts "!------Approximately less  than------!"
-						end
-						cap_matches+=half_point-((half_point/base))
-						
-					end
-
-				else
-					no_limit_matches_a=get_combinations({:characters=>cap_data[:characters],:cmb_length=>(x-l)+1})
-					greater_half=(((no_limit_matches_a-get_above_limit({:characters=>cap_data[:characters],:cmb_length=>(x-l)+1,:match_limit=>data[:match_limit]})))*base**(x-l))
-					no_limit_matches_b=get_combinations({:characters=>cap_data[:characters],:cmb_length=>(x-l)})
-					lesser_half=(((no_limit_matches_b-get_above_limit({:characters=>cap_data[:characters],:cmb_length=>(x-l),:match_limit=>data[:match_limit]})))*base**(x-l+1))
-					
-					if data[:cmb_length] == 10 && data[:extra_chars].nil?
-						puts "!------Approximately less  than------!"
-					elsif data[:cmb_length] == 12 && data[:extra_chars].nil?
-						puts "!------Approximately more  than------!"
-					end
-					cap_matches+=((greater_half+lesser_half)-((no_limit_matches_a*no_limit_matches_b)-(no_limit_matches_b*base)))*2
-				end
-
-		  	end
-			  
-		end
-
-		if (cap_data[:characters].length <= 2 || data[:cmb_length] >= 13) && data[:extra_chars].nil?
-			puts "!!!----Inaccurate information----!!!"
-		end
-
-		if !data[:extra_chars].nil?
-			all_chars=data[:characters]+data[:extra_chars]
-			new_cap_matches=cap_limit_matching_l({:cmb_length=>data[:cmb_length],:characters=>all_chars,:match_limit=>data[:match_limit]})
-			return	new_cap_matches-(cap_matches*caps_matched.length)
-		else
-    		return cap_matches*caps_matched.length		
-		end
-	end
-
-	def self.unique_cap_limit(data)
-		cap_data={}
-		total_chars=data[:characters].join()
-		caps_matched= total_chars.scan(/[A-Z]/)
-		cap_data[:characters]=[]
-		data[:characters].each do |char|
-			next if caps_matched.include?(char)
-			cap_data[:characters].push(char)
-		end
-		base=cap_data[:characters].length
-		unique_cap_limit=0
-		if data[:uniqueness_type] == 'single'
-		  if data[:cmb_length] == 3
-			  unique_cap_limit=(((base**2)-(base))*3)
-		  else
-			  previous_single=get_single_combs(:characters=>cap_data[:characters],:cmb_length=>data[:cmb_length]-1,:type=>"unique")
-			  unique_cap_limit=previous_single*data[:cmb_length]
-	   	  end
-		else
-			case data[:cmb_length]
-				when 3
-					if data[:uniqueness_type].nil?
-						unique_cap_limit=((base**2)*3)-(base*2)
-					else
-						unique_cap_limit=((base**2)*3)-(base*2)-(((base**2)-(base))*3)
-					end
-				when 4
-					previous_unique=get_combinations(:characters=>cap_data[:characters],:cmb_length=>data[:cmb_length]-1,:type=>"unique")
-				   if data[:uniqueness_type].nil?
-						unique_cap_limit=(previous_unique*2)+((((base**2)-base)*base)*2)
-				   else
-						previous_single=get_single_combs(:characters=>cap_data[:characters],:cmb_length=>data[:cmb_length]-1,:type=>"unique")
-						unique_cap_limit=(previous_unique*2)+((((base**2)-base)*base)*2)-(previous_single*data[:cmb_length])
-				   end					
-				else
-					previous_unique_a=get_combinations(:characters=>cap_data[:characters],:cmb_length=>data[:cmb_length]-1,:type=>"unique")
-					previous_unique_b=get_combinations(:characters=>cap_data[:characters],:cmb_length=>data[:cmb_length]-2,:type=>"unique")
-					if data[:uniqueness_type].nil?
-						unique_cap_limit=(previous_unique_a*2)+((previous_unique_b*base)*(data[:cmb_length]-2))
-					else
-						previous_single=get_single_combs(:characters=>cap_data[:characters],:cmb_length=>data[:cmb_length]-1,:type=>"unique")
-						unique_cap_limit=(previous_unique_a*2)+((previous_unique_b*base)*(data[:cmb_length]-2))-(previous_single*data[:cmb_length])
-					end
-			end
-		end
-			
-		if !data[:extra_chars].nil?
-			all_chars=data[:characters]+data[:extra_chars]
-			new_unique_cap_limit=unique_cap_limit({:cmb_length=>data[:cmb_length],:characters=>all_chars,:uniqueness_type=>data[:uniqueness_type]})
-			return	new_unique_cap_limit-(unique_cap_limit*caps_matched.length)
-		else
-			return unique_cap_limit*caps_matched.length
-		end
-
-	end
-
-	def self.cap_limit_combs(data,x=0)
-		if data[:type] == "matching"
-			if !data[:match_limit].nil?
-			   puts "Combinations and file size may vary when using match_limit" if x == 0
-			   cap_limit_matching_l(data)
-			else
-			   cap_limit_matching(data)			
-			end
-		else
-			unique_cap_limit(data)			
-		end
-	end
-
-	def self.get_size(data)
-		bytes=data[:combinations]*(data[:cmb_length]+1)
-		kilo_bytes=bytes/1000.0
-		mega_bytes=kilo_bytes/1000.0
-		giga_bytes=mega_bytes/1000.0
-		tera_bytes=giga_bytes/1000.0
-		peta_bytes=tera_bytes/1000.0
-		all_sizes= {:bytes=>bytes,:kilo=>kilo_bytes,:mega=>mega_bytes,:giga=>giga_bytes,:tera=>tera_bytes,:peta=>peta_bytes}
-		return_sizes= {}
-		all_sizes.each do |key,value|			
-			if kilo_bytes < 1
-				return_sizes[key]=value
-				break
-			end
-			return_sizes[key]=value if value > 0.01 && key != :bytes
-		end
-		yield(return_sizes) if block_given?
-		return return_sizes
-	end
-
-
-	def self.create_file(data)
-		    continue=file_info(data)
-			case continue
-			when /(y|Y)/
-				if data[:file_append]
-					return File.open("#{data[:file_append]}.txt","a")
-				else					
-					puts "Creating file"
-					print "Enter save file name:"
-				    file_name=gets.chomp
-				    data[:file_append]=file_name if !data[:file_append].nil?
-					return File.open("#{file_name}.txt","w")
-				end
-
-			when /(n|N)/
-				puts "Goodbye"
-				exit
-			else
-				puts "Invalid option"
-				exit
-			end	
-	end
-
-	def self.file_info(data)
-		if data[:file_append].nil? || !data[:file_append]
-			if data[:write_cmbs].nil?
-				poss_combs=get_combinations(data)
-				if !data[:match_limit].nil?
-					if !data[:cap_limit].nil?
-						poss_combs=cap_limit_combs(data)
-					else
-				  		poss_combs -= get_above_limit(data)
-					end
-				elsif !data[:cap_limit].nil?
-			      poss_combs=cap_limit_combs(data)
-				end
-				matching_file_size=get_size({:cmb_length=>data[:cmb_length],:combinations=>poss_combs})
-			else
-				poss_combs=0
-				matching_file_size={:bytes=>0,:kilo=>0,:mega=>0,:giga=>0,:tera=>0,:peta=>0}
-				dataB=data.clone
-				cmb_count=data[:write_cmbs].length if !data[:cap_limit].nil?
-				data[:write_cmbs].each do |n|
-					dataB[:cmb_length]=n
-				  if data[:cap_limit].nil?
-					current_combs=get_combinations(dataB)
-					poss_combs +=current_combs
-				    unless data[:match_limit].nil?
-					     poss_combs -= get_above_limit(dataB)
-					     current_combs -= get_above_limit(dataB)
-				    end
-				  else
-				  	 current_combs=cap_limit_combs(dataB,cmb_count)
-				  	 cmb_count -= 1
-				  	 poss_combs +=cap_limit_combs(dataB,cmb_count)
-				  end
-					get_size({:cmb_length=>n,:combinations=>current_combs})do |sizes|
-						sizes.each do |key,value|
-							matching_file_size[key] +=value
-						end 
-						matching_file_size[:bytes]=0 if matching_file_size[:kilo] >= 1
-					end
-				end
-			end
-			puts "Possible  #{data[:type]} combinations #{poss_combs}."
-			size_string="File size:"
-			matching_file_size.each do |key,value|
-				next if value == 0
-				size_string += " #{"%.2f"% value}#{key.capitalize}#{'Bytes' if key != :bytes}"
-			end
-			puts size_string
-			puts "Do you wish to continue ?"
-			puts "y|Y n|N"
-			return gets.chomp
-
-		elsif data[:file_append]
-			return "y"
-		end
-	end
-
-	def self.multi_length_matching(data)
-		dataB=data.clone
-		i=0
-		while i < data[:cmb_length].length
-			dataB[:cmb_length] = data[:cmb_length][i]
-			dataB[:characters]=data[:characters].clone
-			matching_combinations(dataB)
-			i+=1
-		end
-	end
-
-	def self.multi_length_unique(data)
-		dataB=data.clone
-		i=0
-		while i < data[:cmb_length].length
-			dataB[:cmb_length] = data[:cmb_length][i]
-			dataB[:characters]=data[:characters].clone
-			unique_combinations(dataB)
-			i+=1
-		end
-	end
-
-	def self.combinations(data)
-		case data[:type]
-	  	 when "matching"
-	  	 	if data[:cmb_length].length == 1
-	  	 	   data[:cmb_length]=data[:cmb_length][0]
-			   matching_combinations(data)
-			elsif data[:piped]
-				multi_length_matching(data)
-			else
-				data[:file_append]=false
-				data[:write_cmbs]=data[:cmb_length].clone
-				multi_length_matching(data)
-	  	 	end
-
-		 when "unique"
-		 	if data[:cmb_length].length == 1
-		 		data[:cmb_length]=data[:cmb_length].first
-		 		unique_combinations(data)
-		 	elsif data[:piped]
-		 		multi_length_unique(data)
-		 	else
-				data[:file_append]=false
-				data[:write_cmbs]=data[:cmb_length].clone
-				multi_length_unique(data)
-		 	end
-		 else
-		 	puts "Invalid combination type"
-		 	exit
-		end
-	end
-end