dns_guru 0.1

data/Rakefile

@@ -0,0 +1,43 @@
+require 'rubygems'
+require 'rake'
+require 'rake/testtask'
+require 'rake/gempackagetask'
+
+task :default => [:test]
+
+desc 'Tests'
+Rake::TestTask.new(:test) do |t|
+	t.libs << "test"
+	t.test_files = Dir.glob("test/**/test_*.rb")
+	t.verbose = true
+end
+
+PKG_FILES = FileList[
+  '[a-zA-Z]*',
+  'generators/**/*',
+  'lib/**/*',
+  'rails/**/*',
+  'tasks/**/*',
+  'test/**/*'
+]
+
+spec = Gem::Specification.new do |s|
+  s.name = "dns_guru"
+  s.version = "0.1"
+  s.author = "Dns Guru"
+  s.email = "ken.miller@gmail.com"
+  s.homepage = "http://github.com/kemiller/dns_guru"
+  s.platform = Gem::Platform::RUBY
+  s.summary = "Parse hostnames into useful information with a routes-like syntax"
+  s.files = PKG_FILES.to_a
+  s.require_path = "lib"
+  s.has_rdoc = false
+  s.extra_rdoc_files = ["README"]
+end
+
+desc 'Turn this plugin into a gem.'
+Rake::GemPackageTask.new(spec) do |pkg|
+  pkg.gem_spec = spec
+end
+
+

data/init.rb

@@ -0,0 +1,27 @@
+
+$: << File.join(File.dirname(__FILE__), "lib")
+require 'dns_guru'
+require 'rack'
+require 'action_controller/test_process'
+
+config_file = File.join(File.dirname(__FILE__), "../../../config/hosts.rb")
+DnsGuru.init(config_file)
+
+class Rack::Request
+	include DnsGuru::RequestMixin
+end
+
+class ActionController::Request 
+	include DnsGuru::RequestMixin
+end
+
+class ActionController::TestRequest 
+	include DnsGuru::RequestMixin
+end
+
+class ActionController::Base
+	include DnsGuru::ControllerMixin
+
+	helper_method :host_name
+	helper_method :host_name_params
+end

data/lib/dns_guru/controller_mixin.rb

@@ -0,0 +1,15 @@
+
+module DnsGuru
+	module ControllerMixin
+		def host_name(options = {})
+			host = request.canonical_host_name(options)
+			if request.port && request.port != 80
+				host = "#{host}:#{request.port}"
+			end
+			host
+		end
+		def host_name_params
+			request.host_name_params
+		end
+	end
+end

data/lib/dns_guru/matcher.rb

@@ -0,0 +1,52 @@
+
+require 'dns_guru/pattern'
+
+module DnsGuru
+	class Matcher
+
+		attr_reader :patterns
+
+		def initialize(patterns = [])
+			@patterns = patterns
+		end
+
+		def match(string)
+			iterate(:match, string)
+		end
+
+		def generate(options = {})
+			@defaults ||= {}
+			iterate(:generate, @defaults.merge(options))
+		end
+
+		def rewrite(string, options = {})
+			generate(match(string).merge(options))
+		end
+
+		def pattern(pattern_string, params = {})
+			@patterns << Pattern.new(pattern_string, params)
+		end
+
+		def defaults(options = {})
+			@defaults = options
+		end
+
+		def current_defaults
+			@defaults
+		end
+
+		protected
+
+		def iterate(method, *args)
+			@patterns.each do |pat|
+				val = pat.send(method, *args)
+				if val
+					return val
+				end	
+			end
+			nil
+		end
+
+	end
+
+end

data/lib/dns_guru/pattern.rb

