keytar 0.1.0

data/Gemfile

@@ -0,0 +1,11 @@
+source 'http://rubygems.org'
+
+group :development do
+  gem 'activesupport'
+  gem 'rake'
+  gem 'jeweler'
+end
+
+group :test do
+  gem 'rspec', '~> 2.5'
+end

data/Gemfile.lock

@@ -0,0 +1,28 @@
+GEM
+  remote: http://rubygems.org/
+  specs:
+    activesupport (3.0.6)
+    diff-lcs (1.1.2)
+    git (1.2.5)
+    jeweler (1.5.2)
+      bundler (~> 1.0.0)
+      git (>= 1.2.5)
+      rake
+    rake (0.8.7)
+    rspec (2.5.0)
+      rspec-core (~> 2.5.0)
+      rspec-expectations (~> 2.5.0)
+      rspec-mocks (~> 2.5.0)
+    rspec-core (2.5.1)
+    rspec-expectations (2.5.0)
+      diff-lcs (~> 1.1.2)
+    rspec-mocks (2.5.0)
+
+PLATFORMS
+  ruby
+
+DEPENDENCIES
+  activesupport
+  jeweler
+  rake
+  rspec (~> 2.5)

data/README.md

@@ -0,0 +1,173 @@
+Keytar
+======
+
+**1.** A keyboard that is designed to be played standing up, like a guitar.  
+**2.** A crazy simple ruby-on-rails library for making re-usable keys  
+
+
+
+Installation
+------------
+    Coming Soon
+    
+KeyBuilder
+----------
+
+Keytar is a Ruby on Rails wrapper for KeyBuilder. Use KeyBuilder to automatically generate keys based on class name instead of cluttering model definitions with tons of redundant key method declarations. 
+
+quit littering your code with junk like this:
+
+      def self.some_distributed_no_sql_datastore_key
+        "foo:some_distributed_no_sql_datastore"
+      end
+      
+Seriously, quit it
+
+
+Example: 
+--------
+
+Keytar in action
+
+    class User < ActiveRecord::Base
+    end
+
+    User.key #=> "user"
+    User.memcache_key #=> "user:memcache"
+    
+    u = User.new
+    u.redis_key #=> "users:redis"
+    u.redis_key("some_arguement") #=> "users:redis:some_arguement"
+    
+    u = User.create(:id => 2)
+    u.sweet_key #=> "users:sweet:2"
+    
+
+It's that simple
+
+Config
+------
+
+There's a ton of configuration options. Call the below methods in your class to configure it's options. 
+
+    class User < ActiveRecord::Base
+      key_delimiter ":"
+      key_order [:prefix, :base, :name, :unique, :args, :suffix]
+      key_prefix nil
+      key_suffix nil
+      key_pluralize_instances true
+      key_plural nil
+      key_case :downcase
+      key_unique "id"
+    end
+
+Here is a run down of what each does  
+
+    User.key_delimeter "|"
+    user.redis_key #=> "users|redis"
+
+key_delimeter sets the separating argument in keys
+
+    User.key_order [:name, :base]
+    user.redis_key #=> "redis:users"
+
+key_order sets the location of key parts, if a symbol is omitted, it will not show up in the final key
+    
+    User.key_prefix "woot"
+    user.redis_key #=> "woot:users:redis"
+    
+key_prefix sets the a prefix to your key for that class
+
+    User.key_suffix "slave"
+    user.redis_key #=> "users:redis:slave"
+
+key_suffix sets the a suffix to your key for that class
+
+    User.key_pluralize_instances false
+    user.redis_key #=> "user:redis"
+    
+key_pluralize_instances allows you to toggle pluralizing instance keys (note the 's' in 'users' is not there)
+
+    User.key_plural "uzerz"
+    user.redis_key #=> "uzerz:redis"
+
+key_plural allows you to over-ride the default pluralize method with custom spelling
+
+    User.key_case :upcase
+    user.redis_key #=> "USERS:REDIS"
+
+key_case allows you to specify the case of your key
+
+    User.key_unique "username"
+
+`key_unique`: By default all instance keys have an identifying unique element included in the key, specifying `key_unique` allows you to change the field that is used to specify a unique key. (defaults to database backed id, but will not use id if object.id == object.object_id)
+
+    user = User.create(:username => "Schneems", :id => 9)
+    user.id #=> 9
+    user.redis_key #=> "users:redis:9"
+    
+    User.key_unique("username")
+    user.redis_key #=> "users:redis:schneems"
+    
+    
+    
+
+
+
+Since this library is sooooo simple, here is a ASCII keytar for you. Thanks for checking it out.
+
+                                                                         ,,,,     
+                                                                        ,,:::,    
+                                                                      ,,,,7::=    
+                                                                     ,:~?MOZN~    
+                                                                   ,,=~ONZDM      
+                                                                 ,,,~,NMOM+       
+                                                                :,,:~MNOM,        
+                                                              ,,,:,,MO8M          
+                                                             :,,,,:: NO           
+                                                           ,:,~=~+,,:~            
+                                                         ,:::+:I:=::,             
+                                                        =?::::I::::               
+                                                      ,~:,+7:::::~                
+                                                     ~,,,,,,+~:::           ,,,   
+                                                   ,:,,,,,=,,,7~:         ,::::,  
+                                                 ,:,,:,,?~::=:,+=:,,,,,,,::::::   
+                                                ::::,,:,,NMZ,=,,+=::,::::+::::    
+                                               ~:,,,::,88=DNM:,:,:+~:::,MN~,~     
+                                             ,:,,:,,,+=+MM==8MZ,=::::::?=:~~      
+                                            ~,,: ,,=,7MN~OMM=?NM::~:$+:~:=        
+                                          ~:,:,:,~7~:==MM?+ZM8~7::I~:+:::         
+                                        ,:,,,,,~,:NM8:=~$MD?+M~::~~~~~~           
+                                       ~,:,, +,+DO=?MM~,=~NM8:::I+:::~            
+                                     ,~:,:,=:,:~+MM8=ZMD:~::::+:~::~              
+                                    ~:,:,:,,?DZ:?~ONM=+MM:+~:I?~:~                
+                                  ~~,,,~:,ZN=?MN~::~OMO~:NMM:,::~                 
+                                ,~:,:~,,==+ZM8+8MZ:::~=+8D+,===,                  
+                               ~:,~=,,=,$MD++MM~?MMO::ND8,===~                    
+                             ,:,:,,:=:~:==MMD=OMO~Z=~=+?:===:                     
+                            ~,:,,,=,:ZM8~=:=NN?+M+::I7+~==:                       
+                          ~:::,,=,+DN=?MM~,=~ZM8:~7~::~~=                         
+                        ,~::,:=,:~~~8MZ+OM8~,~::==::=~:,                          
+                       ~:,: =,,?D$~~~+MN=+NMO::$~~~~~=                            
+                      ~,,~,:,=+=DMZ~~~+NN==$,::?~~::=                             
+                    ,,:~,::=,~NN+IMM$:+=8D,:::~~+~=                               
+                   ~,::,::,=D8?OMZ??NN:~:::?I:~:~                                 
+                 :,:,:,:,,+~=MN+?MDZ+DM::+7::~~=                                  
+               ,::,,,~,:NN~~?~OM8+8MN:::N:~~:=,                                   
+              :~,,:~,,$$+8MM~~~=MN==::=Z~~:~~                                     
+            ,:,::,,,~,+MN+I8M$~+~Z,:==~~~~~                                       
+           :,,,,,,=I\~+~DM$=?MN::::::~+~+                                         
+         ~,::,,,=~=?M\~=~?MN7=O:::$~=:~,                                          
+        :,~,,,=,~NN$+N\ :~:+MI::N:::~=                                            
+      ,:=:,,+,=DZ?DMN+7M\:==,:~::=~=                                              
+     ::::~::,::+MN+?DN7+N\,:~::=:=                                                
+    ::::::,~::,?:DMN+?MN~~ :::~::                                                 
+     :::::::,I:,~:+8NZ=,:=+I::~                                                   
+       ,,:::::+:,,+:=$::$7::~                                                     
+          :,:::,I:,,,:?7=:~~                                                      
+          I:,:::::::$7I,:~                                                        
+             ,::::~:,7:::                                                         
+
+
+Copyright (c) 2011 Schneems. See LICENSE.txt for
+further details.

