daphne_util 0.0.1 → 0.2.0

checksums.yaml

@@ -1,15 +1,15 @@
 ---
 !binary "U0hBMQ==":
   metadata.gz: !binary |-
-    MDc4OGFiNGE1OWQ3YjllMTgxMjU1NTFmMzY3YzBkZTdkYTJmYjFmNA==
+    NTlhNjE2YzhiMGNlYjFhOTNhZWY5ZjY3NWYxZGE0NDA1MTZiZmM5Ng==
   data.tar.gz: !binary |-
-    MTU2N2NlNTcwOTQ3YjU4OTJjYmViYTIwNWMzY2JkYzkzZjkzNGJlOA==
-!binary "U0hBNTEy":
+    ZDcwYTI3NTM0Y2VkZjlkN2NjODYwYzE5NzhmODliNWUxMjg1MDNkZQ==
+SHA512:
   metadata.gz: !binary |-
-    NTBkOTc4NGExZTJjOTIyODhlMDFkMjM1ZTBlZDhkNzZlODEzMzcyMDFmY2E1
-    YTNjMDg1Yjk1NjI2NWM2NjUzNjE0OGQ0ZjE5NTdjODEzZTMxMzg0YWRmNzQy
-    NGEwMmNjMTUyZTc4MWE2ZDVhYmEwNDU2OGYxYmI5N2Q1MzU4N2Y=
+    YTZiNmI2NDYwOWExMWI2MDA1NmI4ZTQyMTM1NWU4NTg3YzM3NWM4OTE4YzA4
+    ZGJlYjI0MjZkYmFhNjU1MDExYTFhNDk0NzU5ZTBkZTI0NGE4ZDM2YjY0M2Rm
+    NWM5MmY3YjNhNDgxNmMwMDc4M2I1ZTI4OWJlZWQ3MmRlZmZhNjQ=
   data.tar.gz: !binary |-
-    YWZlYjk3ZGYyY2QyODhiMGVhNjZjM2Y3OTVjNGE2MjZiMzliNWRjMjFjMzll
-    YmIxNzIzNTI0YTA5MWNkZjc1YjA0M2EzNmZmMmViZDU2YmNiOWIyYmVhZmRk
-    YzEzMDc1NWIzY2E5ZWViYjgxMWU5OGVjYjE2YzgyZTlkY2FkODQ=
+    N2UyMDk4ZWQ2YTY4NzMyZWUzYTMyZWE3MjY1Njg4OTUzOWE2ZGYzNzcwMDlk
+    MDM0ZDJmNzNlMjhiNDZmNTAwOWZhYWQ0ZDUzZDlhYmIyMjY4YTljODM4NmRl
+    MjQzNzlkMWJlZWMyZTEzZDc2OTA4YmNiYTEzYTM0M2M4MDZiNGY=

data/CHANGES.md

@@ -0,0 +1,3 @@
+# 0.1.0 / 2014-02-06 / Grady Griffin
+
+* adding api key generator

data/README.md

@@ -1,6 +1,6 @@
 # DaphneUtil
 
-  A pseudorandom credential generator to create/distribute application credentials
+  A pseudorandom credential generator to create/distribute application credentials and command line client for Daphne
 
 ## Installation
 
@@ -14,7 +14,12 @@ And then execute:
 
 Or install it yourself as:
 
-    $ gem install daphne_util
+    $ git clone git@github.com:MTNSatelliteComm/daphne_util.git
+    $ cd daphne_util
+    $ gem build daphne_util.gemspec
+    $ gem install daphne_util-0.2.0.gem
+
+Keep in mind the version may need to match the version created by gem build
 
 ## CLI Usage
 
@@ -22,6 +27,8 @@ daphne_client_id arg1[,arg2[,argN]]
 
 daphne_client_secret arg1[,arg2[,argN]]
 
+daphne_client_api_key arg1[,arg2[,argN]]
+
 ## Ruby App Usage
 
 
@@ -29,7 +36,7 @@ DaphneUtil::IdGenerator.generate(arg1[,arg2[,argN]])
 
 DaphneUtil::SecretGenerator.generate(arg1[,arg2[,argN]])
 
-
+DaphneUtil::ApiKeyGenerator.generate(arg1[,arg2[,argN]])
 
 
 ### CLI Example