@@ -0,0 +1,128 @@
+
+module DnsGuru
+	class Pattern
+
+		attr_reader :segments, :regexp, :params
+
+		def initialize(pattern, params={})
+			@params = params
+			parse(pattern)
+		end
+
+		def parse(pattern)
+			raw_segments = pattern.split(/(\.|-)/)
+
+			@segments = raw_segments.map do |seg| 
+				Segment.make_segment(seg, @params)
+			end
+ 
+			@regexp = /\A#{segments.map { |s| s.substitute }.join}\Z/
+		end
+
+		def match(string)
+			md = @regexp.match(string)
+
+			unless md
+				return nil
+			end
+
+			hash = {}
+			md.captures.each_with_index do |m, i|
+				if segments[i].param
+					hash[segments[i].param] = m 
+				end
+			end
+
+			params.merge(hash)
+		end
+
+		def generate(options)
+			options = options.dup
+			hostname = segments.map do |seg|
+				seg.generate(options)
+			end
+
+			if hostname.include?(nil)
+				return nil
+			end
+
+			# Whatever is left should be identical
+			if params == options
+				return hostname.join
+			end
+		end
+
+		def rewrite(domain, new_options)
+			options = match(domain)
+			if options
+				generate(options.merge(new_options))
+			end
+		end
+	end
+
+	class Segment
+
+		class << self
+			def inherited(klass)
+				types << klass
+			end
+
+			def types
+				@types ||= []
+			end
+
+			def make_segment(string, params = {})
+				klass = types.detect do |t|
+					t.recognize(string)
+				end
+				klass.new(string, params)
+			end
+		end
+
+		def initialize(string, params = {})
+			@string = string
+			@default = params.delete(param)
+		end
+
+		def param
+			nil
+		end
+
+	end
+
+	class DynamicSegment < Segment
+		def self.recognize(string_segment)
+			string_segment =~ /\A:(.*)/
+		end
+
+		def substitute
+			"([[:alnum:]_-]+)"
+		end
+
+		def generate(options)
+			unless options[param]
+				return @default
+			end
+			options.delete(param)
+		end
+
+		def param
+			@param ||= @string[1,1000].to_sym
+		end
+	end
+
+	class StaticSegment < Segment
+		def self.recognize(string_segment)
+			true
+		end
+
+		def substitute
+			"(#{Regexp.escape(@string)})"
+		end
+
+		def generate(options)
+			@string
+		end
+	end
+end
+

data/lib/dns_guru/request_mixin.rb

@@ -0,0 +1,14 @@
+
+module DnsGuru
+	module RequestMixin
+
+		def canonical_host_name(options = {})
+			DnsGuru.generate(host_name_params.merge(options))
+		end
+
+		def host_name_params
+			@host_name_params ||= DnsGuru.match(host) || DnsGuru.defaults
+		end
+
+	end
+end

data/lib/dns_guru.rb

@@ -0,0 +1,33 @@
+
+require 'dns_guru/matcher'
+require 'dns_guru/pattern'
+require 'dns_guru/request_mixin'
+require 'dns_guru/controller_mixin'
+
+module DnsGuru
+
+	def self.init(filename)
+		@matcher = Matcher.new([])
+		load filename
+	end
+
+	def self.read
+		yield(@matcher)
+	end
+
+	def self.match(domain)
+		@matcher.match(domain)
+	end
+
+	def self.generate(options = {})
+		@matcher.generate(options)
+	end
+
+	def self.rewrite(domain, options = {})
+		@matcher.rewrite(domain, options)
+	end
+
+	def self.defaults
+		@matcher.current_defaults
+	end
+end

data/rails/init.rb

@@ -0,0 +1,27 @@
+
+$: << File.join(File.dirname(__FILE__), "lib")
+require 'dns_guru'
+require 'rack'
+require 'action_controller/test_process'
+
+config_file = File.join(File.dirname(__FILE__), "../../../config/hosts.rb")
+DnsGuru.init(config_file)
+
+class Rack::Request
+	include DnsGuru::RequestMixin
+end
+
+class ActionController::Request 
+	include DnsGuru::RequestMixin
+end
+
+class ActionController::TestRequest 
+	include DnsGuru::RequestMixin
+end
+
+class ActionController::Base
+	include DnsGuru::ControllerMixin
+
+	helper_method :host_name
+	helper_method :host_name_params
+end

data/test/config.rb

@@ -0,0 +1,8 @@
+
+DnsGuru.read do |matcher|
+	matcher.defaults :app => 'www', :stage => 'production', :brand => 'mmp', :tld => 'com'
+	matcher.pattern "localhost", :app => 'www', :stage => 'development', :brand => 'mamasource', :tld => 'com'
+	matcher.pattern "seodev.:brand.:tld", :stage => 'qa'
+	matcher.pattern ":app.:brand.:tld", :stage => 'production'
+	matcher.pattern ":app.:stage.:brand.:tld"
+end

data/test/dns_guru/test_controller_mixin.rb