data/Rakefile

@@ -0,0 +1,58 @@
+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 'jeweler'
+Jeweler::Tasks.new do |gem|
+  # gem is a Gem::Specification... see http://docs.rubygems.org/read/chapter/20 for more options
+  gem.name = "keytar"
+  gem.homepage = "http://github.com/Schnems/keytar"
+  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
+    definitions with tons of redundant key method declarations.
+  }
+  gem.email = "richard.schneeman@gmail.com"
+  gem.authors = ["Schneems"]
+  gem.add_development_dependency "rspec"
+
+  # Include your dependencies below. Runtime dependencies are required when using your gem,
+  # and development dependencies are only needed for development (ie running rake tasks, tests, etc)
+  #  gem.add_runtime_dependency 'jabber4r', '> 0.1'
+  #  gem.add_development_dependency 'rspec', '> 1.2.3'
+end
+Jeweler::RubygemsDotOrgTasks.new
+
+
+# require 'spec/rake/spectask'
+# Spec::Rake::SpecTask.new(:spec) do |spec|
+#   spec.libs << 'lib' << 'spec'
+#   spec.spec_files = FileList['spec/**/*_spec.rb']
+# end
+#
+# Spec::Rake::SpecTask.new(:rcov) do |spec|
+#   spec.libs << 'lib' << 'spec'
+#   spec.pattern = 'spec/**/*_spec.rb'
+#   spec.rcov = true
+# end
+#
+# task :default => :test
+
+# require 'rake/rdoctask'
+# Rake::RDocTask.new do |rdoc|
+#   version = File.exist?('VERSION') ? File.read('VERSION') : ""
+#
+#   rdoc.rdoc_dir = 'rdoc'
+#   rdoc.title = "keytar #{version}"
+#   rdoc.rdoc_files.include('README*')
+#   rdoc.rdoc_files.include('lib/**/*.rb')
+# end