@@ -40,6 +47,9 @@ DaphneUtil::SecretGenerator.generate(arg1[,arg2[,argN]])
     $ daphne_client_secret aname aplace athing
     60934d2dd5069fd4f39550f90cde5b39e0337c91211eb9d8a01174563698fd32
 
+    $ daphne_client_api_key aname aplace athing
+    application-key-0079d3f97d0c27b457e428f86fa4f4cd910e2bd3f25b82716dcdc7301a312d35
+
 ### Ruby Code Example
 
 ```
@@ -51,6 +61,9 @@ DaphneUtil.generate_id("aname","aplace","athing")
 DaphneUtil.generate_secret("aname","aplace","athing")
 #60934d2dd5069fd4f39550f90cde5b39e0337c91211eb9d8a01174563698fd32
 
+DaphneUtil.generate_api_key("aname","aplace","athing")
+application-key-0079d3f97d0c27b457e428f86fa4f4cd910e2bd3f25b82716dcdc7301a312d35
+
 
 #extending a class
 
@@ -63,8 +76,46 @@ Foo.generate_id("aname","aplace","athing")
 
 Foo.generate_secret("aname","aplace","athing")
 #60934d2dd5069fd4f39550f90cde5b39e0337c91211eb9d8a01174563698fd32
+
+Foo.generate_api_key("aname","aplace","athing")
+application-key-0079d3f97d0c27b457e428f86fa4f4cd910e2bd3f25b82716dcdc7301a312d35
 ```
 
+### Example using the Daphne client
+
+create an environment
+
+    $ daphne create env my_env_name http://my_env_target.com
+
+create application credentials
+
+    $ daphne creds a_pre_loaded_app value1 value2
+
+create an application token
+
+    $ daphne create token a_pre_loaded_app
+
+if there are no preloaded app app uid and secret can create a token.  if that is accompanied with email and password a resource owner token associated to the application is created.
+
+set the token for this environment
+
+    $ daphne token dba23d73388e1326cb461f4410fe4ce73667e5ccecd6911341b7af1af9173d9a
+
+verify the token
+
+    $ daphne verify token dba23d73388e1326cb461f4410fe4ce73667e5ccecd6911341b7af1af9173d9a
+
+with a token with api access you can create/modify/delete/view Daphne resources
+
+    $ daphne create resource_owner email=an_email@email.com entity_id=an_id password=password
+
+    $ daphne update resource_owner an_email@email.com password=new_password
+
+use daphne help command to see the usage information
+
+    $ daphne help
+
+
 
 
 ## Contributing

data/bin/daphne

@@ -0,0 +1,11 @@
+#!/usr/bin/env ruby
+begin
+  require 'daphne_util'
+rescue LoadError
+  require 'rubygems'
+  require 'daphne_util'
+end
+
+include DaphneUtil::Tools
+
+execute(*ARGV)

data/bin/daphne_client_api_key

@@ -0,0 +1,13 @@
+#!/usr/bin/env ruby
+begin
+  require 'daphne_util'
+rescue LoadError
+  require 'rubygems'
+  require 'daphne_util'
+end
+
+if ARGV.length == 0
+  puts "Please include at least one argument"
+else
+  puts DaphneUtil::ApiKeyGenerator.generate(*ARGV)
+end

data/daphne_util.gemspec

@@ -18,6 +18,8 @@ Gem::Specification.new do |spec|
   spec.test_files    = spec.files.grep(%r{^(test|spec|features)/})
   spec.require_paths = ["lib"]
 
+  spec.add_runtime_dependency "rest-client", "~>1.6.7"
+
   spec.add_development_dependency "bundler", "~> 1.3"
   spec.add_development_dependency "rake"
   spec.add_development_dependency "rspec"

data/lib/daphne_util.rb

@@ -3,7 +3,9 @@ require "digest"
 require "daphne_util/version"
 require "daphne_util/id_generator"
 require "daphne_util/secret_generator"
+require "daphne_util/api_key_generator"
 require "daphne_util/errors"
+require "daphne_util/tools"
 
 
 module DaphneUtil
@@ -15,7 +17,11 @@ module DaphneUtil
   end
 
   def self.apps
-    ['seanet', 'poseidon', 'apollo']
+    ['seanet', 'poseidon', 'apollo', 'ics']
+  end
+
+  def self.prefix(val)
+    apps.include?(val.to_s.strip.downcase) ? val : "application"
   end
 
   def self.salt=(val)
@@ -30,6 +36,10 @@ module DaphneUtil
     DaphneUtil::SecretGenerator.generate(*seed)
   end
 