@@ -0,0 +1,48 @@
+
+require 'test/unit'
+require 'dns_guru'
+
+module DnsGuru
+	class TestControllerMixin < Test::Unit::TestCase
+
+		def setup
+			DnsGuru.init(File.join(File.dirname(__FILE__), "../config.rb"))
+			@request = MockRequest.new
+			@controller = MockController.new
+			@controller.request = @request
+		end
+
+		def test_host_name
+			@request.host = "www.production.mmp.com"
+			assert_equal "www.mmp.com", @controller.host_name
+		end
+
+		def test_host_name_with_port
+			@request.host = "www.production.mmp.com"
+			@request.port = 3000
+			assert_equal "www.mmp.com:3000", @controller.host_name
+		end
+
+		def test_host_name_params
+			@request.host = "www.production.mamapedia.com"
+			assert_equal({:app => 'www', :stage => 'production', :brand => 'mamapedia', :tld => 'com'},
+				@controller.host_name_params, "Wrong host name components derived from raw host name")
+		end
+
+		def test_host_name_params_no_host
+			assert_equal({:app => 'www', :stage => 'production', :brand => 'mmp', :tld => 'com'},
+				@controller.host_name_params, "No default values given")
+		end
+	end
+
+	class MockRequest
+		include RequestMixin
+		attr_accessor :host
+		attr_accessor :port
+	end
+
+	class MockController
+		include ControllerMixin
+		attr_accessor :request
+	end
+end

data/test/dns_guru/test_matcher.rb

@@ -0,0 +1,98 @@
+
+require 'test/unit'
+require 'dns_guru'
+
+module DnsGuru
+	class TestMatcher < Test::Unit::TestCase
+
+		def test_truth
+			Matcher
+		end
+
+		def test_initialize
+			matcher = Matcher.new
+			assert_not_nil matcher
+		end
+
+		def test_match_no_hit
+			str = "mymatch_here"
+			matcher = Matcher.new([m1 = MockPattern.new, m2 = MockPattern.new])
+			matcher.match(str)
+			assert_equal str, m1.got_match, "First Pattern wasn't checked"
+			assert_equal str, m2.got_match, "Second Pattern wasn't checked"
+		end
+
+		def test_match_hit
+			str = "mymatch_here"
+			matcher = Matcher.new([m1 = MockPattern.new(true), m2 = MockPattern.new])
+			matcher.match(str)
+			assert_equal str, m1.got_match, "First Pattern wasn't checked"
+			assert_equal nil, m2.got_match, "Second Pattern should not have been checked"
+		end
+
+		def test_generate_no_hit
+			hash = { :str => "mygenerate_here" }
+			generateer = Matcher.new([m1 = MockPattern.new, m2 = MockPattern.new])
+			generateer.generate(hash)
+			assert_equal hash, m1.got_generate, "First Pattern wasn't checked"
+			assert_equal hash, m2.got_generate, "Second Pattern wasn't checked"
+		end
+
+		def test_generate_hit
+			hash = { :str => "mygenerate_here" }
+			generateer = Matcher.new([m1 = MockPattern.new(true), m2 = MockPattern.new])
+			generateer.generate(hash)
+			assert_equal hash, m1.got_generate, "First Pattern wasn't checked"
+			assert_equal nil, m2.got_generate, "Second Pattern should not have been checked"
+		end
+
+		def test_pattern
+			matcher = Matcher.new
+			matcher.pattern ":asdf.:rase", :param => 'p1'
+			assert_kind_of Pattern, matcher.patterns.first, "Didn't make a pattern"
+		end
+
+		def test_pattern_precedence
+			matcher = Matcher.new
+			matcher.pattern ":app.:brand.com", :stage => 'production'
+			matcher.pattern ":app.:stage.:brand.com"
+
+			assert_equal "www.mmp.com", matcher.generate(:app => 'www', :brand => 'mmp', :stage => 'production')
+			assert_equal "www.mmp.com", matcher.rewrite("www.production.mmp.com")
+		end
+
+		def test_defaults
+			matcher = Matcher.new
+			matcher.defaults :stage => 'production', :brand => 'mmp', :app => 'www'
+			matcher.pattern ":app.:brand.com", :stage => 'production'
+			matcher.pattern ":app.:stage.:brand.com", :app => 'www', :brand => 'mmp', :stage => 'production'
+
+			assert_equal "www.mmp.com", matcher.generate
+		end
+
+	end
+
+	class MockPattern
+		attr_reader :got_match, :got_generate, :got_rewrite
+
+		def initialize(rval = false)
+			@rval = rval
+		end
+
+		def match(string)
+			@got_match = string
+			@rval
+		end
+
+		def generate(options)
+			@got_generate = options
+			@rval
+		end
+
+		def rewrite(string, options)
+			@got_rewrite = [string, options]
+			@rval
+		end
+	end
+end
+

