keytar 1.4.1 → 1.5.1

data/Gemfile

@@ -2,7 +2,7 @@ source 'http://rubygems.org'
  gem 'activesupport'
 
 group :development, :test do
-  gem 'activerecord', '~>3.0.4' ## not needed if you're just using KeyBuilder
+  gem 'activerecord', '~>3.0.4' ## not needed if you're just using Keytar
   gem 'rake', '~>0.8.7'
   gem 'jeweler', '~>1.5.2'
   gem "autotest-standalone"

data/Rakefile

@@ -17,8 +17,7 @@ Jeweler::Tasks.new do |gem|
   gem.license = "MIT"
   gem.summary = %Q{A crazy simple library for building keys  (in _key_ value store, not house keys) for Ruby on Rails}
   gem.description = %Q{
-    Keytar is a Ruby on Rails wrapper for KeyBuilder.
-    Use KeyBuilder to automatically generate keys based on class name instead of cluttering model
+    Use Keytar to automatically generate keys based on class name instead of cluttering model
     definitions with tons of redundant key method declarations.
   }
   gem.email = "richard.schneeman@gmail.com"

data/VERSION

@@ -1 +1 @@
-1.4.1
+1.5.1

data/keytar.gemspec

@@ -5,14 +5,13 @@
 
 Gem::Specification.new do |s|
   s.name = %q{keytar}
-  s.version = "1.4.1"
+  s.version = "1.5.1"
 
   s.required_rubygems_version = Gem::Requirement.new(">= 0") if s.respond_to? :required_rubygems_version=
   s.authors = [%q{Schneems}]
-  s.date = %q{2011-08-08}
+  s.date = %q{2011-08-12}
   s.description = %q{
-    Keytar is a Ruby on Rails wrapper for KeyBuilder.
-    Use KeyBuilder to automatically generate keys based on class name instead of cluttering model
+    Use Keytar to automatically generate keys based on class name instead of cluttering model
     definitions with tons of redundant key method declarations.
   }
   s.email = %q{richard.schneeman@gmail.com}
@@ -31,10 +30,8 @@ Gem::Specification.new do |s|
     "keytar.gemspec",
     "lib/.DS_Store",
     "lib/keytar.rb",
-    "lib/keytar/key_builder.rb",
     "license.txt",
