consistent_company 0.0.3

data/.document

@@ -0,0 +1,5 @@
+lib/**/*.rb
+bin/*
+- 
+features/**/*.feature
+LICENSE.txt

data/Gemfile

@@ -0,0 +1,15 @@
+source "http://rubygems.org"
+# Add dependencies required to use your gem here.
+# Example:
+#   gem "activesupport", ">= 2.3.5"
+
+# Add dependencies to develop your gem here.
+# Include everything needed to run rake, tests, features, etc.
+group :development do
+  gem "shoulda", ">= 0"
+  gem "bundler", "~> 1.0.18"
+  gem "jeweler", "~> 1.6.4"
+  gem "rcov", ">= 0"
+	gem 'pry'
+	gem "rake-compiler", "~> 0.7.6"
+end

data/Gemfile.lock

@@ -0,0 +1,36 @@
+GEM
+  remote: http://rubygems.org/
+  specs:
+    coderay (0.9.8)
+    git (1.2.5)
+    jeweler (1.6.4)
+      bundler (~> 1.0)
+      git (>= 1.2.5)
+      rake
+    method_source (0.6.5)
+      ruby_parser (>= 2.0.5)
+    pry (0.9.5)
+      coderay (>= 0.9.8)
+      method_source (>= 0.6.5)
+      ruby_parser (>= 2.0.5)
+      slop (~> 2.1.0)
+    rake (0.9.2)
+    rake-compiler (0.7.6)
+      rake
+    rcov (0.9.10)
+    ruby_parser (2.3.0)
+      sexp_processor (~> 3.0)
+    sexp_processor (3.0.6)
+    shoulda (2.11.3)
+    slop (2.1.0)
+
+PLATFORMS
+  ruby
+
+DEPENDENCIES
+  bundler (~> 1.0.18)
+  jeweler (~> 1.6.4)
+  pry
+  rake-compiler (~> 0.7.6)
+  rcov
+  shoulda

data/LICENSE.txt

@@ -0,0 +1,20 @@
+Copyright (c) 2011 Doug Cleven
+
+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