data/test/dns_guru/test_pattern.rb

@@ -0,0 +1,83 @@
+
+require 'test/unit'
+require 'dns_guru'
+
+module DnsGuru
+	class TestPattern < Test::Unit::TestCase
+
+		def test_initialize
+			p = Pattern.new(":blah.:blah")
+			assert_not_nil p, "Initialization should work"
+		end
+
+		def test_parse
+			p = Pattern.new(":blah.:blah")
+			segments = p.segments
+			assert !segments.empty?, "Parsing should return an array of segments"
+		end
+
+		def test_segment_types
+			p = Pattern.new(":blah.dev.:blah")
+			segments = p.segments
+			assert_kind_of DynamicSegment, segments.first, "First Segment should be Dynamic"
+			assert_kind_of StaticSegment, segments[1], "Second Segment should be Static"
+		end
+
+		def test_match
+			p = Pattern.new(":app.:stage.:brand.:tld")
+			assert_equal({ :app => 'www', :stage => 'dev', :brand => 'mmp', :tld => 'com' },  p.match("www.dev.mmp.com"))
+			assert_equal({ :app => 'www-01', :stage => 'dev', :brand => 'mmp', :tld => 'com' },  p.match("www-01.dev.mmp.com"))
+		end
+
+		def test_match_with_specified_hyphens
+			p = Pattern.new(":app.:stage-:machine.:brand.:tld")
+			assert_equal({ :app => 'www', :machine => '01', :stage => 'dev', :brand => 'mmp', :tld => 'com' },  p.match("www.dev-01.mmp.com"))
+		end
+
+		def test_match_with_static_segments
+			p = Pattern.new(":app.dev.:brand.:tld", :stage => 'development')
+			assert_equal({ :app => 'www', :stage => 'development', :brand => 'mmp', :tld => 'com' },  p.match("www.dev.mmp.com"))
+		end
+
+		def test_match_no_match
+			p = Pattern.new("foo")
+			assert_equal(nil,  p.match("ausfark"))
+		end
+
+		def test_localhost
+			p = Pattern.new("localhost", :stage => 'development', :brand => 'mms', :tld => 'com', :app => 'www')
+			assert_equal({ :app => 'www', :stage => 'development', :brand => 'mms', :tld => 'com' },  p.match("localhost"))
+		end
+
+		def test_generate
+			p = Pattern.new(":app.:stage.:brand.:tld")
+			assert_equal "www.qa.mms.com", p.generate(:app => 'www', :stage => 'qa', :brand => 'mms', :tld => 'com')
+		end
+
+		def test_generate_with_defaults
+			p = Pattern.new(":app.:stage.:brand.:tld", :tld => 'com')
+			assert_equal "www.qa.mms.com", p.generate(:app => 'www', :stage => 'qa', :brand => 'mms')
+		end
+
+		def test_generate_with_statics
+			p = Pattern.new(":app.dev.:brand.:tld", :stage => 'development')
+			assert_equal "www.dev.mms.com", p.generate(:app => 'www', :stage => 'development', :brand => 'mms', :tld => 'com')
+		end
+
+		def test_generate_fails_for_insufficient_params
+			p = Pattern.new(":app.dev.:brand.:tld", :stage => 'development')
+			assert_equal nil, p.generate(:stage => 'development', :brand => 'mms', :tld => 'com')
+		end
+
+		def test_generate_fails_for_surplus_params
+			p = Pattern.new(":app.dev.:brand.:tld", :stage => 'development')
+			assert_equal nil, p.generate(:extra => 'foo', :app => 'www', :stage => 'development', :brand => 'mms', :tld => 'com')
+		end
+
+		def test_rewrite
+			p = Pattern.new(":app.:stage.:brand.:tld")
+			assert_equal "www.qa.mmp.com", p.rewrite("www.qa.google.com", :brand => 'mmp')
+		end
+
+	end
+end