-    "spec/keytar/key_builder_spec.rb",
-    "spec/keytar/keytar_spec.rb",
+    "spec/keytar_spec.rb",
     "spec/spec_helper.rb"
   ]
   s.homepage = %q{http://github.com/Schnems/keytar}
@@ -43,8 +40,7 @@ Gem::Specification.new do |s|
   s.rubygems_version = %q{1.8.6}
   s.summary = %q{A crazy simple library for building keys  (in _key_ value store, not house keys) for Ruby on Rails}
   s.test_files = [
-    "spec/keytar/key_builder_spec.rb",
-    "spec/keytar/keytar_spec.rb",
+    "spec/keytar_spec.rb",
     "spec/spec_helper.rb"
   ]
 

data/lib/keytar.rb

@@ -1,10 +1,96 @@
 require 'active_support/all'
-autoload :KeyBuilder, 'keytar/key_builder'
 
 module Keytar
   extend ActiveSupport::Concern
+  DEFAULTS = {:delimiter  => ":",
+                :order    => [:shard, :prefix, :base, :name, :unique, :args, :suffix, :version, :v],
+                :pluralize_instances => true,
+                :key_case => :downcase,
+                :unique   => :id}
 
-  included do
-    include KeyBuilder
+
+# cannot change :order
+# can change :unique
+#
+  class Key
+    attr_accessor :delimiter, :order, :key_case, :options
+    def initialize(options = {})
+      options[:name]  = options.delete(:name).to_s.gsub(/(^key$|_key$)/, '')
+      self.delimiter  = options.delete(:delimiter)
+      self.order      = options.delete(:order)
+      self.key_case   = options.delete(:key_case)
+      self.options    = options
+    end
+
+    def key_array
+      order.map {|key| options[key]}.flatten.compact.map(&:to_s)
+    end
+
+    def to_s
+      key = key_array.join(delimiter)
+      key = key.send key_case if key_case.present?
+      key
+    end
+
+    def self.build(options = {})
+      self.new(options).to_s
+    end
+  end
+
+
+  def self.define_key_class_method_on(base, options = {})
+    (class << base;self ;end).instance_eval do
+      define_method("#{options[:name]}_key") do |*args|
+        build_key(options.merge(:args => args))
+      end
+    end
+  end
+
+  def self.define_key_instance_method_on(base, options)
+    base.class_eval do
+      define_method("#{options[:name]}_key") do |*args|
+        build_key(options.merge(:args => args))
+      end
+    end
+  end
+
+  # class methods to be extended
+  module ClassMethods
+    # sets up configuration options for individual keys
+    # alows us to define the keys without calling method missing
+    def define_keys(*args)
+      # coherce args into meaningful things
+      names = []; options = {}; args.each {|arg| arg.is_a?(Hash) ? options = arg : names << arg}
+      names.each do |name|
+        name = name.to_s.gsub(/(^key$|_key$)/, '')
+        Keytar.define_key_class_method_on(self, options.merge(:name => name))
+        Keytar.define_key_instance_method_on(self, options.merge(:name => name))
+      end
+    end
+    alias :define_key  :define_keys
+
+
+    # a way to define class level configurations for keytar using a hash
+    def key_config(options = {})
+        options[:base]  = self
+        @key_config     ||= options.reverse_merge(Keytar::DEFAULTS)
+    end
+
+    # Call Keytar.build_key or Foo.build_key with options
+    # :base => self.to_s.downcase, :name => method_name, :args => args
+    def build_key(options = {})
+      input = options.reverse_merge(key_config)
+      input.delete(:unique) # class methods don't have a unique key
+      Key.build(input)
+    end
+  end
+
+  # build_key method for instances by default class is pluralized to create different key
+  def build_key(options = {})
+    options.reverse_merge!(self.class.key_config)
+    unique            = method(options[:unique].to_sym).call if respond_to?(options[:unique].to_sym)
+    options[:base]    = options[:base].to_s.pluralize unless options[:pluralize_instances].blank?
+    options[:unique]  = unique && unique == object_id ?  nil  : unique
+    Key.build(options)
   end
 end

data/spec/keytar_spec.rb

@@ -0,0 +1,151 @@
+require 'spec_helper'
+
+## Gives us ActiveRecord backed model Bar that we can test instances of
+ActiveRecord::Base.establish_connection(
+:adapter => "sqlite3",
+:database => ":memory:",
+:host     => 'localhost')
+
+ActiveRecord::Schema.define do
+  create_table :bars do |t|
+    t.string :name, :null => false
+  end
+  create_table :bar_bazs do |t|
+    t.string :name, :null => false
+  end
+end
+
+class Foo
+  include Keytar
+  define_key :awesome
+end
+
+class Bar < ActiveRecord::Base
+  include Keytar
+  define_key :awesome
+end
+
+class BarNonActiveRecord
+end
+
+
+class BarBaz < ActiveRecord::Base
+end
+
+describe Keytar do
+  describe 'class and instance interference' do
+    it 'should not happen' do
+      bar = Bar.create(:name => "whatever")
+      orig_key =  Bar.awesome_key(bar.id)
+      bar.awesome_key(bar.id)
+      second_key = Bar.awesome_key(bar.id)
+      second_key.should eq(orig_key)
+    end
+  end
+
+  describe 'define_key' do
+
+    it 'allows us to pre-define instance methods' do
+      Foo.define_key(:cached_instance_method, :delimiter => "|", :version => "3")
+      @foo = Foo.new
+      @foo.respond_to?(:cached_instance_method_key).should be_true
+      @foo.cached_instance_method_key.should == "foos|cached_instance_method|3"
+    end
+
+    describe 'taking an array' do
+      it 'allows us to pre-define multiple class key methods' do
+        Foo.define_key(:m1, :m2, :m3, :delimiter => ":", :key_prefix => "foo")
+        Foo.respond_to?(:m1_key).should be_true
+        Foo.respond_to?(:m2_key).should be_true
+        Foo.respond_to?(:m3_key).should be_true
+        @foo = Foo.new
+        @foo.respond_to?(:m1_key).should be_true
+        @foo.respond_to?(:m2_key).should be_true
+        @foo.respond_to?(:m3_key).should be_true
+      end
+    end
+  end
+
+  describe 'class methods on Foo' do
+    it 'should respond to "awesome_key" method by returning :class, :delimiter, :name' do
+      Foo.awesome_key.should == "foo:awesome"
+    end
+
+    it 'should respond to "awesome_key(number)" method by returning :class, :delimiter, :name, :delimiter, :arg' do
+      number = rand(100)
+      Foo.awesome_key(number).should == "foo:awesome:#{number}"
+    end
+  end
+
+
+  describe 'Foo instance methods' do
+    before(:each) do
+      @foo = Foo.new
+    end
+
+    it 'should respond to "awesome_key" method by returning :class, :delimiter, :name' do
+      @foo.awesome_key.should == "foos:awesome"
+    end
+
+    it 'should respond to "awesome_key(number)" method by returning :class, :delimiter, :name, :delimiter, :arg' do
+      number = rand(100)
+      @foo.awesome_key(number).should == "foos:awesome:#{number}"
+    end
+
+    it 'should call method_missing on a non-existant method' do
+        lambda{ @foo.thismethoddoesnotexist }.should raise_error(NoMethodError)
+    end
+  end
+
+
+
+
+  describe 'requiring Keytar' do
+    it 'should allow ActiveRecord based objects to use their unique identifiers' do
+      name = "notblank"
+      b = Bar.create(:name => name)
+      b.name.should == name
+      b.awesome_key.should == "bars:awesome:#{b.id}"
+    end
+  end
+
+  describe 'requiring Keytar with ActiveRecord undefined' do
+    it 'does not automatically add Keytar to the class' do
+      describe BarNonActiveRecord.ancestors do
+        it {should_not include( Keytar)}
+      end
+    end
+
+    describe 'allows non ActiveRecord based classes to use keytar directly' do
+      it 'includes Keytar when it is included' do
+        BarNonActiveRecord.class_eval do
+          include Keytar
+          define_key :awesome
+        end
+        describe BarNonActiveRecord.ancestors do
+          it {should include( Keytar)}
+        end
+      end
+
+      it 'should allow ActiveRecord based objects to use their unique identifiers' do
+        BarNonActiveRecord.awesome_key.should == "barnonactiverecord:awesome"
+      end
+    end
+  end
+
+  describe "keytar should not over-ride default method_missing for AR" do
+    before do
+      b = BarBaz.create(:name => "something")
+      @id = b.id
+      Object.instance_eval{ remove_const :BarBaz } ## AR caches methods on object on create, need to pull it from disk
+      class BarBaz < ActiveRecord::Base
+        include Keytar
+        define_key :foo_key
+      end
+    end
+
+    it 'does not interfere with how ActiveRecord generates methods based on column names' do
+      BarBaz.last.id.should == @id
+    end
+  end
+end

metadata

@@ -1,13 +1,13 @@
 --- !ruby/object:Gem::Specification 
 name: keytar
 version: !ruby/object:Gem::Version 
-  hash: 5
+  hash: 1
   prerelease: 
   segments: 
   - 1
-  - 4
+  - 5
   - 1
-  version: 1.4.1
+  version: 1.5.1
 platform: ruby
 authors: 
 - Schneems
@@ -15,7 +15,7 @@ autorequire:
 bindir: bin
 cert_chain: []
 
-date: 2011-08-08 00:00:00 Z
+date: 2011-08-12 00:00:00 Z
 dependencies: 
 - !ruby/object:Gem::Dependency 
   requirement: &id001 !ruby/object:Gem::Requirement 
@@ -121,7 +121,7 @@ dependencies:
   name: rspec
   prerelease: false
   type: :development
-description: "\n    Keytar is a Ruby on Rails wrapper for KeyBuilder.\n    Use KeyBuilder to automatically generate keys based on class name instead of cluttering model\n    definitions with tons of redundant key method declarations.\n  "
+description: "\n    Use Keytar to automatically generate keys based on class name instead of cluttering model\n    definitions with tons of redundant key method declarations.\n  "
 email: richard.schneeman@gmail.com
 executables: []
 
@@ -141,10 +141,8 @@ files:
 - keytar.gemspec
 - lib/.DS_Store
 - lib/keytar.rb
-- lib/keytar/key_builder.rb
 - license.txt
-- spec/keytar/key_builder_spec.rb
-- spec/keytar/keytar_spec.rb
+- spec/keytar_spec.rb
 - spec/spec_helper.rb
 homepage: http://github.com/Schnems/keytar
 licenses: 
@@ -180,6 +178,5 @@ signing_key:
 specification_version: 3
 summary: A crazy simple library for building keys  (in _key_ value store, not house keys) for Ruby on Rails
 test_files: 
-- spec/keytar/key_builder_spec.rb
-- spec/keytar/keytar_spec.rb
+- spec/keytar_spec.rb
 - spec/spec_helper.rb

data/lib/keytar/key_builder.rb

@@ -1,125 +0,0 @@
-module KeyBuilder
-  DEFAULTS = {:key_delimiter => ":",
-                :key_order => [:shard, :prefix, :base, :name, :unique, :args, :suffix, :version, :v],
-                :key_prefix => nil,
-                :key_suffix => nil,
-                :key_pluralize_instances => true,
-                :key_case => :downcase,
-                :key_plural => nil,
-                :key_unique => "id"}
-
-  def self.included(klass)
-    # setup method missing on class
-    klass.class_eval do
-      extend KeyBuilder::Ext
-    end
-  end
-
-  # class methods to be extended
-  module Ext
-    # creates class level getter and setter methods for the defaults for config
-    DEFAULTS.keys.each do |key|
-      # TODO: re-write without eval
-      eval %{
-        def #{key}(#{key}_input = :key_default)
-          @@#{key} = DEFAULTS[:#{key}] unless defined? @@#{key}
-          @@#{key} = #{key}_input unless #{key}_input  == :key_default
-          return @@#{key}
-        end
-      }
-    end
-
-    # sets up configuration options for individual keys
-    # alows us to define the keys without calling method missing
-    def cache_key( *args)
-      # coherce args into meaningful things
-      names = []; options = {}; args.each {|arg| arg.is_a?(Hash) ? options = arg : names << arg}
-      options.merge!(:name => name, :base => self.to_s.downcase)
-
-      # allow for loose naming of keys configuration symbols can use :key_prefix or just :prefix
-      options.keys.each do |key|
-        options["key_#{key}".to_sym] = options[key] if key.to_s !~ /^key_/
-      end
-      names.each do |name|
-        # define (cache) class method
-        (class << self;self ;end).instance_eval do
-          define_method("#{name}_key") do |*args|
-            build_options = options.merge(:name => name, :base => self.to_s.downcase, :args => args)
-            build_key(build_options)
-          end
-        end
-
-        # define (cache) instance method
-        class_eval do
-          define_method("#{name}_key") do |*args|
-            build_options = options.merge(:name => name, :args => args)
-            build_key(build_options)
-          end
-        end
-      end
-    end
-    alias :cache_keys  :cache_key
-    alias :define_key  :cache_key
-    alias :define_keys :cache_key
-
-    # a way to define configurations for keytar using a hash
-    def key_config(options = {})
-      # allow for loose naming of keys configuration symbols can use :key_prefix or just :prefix
-      options.keys.each do |key|
-        options["key_#{key}".to_sym] = options[key] if key.to_s !~ /^key_/
-      end
-      options.each do |key, value|
-        self.send( key , value) if self.respond_to? key
-      end
-    end
-    alias :keyfig :key_config
-
-    # Call KeyBuilder.build_key or Foo.build_key with options
-    # :base => self.to_s.downcase, :name => method_name, :args => args
-    def build_key(options = {})
-      key_hash = build_key_hash(options)
-      key_array = key_hash_to_ordered_array(key_hash)
-      return key_from_array(key_array, options)
-    end
-
-    # takes input options and turns to a hash, which can be sorted based on key
-    def build_key_hash(options)
-      options[:name] = options[:name].to_s.gsub(/(^key$|_key$)/, '')
-      {:prefix => options[:key_prefix]||self.key_prefix,
-       :suffix => options[:key_suffix]||self.key_suffix}.merge(options)
-    end
-
-    # orders the elements based on defaults or config
-    def key_hash_to_ordered_array(key_hash)
-      key_array ||= []
-      (key_hash[:key_order]||self.key_order).each do |key|
-        if key != :args
-          key_array << key_hash[key]
-        else
-          key_array << key_hash[key].map(&:to_s) unless key_hash[key].blank?
-        end
-      end
-      return key_array
-    end
-
-    # applys a delimter and appropriate case to final key
-    def key_from_array(key_array, options = {})
-      key = key_array.flatten.reject {|item| item.blank? }.join(options[:key_delimiter]||self.key_delimiter)
-      key_case = options[:key_case] || self.key_case
-      key = key.downcase if key_case == :downcase
-      key = key.upcase if key_case == :upcase
-      key
-    end
-  end
-
-  # build_key method for instances by default class is pluralized to create different key
-  def build_key(options = {})
-    options[:base] = options[:base]||self.class.to_s.downcase
-    if (options[:key_pluralize_instances] == true ) || (options[:key_pluralize_instances] != false && self.class.key_pluralize_instances.present?)
-      options[:base] =  options[:key_plural]||self.class.key_plural||options[:base].pluralize
-    end
-    unique = self.send "#{options[:key_unique]||self.class.key_unique}".to_sym
-    options[:unique] = unique unless unique == object_id
-    self.class.build_key(options)
-  end
-end

data/spec/keytar/key_builder_spec.rb

@@ -1,173 +0,0 @@
-require 'spec_helper'
-
-class Foo
-  include Keytar
-
-  def ymd
-    Time.now.strftime("%y%m%d")
-  end
-end
-
-describe KeyBuilder do
-  describe 'build_key class method' do
-    before do
-      @options = {:name => "foo", :args => nil}
-    end
-
-    describe 'manually build key' do
-      it 'works' do
-        foo = Foo.new
-        foo.build_key(:name => "method", :args => "args").should eq("foos:method:args")
-      end
-    end
-
-    describe 'build_key' do
-      it 'calls other class methods' do
-        Foo.should_receive(:build_key_hash)
-        Foo.should_receive(:key_hash_to_ordered_array)
-        Foo.should_receive(:key_from_array)
-        Foo.build_key(@options)
-      end
-    end
-
-    describe 'build_key_hash' do
-      it 'removes key and _key from the :name option' do
-        Foo.build_key_hash(@options.merge(:name => "foo_key"))[:name].should == "foo"
-        Foo.build_key_hash(@options.merge(:name => "key"))[:name].should == ""
-        Foo.build_key_hash(@options.merge(:name => "fookey"))[:name].should == "fookey"
-      end
-
-      describe 'prefix' do
-        it 'takes in prefix converts key_prefix to prefix' do
-          prefix = "prefix"
-          Foo.build_key_hash(@options.merge(:key_prefix => prefix))[:prefix].should == prefix
-        end
-
-        it 'favors direct options over class settings' do
-          prefix = "prefix"
-          Foo.should_not_receive(:key_prefix)
-          Foo.build_key_hash(@options.merge(:key_prefix => prefix))[:prefix].should == prefix
-        end
-
-        it "defaults to class settings when no direct option is given" do
-          prefix = "classPrefix"
-          Foo.should_receive(:key_prefix).and_return(prefix)
-          Foo.build_key_hash(@options)[:prefix].should == prefix
-        end
-      end
-
-      describe "suffix" do
-        it 'takes in suffix and converts key_suffix to suffix' do
-          suffix = "sufix"
-          Foo.build_key_hash(@options.merge(:key_suffix => suffix))[:suffix].should == suffix
-        end
-
-        it 'favors direct options over class settings' do
-          suffix = "suffix"
-          Foo.should_not_receive(:key_suffix)
-          Foo.build_key_hash(@options.merge(:key_suffix => suffix))[:suffix].should == suffix
-        end
-
-        it "defaults to class settings when no direct option is given" do
-          suffix = "classSuffix"
-          Foo.should_receive(:key_suffix).and_return(suffix)
-          Foo.build_key_hash(@options)[:suffix].should == suffix
-        end
-      end
-    end
-
-    describe 'key_hash_to_rdered_array' do
-      before do
-        @options.merge!(:prefix => "prefix", :base => "base", :name => "name", :suffix => "suffix", :version => 1)
-      end
-
-      it "converts a hash to an array based on default order" do
-        Foo.key_hash_to_ordered_array(@options).should == [@options[:shard], @options[:prefix], @options[:base], @options[:name], @options[:unique], @options[:suffix], @options[:version], @options[:v]]
-      end
-
-      it "order output using direct option before class config" do
-        Foo.should_not_receive(:key_order)
-        key_order = [:prefix, :base, :name, :unique, :args, :suffix, :version, :v].reverse
-        Foo.key_hash_to_ordered_array(@options.merge(:key_order => key_order)).should == [@options[:prefix], @options[:base], @options[:name], @options[:unique], @options[:suffix], @options[:version], @options[:v]].reverse
-      end
-
-      it "convert each arg in args to a string" do
-        args = ["hey", 1 , "what", 2, "up", []]
-        Foo.key_hash_to_ordered_array(@options.merge(:args => args)).include?(args.map(&:to_s)).should be_true
-      end
-    end
-
-    describe 'key_from_array' do
-      before do
-        @key_array = ["foo", "Bar", "oH", "YEAH"]
-      end
-
-      it "strip out nil from the array and have no spaces" do
-        Foo.key_from_array([nil, nil]).match(/nil/).should be_false
-        Foo.key_from_array([nil, nil]).match(/\s/).should be_false
-      end
-
-      it "return a string" do
-        Foo.key_from_array(@key_array).class.should == String
-      end
-
-      it "keep the key case consistent (downcase by default)" do
-        Foo.key_from_array(@key_array).should == @key_array.map(&:downcase).join(":")
-      end
-
-      it "allow different cases to be passed in via options" do
-        Foo.should_not_receive(:key_case)
-        Foo.key_from_array(@key_array, :key_case => :upcase).should == @key_array.map(&:upcase).join(":")
-      end
-
-      it "flattens all inputs" do
-        array = @key_array << [[["1"], ["2"]],["3"]]
-        Foo.key_from_array(array, :key_case => :upcase).should == array.flatten.map(&:upcase).join(":")
-      end
-    end
-  end
-
-  describe 'build_key instance method' do
-    before do
-      @options = {:name => "foo", :args => nil}
-      @foo = Foo.new
-    end
-
-    describe 'build_key' do
-      it 'sets_base to class name and pluralizes it' do
-        @foo.class.should_receive(:build_key).with(hash_including(:base => @foo.class.to_s.downcase + "s"))
-        @foo.build_key(@options)
-      end
-
-      it 'allows a manual over-ride of base' do
-        base = "base"
-        @foo.class.should_receive(:build_key).with(hash_including(:base => base + "s"))
-        @foo.build_key(@options.merge(:base => base))
-      end
-
-      it "don't pluralize base if key_pluralize_instances is set to false" do
-        @foo.class.should_not_receive(:key_pluralize_instances)
-        @foo.class.should_receive(:build_key).with(hash_including(:base => @foo.class.to_s.downcase))
-        @foo.build_key(@options.merge(:key_pluralize_instances => false))
-      end
-
-      it "don't pluralize base if key_pluralize_instances is set to false" do
-        @foo.class.should_not_receive(:key_pluralize_instances)
-        @foo.class.should_receive(:build_key).with(hash_including(:base => @foo.class.to_s.downcase))
-        @foo.build_key(@options.merge(:key_pluralize_instances => false))
-      end
-
-      it "allow unique method to be passed in via options" do
-        @foo.class.should_not_receive(:key_unique)
-        @foo.class.should_receive(:build_key).with(hash_including(:unique => @foo.ymd))
-        @foo.build_key(@options.merge(:key_unique => :ymd))
-      end
-
-      it "set unique based on configuration" do
-        @foo.class.should_receive(:key_unique).at_least(:once).and_return("ymd")
-        @foo.class.should_receive(:build_key).with(hash_including(:unique => @foo.ymd))
-        @foo.build_key
-      end
-    end
-  end
-end

data/spec/keytar/keytar_spec.rb

@@ -1,270 +0,0 @@
-require 'spec_helper'
-
-## Gives us ActiveRecord backed model Bar that we can test instances of
-ActiveRecord::Base.establish_connection(
-:adapter => "sqlite3",
-:database => ":memory:",
-:host     => 'localhost')
-
-ActiveRecord::Schema.define do
-  create_table :bars do |t|
-    t.string :name, :null => false
-  end
-  create_table :bar_bazs do |t|
-    t.string :name, :null => false
-  end
-end
-
-class Foo
-  include Keytar
-  define_key :awesome
-end
-
-class Bar < ActiveRecord::Base
-  include Keytar
-  define_key :awesome
-end
-
-class BarNonActiveRecord
-end
-
-
-class BarBaz < ActiveRecord::Base
-end
-
-describe Keytar do
-  describe 'class and instance interference' do
-    it 'should not happen' do
-      bar = Bar.create(:name => "whatever")
-      orig_key =  Bar.awesome_key(bar.id)
-      bar.awesome_key(bar.id)
-      second_key = Bar.awesome_key(bar.id)
-      second_key.should eq(orig_key)
-    end
-  end
-
-  describe 'cache_key' do
-    it 'allows us to pre-define class methods' do
-      Foo.cache_key(:cached_method, :delimiter => "/", :key_prefix => "woo")
-      Foo.respond_to?(:cached_method_key).should be_true
-      puts Foo.cached_method_key(22).should == "woo/foo/cached_method/22"
-    end
-
-    it 'allows us to pre-define instance methods' do
-      Foo.cache_key(:cached_instance_method, :delimiter => "|", :version => "3")
-      @foo = Foo.new
-      @foo.respond_to?(:cached_instance_method_key).should be_true
-      @foo.cached_instance_method_key.should == "foos|cached_instance_method|3"
-    end
-
-    describe 'taking an array' do
-      it 'allows us to pre-define multiple class key methods' do
-        Foo.cache_key(:m1, :m2, :m3, :delimiter => ":", :key_prefix => "foo")
-        Foo.respond_to?(:m1_key).should be_true
-        Foo.respond_to?(:m2_key).should be_true
-        Foo.respond_to?(:m3_key).should be_true
-        @foo = Foo.new
-        @foo.respond_to?(:m1_key).should be_true
-        @foo.respond_to?(:m2_key).should be_true
-        @foo.respond_to?(:m3_key).should be_true
-      end
-    end
-  end
-
-  describe 'class methods' do
-    it 'should respond to "awesome_key" method by returning :class, :delimiter, :name' do
-      Foo.awesome_key.should == "foo:awesome"
-    end
-
-    it 'should respond to "awesome_key(number)" method by returning :class, :delimiter, :name, :delimiter, :arg' do
-      number = rand(100)
-      Foo.awesome_key(number).should == "foo:awesome:#{number}"
-    end
-
-
-
-    it 'should call method_missing on a non-existant method' do
-        lambda{ Foo.thismethoddoesnotexist }.should raise_error(NoMethodError)
-    end
-  end
-
-
-  describe 'instance methods' do
-    before(:each) do
-      @foo = Foo.new
-    end
-
-    it 'should respond to "awesome_key" method by returning :class, :delimiter, :name' do
-      @foo.awesome_key.should == "foos:awesome"
-    end
-
-    it 'should respond to "awesome_key(number)" method by returning :class, :delimiter, :name, :delimiter, :arg' do
-      number = rand(100)
-      @foo.awesome_key(number).should == "foos:awesome:#{number}"
-    end
-
-    it 'should call method_missing on a non-existant method' do
-        lambda{ @foo.thismethoddoesnotexist }.should raise_error(NoMethodError)
-    end
-  end
-
-  # test last
-  describe 'class configurations' do
-    after(:each) do
-      # todo find a better way of resetting all these values
-      Foo.key_delimiter KeyBuilder::DEFAULTS[:key_delimiter]
-      Foo.key_order KeyBuilder::DEFAULTS[:key_order]
-      Foo.key_prefix KeyBuilder::DEFAULTS[:key_prefix]
-      Foo.key_suffix KeyBuilder::DEFAULTS[:key_suffix]
-      Foo.key_pluralize_instances KeyBuilder::DEFAULTS[:key_pluralize_instances]
-      Foo.key_case KeyBuilder::DEFAULTS[:key_case]
-      Foo.key_plural KeyBuilder::DEFAULTS[:key_plural]
-      Foo.key_unique KeyBuilder::DEFAULTS[:key_unique]
-    end
-
-    it 'should change key_delimiter' do
-      key_delimiter = "|"
-      Foo.key_delimiter key_delimiter
-      Foo.key_delimiter.should == key_delimiter
-      Foo.awesome_key.should == "foo#{key_delimiter}awesome"
-    end
-
-
-    it 'should change key_order' do
-      order_array = [:prefix, :name, :unique, :base, :args, :suffix]
-      Foo.key_order order_array
-      Foo.key_order.should == order_array
-      Foo.awesome_key.should == "awesome:foo"
-    end
-
-    it 'should change key_prefix' do
-      key_prefix = "memcache"
-      Foo.key_prefix key_prefix
-      Foo.key_prefix.should == key_prefix
-      Foo.awesome_key.should == "#{key_prefix}:foo:awesome"
-    end
-
-    it 'should change key_suffix' do
-      key_suffix = "slave"
-      Foo.key_suffix key_suffix
-      Foo.key_suffix.should == key_suffix
-      Foo.awesome_key.should == "foo:awesome:#{key_suffix}"
-    end
-
-     it 'should change key_pluralize_instances' do
-       key_pluralize_instances = false
-       Foo.key_pluralize_instances key_pluralize_instances
-       Foo.key_pluralize_instances.should == key_pluralize_instances
-       foo = Foo.new
-       foo.awesome_key.should == "foo:awesome"
-     end
-
-     it 'should change key_case' do
-       key_case = :upcase
-       Foo.key_case key_case
-       Foo.key_case.should == key_case
-       Foo.awesome_key.should == "FOO:AWESOME"
-     end
-
-     it 'should change key_plural' do
-       key_plural = "fooz"
-       Foo.key_plural key_plural
-       Foo.key_plural.should == key_plural
-       foo = Foo.new
-       foo.awesome_key.should == "fooz:awesome"
-     end
-
-     it 'should change key_unique' do
-       Foo.class_eval { def timeish; (Time.now.to_i * 0.01).floor.to_s; end}
-       key_unique = :timeish
-       Foo.key_unique key_unique
-       Foo.key_unique.should == key_unique
-       foo = Foo.new
-       foo.awesome_key.should include(foo.timeish)
-     end
-
-     # todo move tests and assertsions to seperate describe and it blocks
-     it 'should allow all configurations to be set using a hash' do
-       # variables
-       key_delimiter = "/"
-       key_order = [:prefix, :base, :suffix]
-       key_prefix = "before"
-       key_suffix = "after"
-       key_pluralize_instances = false
-       key_case = :upcase
-       key_plural = "zoosk"
-       key_unique = "doesn-t_apply_to_instance_methods"
-       # config
-       Foo.keyfig :delimiter => key_delimiter,
-                  :order => key_order,
-                  :prefix => key_prefix,
-                  :suffix => key_suffix,
-                  :pluralize_instances => key_pluralize_instances,
-                  :case => key_case,
-                  :plural => key_plural,
-                  :unique => key_unique
-      # assertions
-      Foo.key_delimiter.should == key_delimiter
-      Foo.key_order.should == key_order
-      Foo.key_prefix.should == key_prefix
-      Foo.key_suffix.should == key_suffix
-      Foo.key_pluralize_instances.should == key_pluralize_instances
-      Foo.key_case.should == key_case
-      Foo.key_plural.should == key_plural
-      Foo.key_unique.should == key_unique
-     end
-
-  end
-
-
-
-  describe 'requiring Keytar' do
-    it 'should allow ActiveRecord based objects to use their unique identifiers' do
-      name = "notblank"
-      b = Bar.create(:name => name)
-      b.name.should == name
-      b.awesome_key.should == "bars:awesome:#{b.id}"
-    end
-  end
-
-  describe 'requiring Keytar with ActiveRecord undefined' do
-    it 'does not automatically add KeyBuilder to the class' do
-      describe BarNonActiveRecord.ancestors do
-        it {should_not include( KeyBuilder)}
-      end
-    end
-
-    describe 'allows non ActiveRecord based classes to use keytar directly' do
-      it 'includes keybuilder when it is included' do
-        BarNonActiveRecord.class_eval do
-          include Keytar
-          define_key :awesome
-        end
-        describe BarNonActiveRecord.ancestors do
-          it {should include( KeyBuilder)}
-        end
-      end
-
-      it 'should allow ActiveRecord based objects to use their unique identifiers' do
-        BarNonActiveRecord.awesome_key.should == "barnonactiverecord:awesome"
-      end
-    end
-  end
-
-  describe "keytar should not over-ride default method_missing for AR" do
-    before do
-      b = BarBaz.create(:name => "something")
-      @id = b.id
-      Object.instance_eval{ remove_const :BarBaz } ## AR caches methods on object on create, need to pull it from disk
-      class BarBaz < ActiveRecord::Base
-        include Keytar
-        define_key :foo_key
-      end
-    end
-
-    it 'does not interfere with how ActiveRecord generates methods based on column names' do
-      BarBaz.last.id.should == @id
-    end
-  end
-
-end