data/VERSION

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

data/lib/keytar.rb

@@ -0,0 +1,7 @@
+require 'rubygems'
+require 'active_record'
+
+module Keytar
+  autoload :KeyBuilder, 'keytar/key_builder'
+  ActiveRecord::Base.class_eval %{ include KeyBuilder }
+end

data/lib/keytar/key_builder.rb

@@ -0,0 +1,105 @@
+require 'rubygems'
+require 'active_support/inflector' # used for pluralize
+require 'active_support/core_ext/object/blank' # used for blank? and present?
+
+module KeyBuilder
+  alias :original_method_missing :method_missing
+
+  DEFAULTS = {:key_delimiter => ":",
+                :key_order => [:prefix, :base, :name, :unique, :args, :suffix],
+                :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 %{
+      extend KeyBuilder::Ext
+      # if method_missing doesn't already exist, aliasing and calling it will create an infinite loop
+      @@key_builder_jump_to_superclass = true unless klass.respond_to?("method_missing")
+      def self.method_missing(method_name, *args, &blk)
+        if method_name.to_s =~ /.*key$/
+          self.build_key(:base => self.to_s.downcase, :name => method_name, :args => args)
+        else
+          if @@key_builder_jump_to_superclass
+            superclass.method_missing(method_name, *args, &blk)
+          else
+            key_builder_alias_method_missing(method_name, *args, &blk)
+          end
+        end
+      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|
+      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
+
+
+    # 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)
+    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)/, '')
+      options.merge :prefix => self.key_prefix, :suffix => self.key_suffix
+    end
+
+    # orders the elements based on defaults or config
+    def key_hash_to_ordered_array(key_hash)
+      key_array ||= []
+      self.key_order.each do |key|
+        if key != :args
+          key_array << key_hash[key]
+        else
+          key_array << key_hash[key].map(&:to_s)
+        end
+      end
+      return key_array
+    end
+
+    # applys a delimter and appropriate case to final key
+    def key_from_array(key_array)
+      key = key_array.flatten.reject {|item| item.blank? }.join(self.key_delimiter)
+      key = key.downcase if self.key_case == :downcase
+      key = key.upcase if self.key_case == :upcase
+      key
+    end
+  end
+
+  # build_key method for instances by default class is pluralized to create different key
+  def build_key(method_name, *args)
+    base = self.class.to_s.downcase
+    base =  self.class.key_plural||base.pluralize if self.class.key_pluralize_instances.present?
+    unique = eval("self.#{self.class.key_unique}") unless eval("self.#{self.class.key_unique}") == object_id
+    self.class.build_key(:base => base, :name => method_name, :args => args, :unique => unique)
+  end
+
+
+
+  def method_missing(method_name, *args, &blk)
+    if method_name.to_s =~ /.*key$/
+      build_key(method_name, *args)
+    else
+      original_method_missing(method_name, *args, &blk)
+    end
+  end
+end

data/license.txt

@@ -0,0 +1,20 @@
+Copyright (c) 2011 Schneems
+
+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/spec/keytar/key_builder_spec.rb

@@ -0,0 +1,137 @@
+require 'spec_helper'
+
+class Foo
+  include KeyBuilder
+end
+
+
+describe KeyBuilder do
+
+  describe 'class methods' do
+    it 'should respond to "key" method by returning downcase of class name' do
+      Foo.key.should == "foo"
+    end
+
+    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
+      begin
+        Foo.thismethoddoesnotexist
+      rescue => ex
+      end
+        ex.class.should == NoMethodError
+    end
+  end
+
+
+  describe 'instance methods' do
+    before(:each) do
+      @foo = Foo.new
+    end
+
+    it 'should respond to "key" method by returning pluralized downcase of class name' do
+      @foo.key.should == "foos"
+    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
+      begin
+        @foo.thismethoddoesnotexist
+      rescue => ex
+      end
+        ex.class.should == 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; end}
+       key_unique = :timeish
+       Foo.key_unique key_unique
+       Foo.key_unique.should == key_unique
+       foo = Foo.new
+       foo.awesome_key.should == "foos:awesome:#{foo.timeish}"
+     end
+  end
+
+end