data/test/dns_guru/test_request_mixin.rb

@@ -0,0 +1,30 @@
+
+require 'test/unit'
+require 'dns_guru'
+
+module DnsGuru
+	class TestRequestMixin < Test::Unit::TestCase
+
+		def setup
+			DnsGuru.init(File.join(File.dirname(__FILE__), "../config.rb"))
+			@req = MockRequest.new
+		end
+
+		def test_canonical_host_name
+			@req.host = "www.production.mamapedia.com"
+			assert_equal "www.mamapedia.com", @req.canonical_host_name
+		end
+
+		def test_host_name_params
+			@req.host = "www.production.mamapedia.com"
+			assert_equal({:app => 'www', :stage => 'production', :brand => 'mamapedia', :tld => 'com'},
+				@req.host_name_params, "Wrong host name components derived from raw host name")
+		end
+	end
+
+
+	class MockRequest
+		include RequestMixin
+		attr_accessor :host
+	end
+end

data/test/test_dns_guru.rb

@@ -0,0 +1,28 @@
+
+require 'test/unit'
+require 'dns_guru'
+
+class TestDnsGuru < Test::Unit::TestCase
+	
+	def setup
+		DnsGuru.init(File.join(File.dirname(__FILE__), "config.rb"))
+	end
+
+	def test_match
+		assert_equal({:app => 'www', :stage => 'production', :brand => 'google', :tld => 'com'}, DnsGuru.match("www.google.com"))
+	end
+
+	def test_generate
+		assert_equal("www.google.com",  DnsGuru.generate(:app => 'www', :stage => 'production', :brand => 'google', :tld => 'com')) 
+		assert_equal("www.mmp.com",  DnsGuru.generate)
+	end
+
+	def test_rewrite
+		assert_equal("www.mmp.com",  DnsGuru.rewrite("www.google.com", :brand => 'mmp')) 
+		assert_equal("www.mmp.com",  DnsGuru.rewrite("www.production.mmp.com"))
+		assert_equal("mail.google.com",  DnsGuru.rewrite("www.google.com", :app => 'mail')) 
+		assert_equal("www.google.co.jp",  DnsGuru.rewrite("www.google.com", :tld => 'co.jp')) # this is iffy
+		assert_equal(nil,  DnsGuru.rewrite("www.google.com", :stage => 'asdf', :nuts => 'too')) 
+	end
+
+end

metadata

@@ -0,0 +1,69 @@
+--- !ruby/object:Gem::Specification 
+name: dns_guru
+version: !ruby/object:Gem::Version 
+  version: "0.1"
+platform: ruby
+authors: 
+- Dns Guru
+autorequire: 
+bindir: bin
+cert_chain: []
+
+date: 2010-03-07 00:00:00 -08:00
+default_executable: 
+dependencies: []
+
+description: 
+email: ken.miller@gmail.com
+executables: []
+
+extensions: []
+
+extra_rdoc_files: 
+- README
+files: 
+- init.rb
+- Rakefile
+- README
+- lib/dns_guru/controller_mixin.rb
+- lib/dns_guru/matcher.rb
+- lib/dns_guru/pattern.rb
+- lib/dns_guru/request_mixin.rb
+- lib/dns_guru.rb
+- rails/init.rb
+- test/config.rb
+- test/dns_guru/test_controller_mixin.rb
+- test/dns_guru/test_matcher.rb
+- test/dns_guru/test_pattern.rb
+- test/dns_guru/test_request_mixin.rb
+- test/test_dns_guru.rb
+has_rdoc: true
+homepage: http://github.com/kemiller/dns_guru
+licenses: []
+
+post_install_message: 
+rdoc_options: []
+
+require_paths: 
+- lib
+required_ruby_version: !ruby/object:Gem::Requirement 
+  requirements: 
+  - - ">="
+    - !ruby/object:Gem::Version 
+      version: "0"
+  version: 
+required_rubygems_version: !ruby/object:Gem::Requirement 
+  requirements: 
+  - - ">="
+    - !ruby/object:Gem::Version 
+      version: "0"
+  version: 
+requirements: []
+
+rubyforge_project: 
+rubygems_version: 1.3.5
+signing_key: 
+specification_version: 3
+summary: Parse hostnames into useful information with a routes-like syntax
+test_files: []
+