+  def self.generate_api_key(*seed)
+    DaphneUtil::ApiKeyGenerator.generate(*seed)
+  end
+
   def generate_id(*seed)
     DaphneUtil::IdGenerator.generate(*seed)
   end
@@ -38,4 +48,8 @@ module DaphneUtil
     DaphneUtil::SecretGenerator.generate(*seed)
   end
 
+  def generate_api_key(*seed)
+    DaphneUtil::ApiKeyGenerator.generate(*seed)
+  end
+
 end

data/lib/daphne_util/api_key_generator.rb

@@ -0,0 +1,19 @@
+module DaphneUtil
+  module ApiKeyGenerator
+
+    def self.generate(*seed)
+      seed_string = seed.compact.join("-")
+      hashes = (0..1).to_a.map {|x| Digest::MD5.hexdigest("api_key=#{seed_string}#{DaphneUtil.salt}#{x}")}
+
+      hashes.unshift("-key-")
+      hashes.unshift(DaphneUtil.prefix(seed.first))
+      
+      hashes.join
+    end
+
+    def generate(seed)
+      DaphneUtil::SecretGenerator.generate(seed)
+    end
+
+  end
+end

data/lib/daphne_util/errors.rb

@@ -1 +1,3 @@
-class SaltUndefined < StandardError; end
+class SaltUndefined < StandardError; end
+
+class IncorrectUsage < StandardError; end

data/lib/daphne_util/id_generator.rb

@@ -5,7 +5,7 @@ module DaphneUtil
       seed_string = seed.compact.join("-")
       hashes = (0..4).to_a.map {|x| Digest::MD5.hexdigest("client_id=#{seed_string}#{DaphneUtil.salt}#{x}")}
 