@@ -0,0 +1,97 @@
+# consistent_company
+
+A Ruby C Extension that takes a Company Name string and replaces it with a normalized compressed version.
+The new name is not meant for human consumption, but for comparing other like names to find matches.
+This was written with the Adverting domain in mind. So many of the common advertiser/agency abbreviations are
+handled well. Although it can work with other domains you may find need to enhance the specific company name 
+identifiers in IsCompanyName and TransformCompany.
+
+## Install:
+gem install consistent_company
+
+## Usage:
+A company_namer method is added to the string class.
+
+	>> require 'consistent_company'
+	=> true
+	>> 'First Federal Savings'.company_namer
+	=> '1STFEDERALSAVINGS'
+
+## Development:
+
+
+## CompanyNamer Function Transformations
+This function performs a sequence of changes to its input parameter, which should be the name of an advertiser or agency.
+
+1.	It transforms all alpha characters to upper case.
+
+2.	It loops through the string, finding and tracking open and close parenthesis characters.
+If it finds any of the following patterns, the parentheses and the text contained within them is removed 
+and replaced with a single space. 
+The “..” strings indicate other characters not within the parentheses; the “xx” characters represent any characters within the parentheses.
+All other patterns of parenthesis characters are left intact.
+..(xx)..	..(xx	..(xx)..(xx)..	..(xx(xx)xx)..	..(xx)..(xx	..(xx(xx)xx	..(xx(xx
+
+3.	It loops through the string performing character-level transformations:
+
+	a.	Characters in the ranges A-Z, 0-9, and high-order characters (ASCII value 128 or greater) are kept  unchanged.
+
+	b.	Single tic-marks (‘) are removed
+
+	c.	An ampersand character (&) in the middle of the name is converted to “AND”, with surrounding spaces as they were
+
+	d.	A plus sign (+) is converted to “PLUS” if it is preceded only by “A” (taking account of spacing); otherwise it is converted to “AND”
+
+	e.	All other characters are converted to spaces
+
+	f.	All the above transformations ensure that there are no multiple spaces in the result
+
+4.	It replaces all instances of “ AND ” (the word “and” surrounded by spaces) with “ & ”, and removes leading and trailing spaces.
+
+5.	It passes the string through TransformCompany and then returns the result.
+
+## TransformCompany Function Transformations
+This function transforms elements of the company name at the word level, 
+removing some and making variants into a common form. 
+It also changes commonly used long words into shorter versions, to speed the hashing process.
+
+1.	It removes the word “THE”
+
+2.	It transforms the first eleven number words into numeric form: “THREE” becomes “3”
+
+3.	It transforms the first ten ordinals into numeric form: “SIXTH” becomes “6TH”
+
+4.	It transforms common words to a common abbreviation. "CENTER" becomes CTR
+
+5.	Leading and trailing spaces are removed
+
+6.	If the string has more than one word and more than three characters:
+
+	a.	If the leading word is “A” and the second word is neither an initial or “PLUS”, remove the leading “A”.Example: “A B & X” keeps its “A”, as does “A PLUS”, but “A TOUCH OF CLASS” does not.
+	
+	b. If the last word in the name is a “company word” as defined by IsCompanyWord, then remove it and repeat the check and removal on the resulting last word. 
+	
+	c.	If the last character in the name is now “&”, remove it
+
+7.	Remove all spaces from the name and return .
+
+## IsCompanyWord Function
+The following words are recognized as commonly-used in company names without adding to the distinguishing characteristics of the name.
+
+ADV, ADVERTISER, ADV, ADVERTISING, AGCY, AGENCY, AGY, ASC, ASS, ASSN, ASSOC, ASSOCIAT, ASSOCIATES, ASSOCIATION, ATTORNEY, ATTRNY, ATTY, ATY, AUTO, CO, COMP, COMPANIES, COMPANY, CORP, CORPORATION, CT, CONTRA, DEPARTMENT, DEPT, DIR, DIRECT, DIV, DIVISION, GROUP, HOLDINGS, INC, INCORPORATED, INT, LIMITED, LLC, LLP, LOCAL, LTD, PC, PLC, PROD, PRODS, PRODUCT, PRODUCTIONS, PRODUCTS, TR, TRADE
+
+== Contributing to consistent_company
+ 
+* Check out the latest master to make sure the feature hasn't been implemented or the bug hasn't been fixed yet
+* Check out the issue tracker to make sure someone already hasn't requested it and/or contributed it
+* Fork the project
+* Start a feature/bugfix branch
+* Commit and push until you are happy with your contribution
+* Make sure to add tests for it. This is important so I don't break it in a future version unintentionally.
+* Please try not to mess with the Rakefile, version, or history. If you want to have your own version, or is otherwise necessary, that is fine, but please isolate to its own commit so I can cherry-pick around it.
+
+== Copyright
+
+Copyright (c) 2011 Doug Cleven. See LICENSE.txt for
+further details.
+

data/Rakefile

@@ -0,0 +1,48 @@
+# encoding: utf-8
+
+require 'rubygems'
+require 'bundler'
+
+begin
+  Bundler.setup(:default, :development)
+rescue Bundler::BundlerError => e
+  $stderr.puts e.message
+  $stderr.puts "Run `bundle install` to install missing gems"
+  exit e.status_code
+end
+require 'rake'
+
+require "rake/extensiontask"
+Rake::ExtensionTask.new("consistent_company") do |extension|
+  extension.lib_dir = "lib/consistent_company"
+end
+
+task :build => [:clean, :compile]
+
+require 'jeweler'
+require './lib/consistent_company/version.rb'
+Jeweler::Tasks.new do |gem|
+  # gem is a Gem::Specification... see http://docs.rubygems.org/read/chapter/20 for more options
+  gem.name = "consistent_company"
+  gem.homepage = "http://github.com/dcleven/consistent_company"
+  gem.license = "MIT"
+  gem.summary = %Q{Normalize a company name for consistent matching}
+  gem.description = %Q{Ruby C Extension to normalize a company name. Useful when company names come from various sources.}
+  gem.email = "dcleven@marketron.com"
+  gem.authors = ["Doug Cleven"]
+  gem.version = ConsistentCompany::Version::STRING
+  gem.files.include('lib/consistent_company/*') # add native stuff
+  # dependencies defined in Gemfile
+end
+Jeweler::RubygemsDotOrgTasks.new
+
+task :test => [:build]
+
+require 'rake/testtask'
+Rake::TestTask.new(:test) do |test|
+  test.libs << 'lib' << 'test'
+  test.pattern = 'test/**/test_*.rb'
+  test.verbose = true
+end
+
+task :default => :test

data/VERSION

@@ -0,0 +1 @@
+0.1.0

data/consistent_company.gemspec

@@ -0,0 +1,70 @@
+# Generated by jeweler
+# DO NOT EDIT THIS FILE DIRECTLY
+# Instead, edit Jeweler::Tasks in Rakefile, and run 'rake gemspec'
+# -*- encoding: utf-8 -*-
+
+Gem::Specification.new do |s|
+  s.name = %q{consistent_company}
+  s.version = "0.0.3"
+
+  s.required_rubygems_version = Gem::Requirement.new(">= 0") if s.respond_to? :required_rubygems_version=
+  s.authors = [%q{Doug Cleven}]
+  s.date = %q{2011-09-20}
+  s.description = %q{Ruby C Extension to normalize a company name. Useful when company names come from various sources.}
+  s.email = %q{dcleven@marketron.com}
+  s.extensions = [%q{ext/consistent_company/extconf.rb}]
+  s.extra_rdoc_files = [
+    "LICENSE.txt",
+    "README.md"
+  ]
+  s.files = [
+    ".document",
+    "Gemfile",
+    "Gemfile.lock",
+    "LICENSE.txt",
+    "README.md",
+    "Rakefile",
+    "VERSION",
+    "consistent_company.gemspec",
+    "ext/consistent_company/consistent_company.c",
+    "ext/consistent_company/extconf.rb",
+    "lib/consistent_company.rb",
+    "lib/consistent_company/consistent_company.bundle",
+    "lib/consistent_company/version.rb",
+    "test/helper.rb",
+    "test/test_consistent_company.rb"
+  ]
+  s.homepage = %q{http://github.com/dcleven/consistent_company}
+  s.licenses = [%q{MIT}]
+  s.require_paths = [%q{lib}]
+  s.rubygems_version = %q{1.8.6}
+  s.summary = %q{Normalize a company name for consistent matching}
+
+  if s.respond_to? :specification_version then
+    s.specification_version = 3
+
+    if Gem::Version.new(Gem::VERSION) >= Gem::Version.new('1.2.0') then
+      s.add_development_dependency(%q<shoulda>, [">= 0"])
+      s.add_development_dependency(%q<bundler>, ["~> 1.0.18"])
+      s.add_development_dependency(%q<jeweler>, ["~> 1.6.4"])
+      s.add_development_dependency(%q<rcov>, [">= 0"])
+      s.add_development_dependency(%q<pry>, [">= 0"])
+      s.add_development_dependency(%q<rake-compiler>, ["~> 0.7.6"])
+    else
+      s.add_dependency(%q<shoulda>, [">= 0"])
+      s.add_dependency(%q<bundler>, ["~> 1.0.18"])
+      s.add_dependency(%q<jeweler>, ["~> 1.6.4"])
+      s.add_dependency(%q<rcov>, [">= 0"])
+      s.add_dependency(%q<pry>, [">= 0"])
+      s.add_dependency(%q<rake-compiler>, ["~> 0.7.6"])
+    end
+  else
+    s.add_dependency(%q<shoulda>, [">= 0"])
+    s.add_dependency(%q<bundler>, ["~> 1.0.18"])
+    s.add_dependency(%q<jeweler>, ["~> 1.6.4"])
+    s.add_dependency(%q<rcov>, [">= 0"])
+    s.add_dependency(%q<pry>, [">= 0"])
+    s.add_dependency(%q<rake-compiler>, ["~> 0.7.6"])
+  end
+end
+

data/ext/consistent_company/consistent_company.c

@@ -0,0 +1,383 @@
+#include "ruby.h"
+#include <ctype.h>
+#include <string.h>
+#include <stdlib.h>
+
+
+char * TransformCompany(char * inString);
+static int IsCompanyWord(char * inWord);
+char *trimwhitespace(char *str);
+char *str_replace(char *orig, const char *rep, const char *with);
+
+static VALUE rb_ConsistentCompany_Init(VALUE self)
+{
+	return self;
+}
+
+
+static VALUE rb_CompanyNamer(VALUE self)
+{
+	char * pSelf = RSTRING_PTR(self);
+	
+	// for company only
+	int i;
+	char ch;
+	int asc;
+	int numLefts = 0, numRights = 0;
+	int left1 = -1, right1 = -1, left2 = -1, right2 = -1;
+	char * workString = malloc(strlen(pSelf)+2);	// 2 extra chars for TransformCompany
+	char * returnString = malloc(strlen(pSelf)+2);
+	char * inString;
+	strcpy(workString, pSelf);
+	inString = workString;
+	
+	for( i = 0; inString[i]; i++)
+		inString[i] = toupper( inString[i] );
+	
+	inString = trimwhitespace(inString);
+	unsigned long len = strlen(inString);
+	for (i = 0; i < len; i++)
+	{
+		if (inString[i] == '(')
+		{
+			numLefts++;
+			if (numLefts == 1)
+				left1 = i;
+			else if (numLefts == 2)
+				left2 = i;
+		}
+		else if (inString[i] == ')')
+		{
+			numRights++;
+			if (numRights == 1)
+				right1 = i;
+			else if (numRights == 2)
+				right2 = i;
+		}
+	}
+
+	if (numLefts == 0 || inString[0] == '(')
+	{ } // Do Nothing
+	else if (numLefts == 1)
+	{
+		if (right1 > left1)
+		{
+			// ..(xx)..
+			inString[left1++] = ' ';
+			strcpy(&inString[left1], &inString[right1+1]);		
+		}
+		else
+			// ..(xx
+			inString[left1] = '\0';
+	}
+	else if (numLefts == 2)
+	{
+		if ((left1 < right1) && (right1 < left2) && (left2 < right2))
+		{
+			// ..(xx)..(xx)..
+			inString[left1] = ' ';
+			strncpy(inString + left1 + 1, inString + right1 + 1, left2-right1-1);
+			inString[left1+1+left2-right1-1]  = ' ';
+			strcpy(inString+left1+1+left2-right1, inString + right2+1);
+		}
+		else if ((left1 < left2) && (left2 < right1) && (right1 < right2))
+		{
+			// ..(xx(xx)xx)..
+			inString[left1] = ' ';
+			strcpy(inString+left1+1, inString+right2+1);
+		}
+		else if ((left1 < right1) && (right1 < left2) && (right2 == -1))
+		{
+			// ..(xx)..(xx
+			inString[left1] = ' ';
+			strncpy(inString+left1+1, inString+right1+1, left2-right1-1);
+			inString[left1+1+left2-right1] = '\0';
+		}
+		else if ((left1 < left2) && (left2 < right1) && (right2 == -1))
+		{
+			// ..(xx(xx)xx
+			inString[left1] = '\0';
+		}
+		else if ((right1 == -1) && (right2 == -1))
+		{
+			// ..(xx(xx
+			inString[left1] = '\0';
+		}
+	}
+	char singleCharStr[2];
+	singleCharStr[1] = '\0';
+	returnString[0] = '\0';
+	for (i = 0; i < strlen(inString); i++)
+	{
+		ch = inString[i];
+		asc = (int)ch;
+
+		if ((asc >= 65 && asc <= 90) ||
+			(asc >= 48 && asc <= 57) ||
+			(asc >= 128))  // A-Z, 0-9, and high order chars
+		{
+			singleCharStr[0] = ch;
+			strcat(returnString, singleCharStr);
+		}
+		else if (asc == 39) // '
+		{ }  // Remove it
+		else if (asc == 38 && strlen(returnString) > 0) // &
+		{
+			if (returnString[strlen(returnString)-1] != ' ')
+				strcat(returnString, " AND ");
+			else
+				strcat(returnString, "AND ");
+		}
+		else if (asc == 43)  // +
+		{
+			if (strcmp(returnString, "A") == 0 || strcmp(returnString, "A ") == 0)
+				strcpy(returnString, "A PLUS ");
+			else if (strlen(returnString) > 0)
+			{
+				if (returnString[strlen(returnString)-1] != ' ')
+					strcat(returnString, " AND ");
+				else
+					strcat(returnString, "AND ");
+			}
+		}
+		else if (strlen(returnString) > 0 &&
+			returnString[strlen(returnString)-1] != ' ')
+		{
+			strcat(returnString, " ");
+		}
+	}
+	char * p;
+	str_replace(returnString, " AND ", " & ");
+	returnString = trimwhitespace(returnString);
+	strcpy(returnString, TransformCompany(returnString));
+	VALUE return_value = rb_str_new2(trimwhitespace(returnString));
+	free(returnString);
+	free(workString);
+	return return_value;
+} 
+
+/*
+TransformCompany
+given a string transform typical company name parts to common abbreviations
+thereby normailizing the name and making exact matching of different names easier
+example:
+FIRST FEDERAL SAVINGS becomes 1ST FEDERAL SAVINGS 
+*/
+char * TransformCompany(char * resultString)
+{
+	// resultString should have been allocated with 2 extra char for our padding here
+	char * buf = malloc(strlen(resultString));
+	strcpy(buf, " ");
+	strcat(buf,resultString);
+	strcat(buf, " ");
+	strcpy(resultString, buf);
+	free(buf);
+	
+	char * spaceLoc;
+	char * s = resultString;
+
+	str_replace(s, " THE ", " ");
+	str_replace(s, " ONE ", " 1 ");
+	str_replace(s, " TWO ", " 2 ");
+	str_replace(s, " TO ", " 2 ");
+	str_replace(s, " THREE ", " 3 ");
+	str_replace(s, " FOUR ", " 4 ");
+	str_replace(s, " FOR ", " 4 ");
+	str_replace(s, " FIVE ", " 5 ");
+	str_replace(s, " SIX ", " 6 ");
+	str_replace(s, " SEVEN ", " 7 ");
+	str_replace(s, " EIGHT ", " 8 ");
+	str_replace(s, " NINE ", " 9 ");
+	str_replace(s, " TEN ", " 10 ");
+	str_replace(s, " ELEVEN ", " 11 ");
+
+	str_replace(s, " FIRST ", " 1ST ");
+	str_replace(s, " SECOND ", " 2ND ");
+	str_replace(s, " THIRD ", " 3RD ");
+	str_replace(s, " FOURTH ", " 4TH ");
+	str_replace(s, " FIFTH ", " 5TH ");
+	str_replace(s, " SIXTH ", " 6TH ");
+	str_replace(s, " SEVENTH ", " 7TH ");
+	str_replace(s, " EIGHTH ", " 8TH ");
+	str_replace(s, " NINTH ", " 9TH ");
+	str_replace(s, " TENTH ", " 10TH ");
+	str_replace(s, " CENTRE ", " CTR ");
+	str_replace(s, " CENTER ", " CTR ");
+	str_replace(s, " AUTOMOTIVE ", " AUTO ");
+	str_replace(s, " AUTOMOBILE ", " AUTO ");
+	str_replace(s, " AUTOS ", " AUTO ");
+	str_replace(s, " AVENUE ", " AVE ");
+	str_replace(s, " DRIVE ", " DR ");
+	str_replace(s, " PHOTOGRAPHY ", " PHOTO ");
+	str_replace(s, " BROTHERS ", " BROS ");
+	str_replace(s, " TECHNOLOGY ", " TEC ");
+	str_replace(s, " TECH ", " TEC ");
+	str_replace(s, " TELEVISION ", " TV ");
+	str_replace(s, " INFORMATION ", " INFO ");
+	str_replace(s, " SOCIETY ", " SOC ");
+	str_replace(s, " DEPARTMENT ", " DEPT ");
+	str_replace(s, " REGIONAL ", " REG ");
+	str_replace(s, " REGION ", " REG ");
+	str_replace(s, " AUTHORITY ", " AUTH ");
+	str_replace(s, " NATIONAL ", " NATL ");
+	str_replace(s, " INTERNATIONAL ", " INT ");
+	str_replace(s, " INTERNATION ", " INT ");
+	str_replace(s, " INTL ", " INT ");
+	str_replace(s, " MARKETING ", " MKTG ");
+	str_replace(s, " MANAGEMENT ", " MGT ");
+	str_replace(s, " MGMT ", " MGT ");
+
+	s = trimwhitespace(s);
+	spaceLoc = strstr(s, " ");
+	//spaceLoc = resultString.IndexOf(" ");
+	if (spaceLoc && strlen(s) > 3) // More than one word and more than 3 chars
+	{
+		// Check for "A" as the first word, and 
+		// make sure that second word is not an initital or the word "PLUS"
+		// For example: "A C & R" do not remove "A"; "A TOUCH OF CLASS" remove the "A"
+		if (strncmp(s, "A ",  2) == 0 &&
+			strncmp(s+2, "&", 1) != 0 &&
+			strncmp(s+3, " ", 1) != 0 &&
+			strstr(s, "PLUS") != s + 2)
+		{
+			strcpy(s, s+2);
+		}
+
+		spaceLoc = strrchr(s, ' ');
+		//spaceLoc = resultString.LastIndexOf(" ");
+		if (spaceLoc)  // Look at the last word
+		{
+			char * lastWord = malloc(strlen(spaceLoc));
+			strcpy(lastWord, spaceLoc + 1);
+			if (IsCompanyWord(lastWord))
+			{
+				*spaceLoc = '\0';
+				spaceLoc = strrchr(s, ' ');
+				if (spaceLoc)  // Look at the new last word
+				{
+					strcpy(lastWord, spaceLoc + 1);
+					if (IsCompanyWord(lastWord))
+					{
+						*spaceLoc = '\0';
+					}
+				}
+			}
+			free(lastWord);
+		}
+		if (s[strlen(s)-1] == '&')
+			s[strlen(s)-1] = '\0';
+	}
+
+	str_replace(s, " ", "");
+	return s;
+}
+
+/*
+IsCompanyWord
+returns 1 if the null terminated word passed in inWord 
+is a typical Company word. Add more company words here if desired.
+return 0 if not a Company word
+*/
+int IsCompanyWord(char * inWord)
+{
+	if (strcmp(inWord, "ADV") == 0 ||
+		strcmp(inWord, "ADVERTISER") == 0 ||
+		strcmp(inWord, "ADV") == 0 ||
+		strcmp(inWord, "ADVERTISING") == 0 ||
+		strcmp(inWord, "AGCY") == 0 ||
+		strcmp(inWord, "AGENCY") == 0 ||
+		strcmp(inWord, "AGY") == 0 ||
+		strcmp(inWord, "ASC") == 0 ||
+		strcmp(inWord, "ASS") == 0 ||
+		strcmp(inWord, "ASSN") == 0 ||
+		strcmp(inWord, "ASSOC") == 0 ||
+		strcmp(inWord, "ASSOCIAT") == 0 ||
+		strcmp(inWord, "ASSOCIATES") == 0 ||
+		strcmp(inWord, "ASSOCIATION") == 0 ||
+		strcmp(inWord, "ATTORNEY") == 0 ||
+		strcmp(inWord, "ATTRNY") == 0 ||
+		strcmp(inWord, "ATTY") == 0 ||
+		strcmp(inWord, "ATY") == 0 ||
+		strcmp(inWord, "AUTO") == 0 ||
+		strcmp(inWord, "CO") == 0 ||
+		strcmp(inWord, "COMP") == 0 ||
+		strcmp(inWord, "COMPANIES") == 0 ||
+		strcmp(inWord, "COMPANY") == 0 ||
+		strcmp(inWord, "CORP") == 0 ||
+		strcmp(inWord, "CORPORATION") == 0 ||
+		strcmp(inWord, "CT") == 0 ||
+		strcmp(inWord, "CONTRA") == 0 ||
+		strcmp(inWord, "DEPARTMENT") == 0 ||
+		strcmp(inWord, "DEPT") == 0 ||
+		strcmp(inWord, "DIR") == 0 ||
+		strcmp(inWord, "DIRECT") == 0 ||
+		strcmp(inWord, "DIV") == 0 ||
+		strcmp(inWord, "DIVISION") == 0 ||
+		strcmp(inWord, "GROUP") == 0 ||
+		strcmp(inWord, "HOLDINGS") == 0 ||
+		strcmp(inWord, "INC") == 0 ||
+		strcmp(inWord, "INCORPORATED") == 0 ||
+		strcmp(inWord, "INT") == 0 ||
+		strcmp(inWord, "LIMITED") == 0 ||
+		strcmp(inWord, "LLC") == 0 ||
+		strcmp(inWord, "LLP") == 0 ||
+		strcmp(inWord, "LOCAL") == 0 ||
+		strcmp(inWord, "LTD") == 0 ||
+		strcmp(inWord, "PC") == 0 ||
+		strcmp(inWord, "PLC") == 0 ||
+		strcmp(inWord, "PROD") == 0 ||
+		strcmp(inWord, "PRODS") == 0 ||
+		strcmp(inWord, "PRODUCT") == 0 ||
+		strcmp(inWord, "PRODUCTIONS") == 0 ||
+		strcmp(inWord, "PRODUCTS") == 0 ||
+		strcmp(inWord, "TR") == 0 ||
+		strcmp(inWord, "TRADE") == 0)
+		return 1;
+	else
+		return 0;
+}  // IsCompanyWord
+
+/*
+Trim whitespace from front and back of string
+*/
+char *trimwhitespace(char *str)
+{
+  char *end;
+
+  // Trim leading space
+  while(isspace(*str)) str++;
+
+  if(*str == 0)  // All spaces?
+    return str;
+
+  // Trim trailing space
+  end = str + strlen(str) - 1;
+  while(end > str && isspace(*end)) end--;
+
+  // Write new null terminator
+  *(end+1) = 0;
+
+  return str;
+}
+
+// !!!! This ONLY works where rep is longer than with
+char *str_replace(char *orig, const char *rep, const char *with)
+{
+	char * s = orig;
+	while (s=strstr(s, rep))
+	{
+		strncpy(s, with, strlen(with));
+		strcpy(s+strlen(with), s+strlen(rep));
+		s = s + strlen(with)-1;
+	}
+	return orig;
+}
+
+
+void Init_consistent_company()
+{
+	VALUE rb_mConsistentCompany = rb_define_module("ConsistentCompany");
+	VALUE string   				= rb_define_class("String", rb_cObject);
+	rb_define_method(rb_mConsistentCompany, "company_namer", rb_CompanyNamer, 0);
+	rb_include_module(string, rb_mConsistentCompany);
+}

data/ext/consistent_company/extconf.rb

@@ -0,0 +1,6 @@
+require 'mkmf'
+require 'rbconfig'
+if CONFIG['CC'] == 'gcc'
+  CONFIG['CC'] = 'gcc -Wall '
+end
+create_makefile 'consistent_company/consistent_company' 

data/lib/consistent_company/version.rb

@@ -0,0 +1,10 @@
+module ConsistentCompany
+  module Version
+     MAJOR = 0
+     MINOR = 0
+     PATCH = 3
+     BUILD = nil
+
+     STRING = [MAJOR, MINOR, PATCH, BUILD].compact.join('.')
+   end
+end

data/lib/consistent_company.rb

@@ -0,0 +1,5 @@
+
+module ConsistentCompany
+  autoload :Version, "consistent_company/version"
+end
+require 'consistent_company/consistent_company'

data/test/helper.rb

@@ -0,0 +1,19 @@
+require 'rubygems'
+require 'bundler'
+begin
+  Bundler.setup(:default, :development)
+rescue Bundler::BundlerError => e
+  $stderr.puts e.message
+  $stderr.puts "Run `bundle install` to install missing gems"
+  exit e.status_code
+end
+require 'test/unit'
+#require 'shoulda'
+
+$LOAD_PATH.unshift(File.join(File.dirname(__FILE__), '..', 'lib/consistent_company'))
+$LOAD_PATH.unshift(File.join(File.dirname(__FILE__), '..', 'ext/consistent_company'))
+$LOAD_PATH.unshift(File.dirname(__FILE__))
+
+
+class Test::Unit::TestCase
+end

data/test/test_consistent_company.rb

@@ -0,0 +1,73 @@
+require 'helper'
+require 'consistent_company'
+require 'pry'
+
+class TestConsistentCompany < Test::Unit::TestCase
+
+  def test_company_namer
+    # don't change the calling string
+    str = ' my test '
+    company = str.company_namer
+    assert_equal(' my test ', str) 
+    # remove leading and trailing space
+    assert_equal('TEST', " test ".company_namer)
+    # remove embedded space
+    assert_equal('TEST', " te st ".company_namer)
+    # remove Company
+    assert_equal("MYTEST", "My Test Company".company_namer)
+    assert_equal("MYCOMPANYTEST", ("MY COMPANY TEST").company_namer)
+    assert_equal("MYTEST", ("MY TEST COMPANY COMP").company_namer)
+    # remove leading The
+    assert_equal("AAA", "The AAA Company".company_namer)
+    # remove punctuation
+    assert_equal("TESTERS", %q{The, ?%^* tester's company!}.company_namer)
+    # empty name
+    assert_equal("", "".company_namer)
+    # a very long name
+    assert_equal("A"*1000, ("A"*1000).company_namer)
+    # parenthesis matching
+    assert_equal("BBEE", ("BB(xx)EE").company_namer)
+    assert_equal("BE", ("B(xx)E").company_namer)
+    assert_equal("XX", ("(xx)").company_namer)
+    assert_equal("BB", ("BB(xx").company_namer)
+    assert_equal("XX", ("(xx").company_namer)
+    assert_equal("BBMMEE", ("BB(xx)MM(xx)EE").company_namer)
+    assert_equal("BBEE", ("BB(xx(xx)xx)EE").company_namer)
+    assert_equal("BBMM", ("BB(xx)MM(xx").company_namer)
+    assert_equal("BB", ("BB(xx(xx)xx").company_namer)
+    assert_equal("BB", ("BB(xx(xx").company_namer)
+    
+    # handle and &
+    assert_equal("PRE&POST", ("pre and post").company_namer)
+    assert_equal("PRE&POST", ("pre & post").company_namer)
+    assert_equal("PRE&POST", ("&pre and post&").company_namer)
+    assert_equal("PRE&POST", ("& pre and post &").company_namer)
+    assert_equal("ANDPRE&POSTAND", ("and pre and post and").company_namer)
+    
+    # leading A
+    assert_equal("ABTEST", ("A B TEST").company_namer)
+    assert_equal("BTEST", ("A BTEST").company_namer)
+    assert_equal("APLUSTEST", ("A PLUS TEST").company_namer)
+    assert_equal("APLUSTEST", ("A + TEST").company_namer)
+    assert_equal("APLUSTEST", ("A+ TEST").company_namer)
+    
+    # common name shortening
+    assert_equal("TESTCTRCTRCTR", ("Test Center Center Center").company_namer)
+    
+    assert_equal("My Test Advertising Co".company_namer, "MY TEST ADV COMPANY".company_namer)
+  end
+
+    
+  # def test_benchmark
+  #   looptimes = 1000000
+  # 
+  #   puts "[BaseString]"
+  #   puts Benchmark::CAPTION
+  #   puts Benchmark.measure {
+  #     base = BaseString.new
+  #     looptimes.times { |n|
+  #       base.make " My Test Company Name (A)"
+  #     }
+  #   }
+  # end
+end

metadata

@@ -0,0 +1,133 @@
+--- !ruby/object:Gem::Specification
+name: consistent_company
+version: !ruby/object:Gem::Version
+  version: 0.0.3
+  prerelease: 
+platform: ruby
+authors:
+- Doug Cleven
+autorequire: 
+bindir: bin
+cert_chain: []
+date: 2011-09-20 00:00:00.000000000Z
+dependencies:
+- !ruby/object:Gem::Dependency
+  name: shoulda
+  requirement: &70285303244580 !ruby/object:Gem::Requirement
+    none: false
+    requirements:
+    - - ! '>='
+      - !ruby/object:Gem::Version
+        version: '0'
+  type: :development
+  prerelease: false
+  version_requirements: *70285303244580
+- !ruby/object:Gem::Dependency
+  name: bundler
+  requirement: &70285303243640 !ruby/object:Gem::Requirement
+    none: false
+    requirements:
+    - - ~>
+      - !ruby/object:Gem::Version
+        version: 1.0.18
+  type: :development
+  prerelease: false
+  version_requirements: *70285303243640
+- !ruby/object:Gem::Dependency
+  name: jeweler
+  requirement: &70285303242660 !ruby/object:Gem::Requirement
+    none: false
+    requirements:
+    - - ~>
+      - !ruby/object:Gem::Version
+        version: 1.6.4
+  type: :development
+  prerelease: false
+  version_requirements: *70285303242660
+- !ruby/object:Gem::Dependency
+  name: rcov
+  requirement: &70285303241720 !ruby/object:Gem::Requirement
+    none: false
+    requirements:
+    - - ! '>='
+      - !ruby/object:Gem::Version
+        version: '0'
+  type: :development
+  prerelease: false
+  version_requirements: *70285303241720
+- !ruby/object:Gem::Dependency
+  name: pry
+  requirement: &70285303241040 !ruby/object:Gem::Requirement
+    none: false
+    requirements:
+    - - ! '>='
+      - !ruby/object:Gem::Version
+        version: '0'
+  type: :development
+  prerelease: false
+  version_requirements: *70285303241040
+- !ruby/object:Gem::Dependency
+  name: rake-compiler
+  requirement: &70285303240300 !ruby/object:Gem::Requirement
+    none: false
+    requirements:
+    - - ~>
+      - !ruby/object:Gem::Version
+        version: 0.7.6
+  type: :development
+  prerelease: false
+  version_requirements: *70285303240300
+description: Ruby C Extension to normalize a company name. Useful when company names
+  come from various sources.
+email: dcleven@marketron.com
+executables: []
+extensions:
+- ext/consistent_company/extconf.rb
+extra_rdoc_files:
+- LICENSE.txt
+- README.md
+files:
+- .document
+- Gemfile
+- Gemfile.lock
+- LICENSE.txt
+- README.md
+- Rakefile
+- VERSION
+- consistent_company.gemspec
+- ext/consistent_company/consistent_company.c
+- ext/consistent_company/extconf.rb
+- lib/consistent_company.rb
+- lib/consistent_company/consistent_company.bundle
+- lib/consistent_company/version.rb
+- test/helper.rb
+- test/test_consistent_company.rb
+homepage: http://github.com/dcleven/consistent_company
+licenses:
+- MIT
+post_install_message: 
+rdoc_options: []
+require_paths:
+- lib
+required_ruby_version: !ruby/object:Gem::Requirement
+  none: false
+  requirements:
+  - - ! '>='
+    - !ruby/object:Gem::Version
+      version: '0'
+      segments:
+      - 0
+      hash: -1402416125086284082
+required_rubygems_version: !ruby/object:Gem::Requirement
+  none: false
+  requirements:
+  - - ! '>='
+    - !ruby/object:Gem::Version
+      version: '0'
+requirements: []
+rubyforge_project: 
+rubygems_version: 1.8.6
+signing_key: 
+specification_version: 3
+summary: Normalize a company name for consistent matching
+test_files: []