data/spec/keytar/keytar_spec.rb

@@ -0,0 +1,13 @@
+require 'spec_helper'
+class Bar < ActiveRecord::Base
+end
+
+describe Keytar do
+  describe 'requiring Keytar' do
+    it 'should load keybuilder into ActiveRecord::Base' do
+      describe Bar.ancestors do
+        it {should include( KeyBuilder)}
+      end
+    end
+  end
+end

data/spec/keytar/spec_helper.rb

@@ -0,0 +1,13 @@
+require 'rubygems'
+
+
+$LOAD_PATH.unshift(File.dirname(__FILE__))
+$LOAD_PATH.unshift(File.join(File.dirname(__FILE__), '../..', 'lib'))
+
+require 'keytar'
+require 'spec'
+require 'spec/autorun'
+
+Spec::Runner.configure do |config|
+
+end

metadata

@@ -0,0 +1,137 @@
+--- !ruby/object:Gem::Specification 
+name: keytar
+version: !ruby/object:Gem::Version 
+  hash: 27
+  prerelease: 
+  segments: 
+  - 0
+  - 1
+  - 0
+  version: 0.1.0
+platform: ruby
+authors: 
+- Schneems
+autorequire: 
+bindir: bin
+cert_chain: []
+
+date: 2011-04-19 00:00:00 -05:00
+default_executable: 
+dependencies: 
+- !ruby/object:Gem::Dependency 
+  type: :development
+  requirement: &id001 !ruby/object:Gem::Requirement 
+    none: false
+    requirements: 
+    - - ">="
+      - !ruby/object:Gem::Version 
+        hash: 3
+        segments: 
+        - 0
+        version: "0"
+  name: activesupport
+  version_requirements: *id001
+  prerelease: false
+- !ruby/object:Gem::Dependency 
+  type: :development
+  requirement: &id002 !ruby/object:Gem::Requirement 
+    none: false
+    requirements: 
+    - - ">="
+      - !ruby/object:Gem::Version 
+        hash: 3
+        segments: 
+        - 0
+        version: "0"
+  name: rake
+  version_requirements: *id002
+  prerelease: false
+- !ruby/object:Gem::Dependency 
+  type: :development
+  requirement: &id003 !ruby/object:Gem::Requirement 
+    none: false
+    requirements: 
+    - - ">="
+      - !ruby/object:Gem::Version 
+        hash: 3
+        segments: 
+        - 0
+        version: "0"
+  name: jeweler
+  version_requirements: *id003
+  prerelease: false
+- !ruby/object:Gem::Dependency 
+  type: :development
+  requirement: &id004 !ruby/object:Gem::Requirement 
+    none: false
+    requirements: 
+    - - ">="
+      - !ruby/object:Gem::Version 
+        hash: 3
+        segments: 
+        - 0
+        version: "0"
+  name: rspec
+  version_requirements: *id004
+  prerelease: false
+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  "
+email: richard.schneeman@gmail.com
+executables: []
+
+extensions: []
+
+extra_rdoc_files: 
+- README.md
+files: 
+- .DS_Store
+- Gemfile
+- Gemfile.lock
+- README.md
+- Rakefile
+- VERSION
+- lib/.DS_Store
+- lib/keytar.rb
+- lib/keytar/key_builder.rb
+- license.txt
+- pkg/keytar-0.1.0.gem
+- spec/keytar/key_builder_spec.rb
+- spec/keytar/keytar_spec.rb
+- spec/keytar/spec_helper.rb
+has_rdoc: true
+homepage: http://github.com/Schnems/keytar
+licenses: 
+- MIT
+post_install_message: 
+rdoc_options: []
+
+require_paths: 
+- lib
+required_ruby_version: !ruby/object:Gem::Requirement 
+  none: false
+  requirements: 
+  - - ">="
+    - !ruby/object:Gem::Version 
+      hash: 3
+      segments: 
+      - 0
+      version: "0"
+required_rubygems_version: !ruby/object:Gem::Requirement 
+  none: false
+  requirements: 
+  - - ">="
+    - !ruby/object:Gem::Version 
+      hash: 3
+      segments: 
+      - 0
+      version: "0"
+requirements: []
+
+rubyforge_project: 
+rubygems_version: 1.6.2
+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_helper.rb