-      prefix = DaphneUtil.apps.include?(seed[0]) ? seed[0] : "application"
+      prefix = DaphneUtil.prefix(seed[0])
 
       [
         prefix,

data/lib/daphne_util/tools.rb

@@ -0,0 +1,399 @@
+module DaphneUtil
+  module Tools
+
+    require "pstore"
+    require "cgi"
+    require "json"
+    require "rest-client"
+
+    class Store
+
+      attr_reader :loaded, :env
+
+      def self.file_location
+        "#{File.expand_path('~')}/.daphne"
+      end
+
+      def self.default_version
+        "1"
+      end
+
+      def initialize
+        @loaded = PStore.new(self.class.file_location, true)
+        save
+      end
+
+      def env=(x_env)
+        x_env = x_env.to_sym
+        loaded.transaction do
+          loaded[:envs].has_key?(x_env) ? (loaded[:env] = x_env) : x_env = nil
+        end
+
+        save
+      end
+
+      def add_env(name, x_url)
+        new_env = {
+            url: x_url,
+            version: self.class.default_version,
+            apps: {}
+        }
+
+        loaded.transaction { loaded[:envs][name.to_sym] = new_env }
+        save
+        self.env = name.to_sym
+        loaded.transaction { loaded[:envs][name.to_sym] }
+      end
+
+      def rm_env(name)
+        loaded.transaction do 
+
+          loaded[:envs].delete(name.to_sym)
+          loaded[:env] = nil if loaded[:envs][env].nil?
+        end
+        save
+        loaded.transaction { loaded[:envs][env] }
+      end
+
+      def url
+        loaded.transaction { loaded[:envs][env][:url] }
+      end
+
+      def url=(x_url)
+        loaded.transaction do
+          old_env = loaded[:envs][env]
+          new_env = old_env.merge(url: x_url)
+
+          loaded[:envs][env] = new_env
+        end
+
+        save
+        loaded.transaction { loaded[:envs][env][:url] } 
+      end
+
+      def token
+        loaded.transaction { loaded[:envs][env][:token] }
+      end
+
+      def token=(x_token)
+        loaded.transaction do
+          old_env = loaded[:envs][env]
+          new_env = old_env.merge(token: x_token)
+
+          loaded[:envs][env] = new_env
+        end
+
+        save
+        loaded.transaction {loaded[:envs][env][:token]}
+      end
+
+      def version
+        loaded.transaction { loaded[:envs][env][:version] }
+      end
+
+      def version=(x_version)
+        loaded.transaction do
+          old_env = loaded[:envs][env]
+          new_env = old_env.merge(version: (x_version.scan(/\d+/).first || self.class.default_version))
+
+          loaded[:envs][env] = new_env
+        end
+
+        save
+        loaded.transaction {loaded[:envs][env][:version]}
+      end
+
+      def add_app(name, *seed)
+        new_app = {name.to_sym => seed}
+        loaded.transaction do
+          old_apps = loaded[:envs][env][:apps]
+          new_apps = old_apps.merge(new_app)
+          loaded[:envs][env][:apps] = new_apps
+        end
+
+        save
+        loaded.transaction {loaded[:envs][env][:apps]} 
+      end
+
+      def rm_app(name)
+        loaded.transaction do
+          old_env = loaded[:envs][env]
+          new_env = old_env[:apps].delete(name.to_sym)
+        end
+
+        save
+
+        loaded.transaction { loaded[:envs][name.to_sym] }
+      end
+
+      def apps
+        loaded.transaction { loaded[:envs][env][:apps]}
+      end
+
+      def app_keys
+        apps.keys
+      end
+
+      private
+
+      def save
+        loaded.transaction do
+          loaded[:env] ||= :local
+          loaded[:envs] ||= {}
+          loaded[:envs][:local] ||= {url: "localhost:3001", version: "1", apps: {} }
+          @env = loaded[:env]
+          loaded.commit
+        end
+      end
+
+    end
+
+    def store
+      @store ||= Store.new
+    end
+
+    def env
+  %{  Environment #{store.env} :
+      - url : #{store.url}
+      - version : #{store.version}
+      - token : #{store.token || 'No token set'}
+      Credentials : #{apps}}
+    end
+
+    def app(k, v = nil)
+      k = k.to_s.to_sym
+      v ||= store.apps[k]
+      seed = [k] + v
+        %{          
+          #{k} : #{v.join(',')}
+              - uid : #{DaphneUtil.generate_id(*seed)}
+              - secret : #{DaphneUtil.generate_secret(*seed)}
+              - api_key : #{DaphneUtil.generate_api_key(*seed)}
+}
+    end
+
+    def apps
+      return 'None' if store.apps.empty?
+      store.apps.collect {|k,v| app(k,v) }.join("\n")
+    end
+
+    def token
+      store.token
+    end
+
+    def usage
+      %{Environments
+    create env <name> <url>
+    delete env <name>
+    get env
+    env
+Application Credentials
+    create creds <name> [arg1, [arg2, [arg3] ...]]
+Token
+    token [string]
+    verify <string>
+    create token <creds name>
+    create token <app uid> <app secret>
+    create token <creds name> <email> <password>
+    create token <app uid> <app secret> <email> <password>
+Url
+    url [string]
+Application
+    create app <attr1>=<value1> <attr2>=<value2> <attr3>=<value3>
+    update app <uid or composite id> <attr1>=<value1> <attr2>=<value2> <attr3>=<value3>
+    delete app <uid or composite id> 
+    get app <uid or composite id>
+Resource Owner
+    create resource_owmer <attr1>=<value1> <attr2>=<value2> <attr3>=<value3>
+    update resource_owmer <uid or composite id or email> <attr1>=<value1> <attr2>=<value2> <attr3>=<value3>
+    delete resource_owmer <uid or composite id or email> 
+    get resource_owmer <uid or composite id or email>
+}
+    end
+
+    def api_domain
+      "#{store.url}/api/v#{store.version}"
+    end
+
+    def oauth_domain
+      "#{store.url}/oauth2/v#{store.version}"
+    end
+
+    def to_payload(args)
+      r = CGI.parse(args.join('&'))
+      Hash[*r.to_a.flatten]
+    end
+
+    def output(str)
+      puts JSON.pretty_generate(JSON.parse(str))
+    end
+
+    def resource_mapping(key)
+      {
+        resource_owner: "resource_owners",
+        application: "applications"
+      }[key.to_s.to_sym]
+    end
+
+    def create_api_resource(resource_type, payload)
+      raise IncorrectUsage unless resource_type && payload
+      RestClient.post("#{api_domain}/#{resource_mapping(resource_type)}", {resource_type => payload}, authorization: "Bearer #{token}")
+    end
+
+    def update_api_resource(resource_type, identifier, payload)
+      raise IncorrectUsage unless payload && identifier
+      RestClient.put("#{api_domain}/#{resource_mapping(resource_type)}/#{identifier}", {resource_type => payload}, authorization: "Bearer #{token}")
+    end
+
+    def delete_api_resource(resource_type, identifier)
+      raise IncorrectUsage unless identifier
+      RestClient.delete("#{api_domain}/#{resource_mapping(resource_type)}/#{identifier}", authorization: "Bearer #{token}")
+    end
+
+    def retrieve_api_resource(resource_type, identifier)
+      raise IncorrectUsage unless identifier
+      RestClient.get("#{api_domain}/#{resource_mapping(resource_type)}/#{identifier}", authorization: "Bearer #{token}")
+    end
+
+    def create_token(*args)
+      raise IncorrectUsage if args.empty?
+      params = {grant_type: "client_credentials"}
+      case args.length
+      when 1
+        if store.app_keys.include?(args.first.to_sym)
+          seed = [args.first] + store.apps[args.first.to_sym]
+          params[:client_id] = DaphneUtil.generate_id(*seed)
+          params[:client_secret] = DaphneUtil.generate_secret(*seed)
+        else
+          raise IncorrectUsage
+        end
+      when 2
+        params[:client_id] = args[0]
+        params[:client_secret] = args[1]
+      when 3
+        raise IncorrectUsage
+      else
+        params[:grant_type] = "password"
+        params[:client_id] = args[0]
+        params[:client_secret] = args[1]
+        params[:email] = args[2]
+        params[:password] = args[3]
+      end
+
+      RestClient.post("#{oauth_domain}/token", params)
+    end
+
+    def verify_token(val)
+      raise IncorrectUsage if val.to_s.empty?
+      RestClient.post("#{oauth_domain}/verify?access_token=#{val}")
+    end
+
+    def create_env(name, url)
+      raise IncorrectUsage unless url && name
+      store.add_env(name, url)
+    end
+
+    def delete_env(name)
+      raise IncorrectUsage unless name
+      store.rm_env(name)
+    end
+
+    def create_app(name, *args)
+      raise IncorrectUsage unless name
+      store.add_app(name, *args)
+    end
+
+    def delete_app(name)
+      raise IncorrectUsage unless name
+      store.add_app(name)
+    end
+
+    def execute(*argv)
+      raise IncorrectUsage if argv.empty?
+
+      action, resource, args = argv[0], argv[1].to_s.to_sym, argv[2..-1].to_a
+
+      case action
+      when "create" then create(resource, *args)
+      when "update" then update(resource, *args)
+      when "delete" then delete(resource, *args)
+      when "get"    then retrieve(resource, *args)
+      when "verify" then verify_token(args[1])
+      when "env" then retrieve(:env)
+      when "help" then puts usage
+      when "token"
+        argv[1] ? update(:token, argv[1]) : retrieve(:token)
+      when "url"
+        argv[1] ? update(:url, argv[1]) : retrieve(:url)
+      else raise IncorrectUsage
+      end
+    rescue IncorrectUsage
+      puts usage
+    rescue RestClient::Exception => e
+      puts "Error :"
+      e.is_a?(RestClient::InternalServerError) ? (raise e) : output(e.response)
+    end
+
+    def create(resource, *args)
+      case resource
+        when :resource_owner, :application, :app
+          rtn = create_api_resource(resource, to_payload(args))
+          output(rtn)
+        when :token
+          rtn = create_token(*args)
+          output(rtn)
+        when :env
+          rtn = create_env(args[0], args[1])
+          puts env
+        when :creds
+          create_app(args[0], *args[1..-1])
+          puts env
+        else raise IncorrectUsage
+      end
+    end
+
+    def update(resource, *args)
+      case resource
+        when :resource_owner, :application, :app
+          rtn = update_api_resource(resource, args[0], to_payload(args[1..-1]))
+          output(rtn)
+        when :token
+          store.token = args.first
+          puts env
+        when :url
+          store.url = args.first
+          puts env
+        else raise IncorrectUsage
+      end
+    end
+
+    def delete(resource, *args)
+      case resource
+        when :resource_owner, :application, :app
+          rtn = delete_api_resource(resource, args.first)
+          output(rtn)
+        when :env
+          store.rm_env(args.first)
+          puts env
+        when :creds
+          store.rm_app(args.first)
+          puts env
+        else raise IncorrectUsage
+      end
+    end
+
+    def retrieve(resource, *args)
+      case resource
+        when :resource_owner, :application
+          rtn = retrieve_api_resource(resource, args.first)
+          output(rtn) 
+        when :token
+          puts(store.token ? store.token : "Token not configured for this environment.")
+        when :env
+          puts env
+        else raise IncorrectUsage
+      end
+    end
+
+  end
+end

data/lib/daphne_util/version.rb

@@ -1,8 +1,8 @@
 module DaphneUtil
   module VERSION
     MAJOR = 0
-    MINOR = 0
-    TINY = 1
+    MINOR = 2
+    TINY = 0
 
     STRING = [MAJOR, MINOR, TINY].join('.')
   end

data/spec/api_key_generator_spec.rb

@@ -0,0 +1,22 @@
+require 'spec_helper'
+
+describe 'ApiKeyGenerator#generate' do
+
+  before(:each) do
+    DaphneUtil.salt = 'hello'
+    @seed = Digest::MD5.hexdigest(rand(9999).to_s)
+  end
+
+  it "should generate a secret string" do
+    DaphneUtil::ApiKeyGenerator.generate(@seed).should be_a(String)
+  end
+
+  it "should be consistent" do
+    DaphneUtil::ApiKeyGenerator.generate(@seed).should eq(DaphneUtil::ApiKeyGenerator.generate(@seed))
+  end
+
+  it "should have the correct structure" do
+    DaphneUtil::ApiKeyGenerator.generate(@seed).should match  /^[A-Za-z]\w*-key-[\da-f]{64}$/
+  end
+
+end

data/spec/tools_spec.rb

@@ -0,0 +1,10 @@
+require 'spec_helper'
+
+describe 'DaphneUtil::Tools' do
+
+  before(:each) do
+    File.delete(Store.file_location)
+  end
+
+
+end

metadata

@@ -1,15 +1,29 @@
 --- !ruby/object:Gem::Specification
 name: daphne_util
 version: !ruby/object:Gem::Version
-  version: 0.0.1
+  version: 0.2.0
 platform: ruby
 authors:
 - Grady Griffin
 autorequire: 
 bindir: bin
 cert_chain: []
-date: 2013-12-17 00:00:00.000000000 Z
+date: 2014-04-14 00:00:00.000000000 Z
 dependencies:
+- !ruby/object:Gem::Dependency
+  name: rest-client
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - ~>
+      - !ruby/object:Gem::Version
+        version: 1.6.7
+  type: :runtime
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - ~>
+      - !ruby/object:Gem::Version
+        version: 1.6.7
 - !ruby/object:Gem::Dependency
   name: bundler
   requirement: !ruby/object:Gem::Requirement
@@ -56,29 +70,37 @@ description: Daphne pseudorandom credential generator
 email:
 - gradygriffin@gmail.com
 executables:
+- daphne
+- daphne_client_api_key
 - daphne_client_id
 - daphne_client_secret
 extensions: []
 extra_rdoc_files: []
 files:
 - .gitignore
+- CHANGES.md
 - Gemfile
 - LICENSE
-- LICENSE.txt
 - README.md
 - Rakefile
+- bin/daphne
+- bin/daphne_client_api_key
 - bin/daphne_client_id
 - bin/daphne_client_secret
 - daphne_util.gemspec
 - lib/daphne_util.rb
+- lib/daphne_util/api_key_generator.rb
 - lib/daphne_util/errors.rb
 - lib/daphne_util/id_generator.rb
 - lib/daphne_util/secret_generator.rb
+- lib/daphne_util/tools.rb
 - lib/daphne_util/version.rb
+- spec/api_key_generator_spec.rb
 - spec/daphne_util_spec.rb
 - spec/id_generator_spec.rb
 - spec/secret_generator_spec.rb
 - spec/spec_helper.rb
+- spec/tools_spec.rb
 homepage: ''
 licenses:
 - MIT
@@ -99,12 +121,14 @@ required_rubygems_version: !ruby/object:Gem::Requirement
       version: '0'
 requirements: []
 rubyforge_project: 
-rubygems_version: 2.0.6
+rubygems_version: 2.2.2
 signing_key: 
 specification_version: 4
 summary: A pseudorandom credential generator to create and generate application credentials
 test_files:
+- spec/api_key_generator_spec.rb
 - spec/daphne_util_spec.rb
 - spec/id_generator_spec.rb
 - spec/secret_generator_spec.rb
 - spec/spec_helper.rb
+- spec/tools_spec.rb

data/LICENSE.txt

@@ -1,22 +0,0 @@
-Copyright (c) 2013 Grady Griffin
-
-MIT License
-
-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.