keyp 0.0.2

checksums.yaml

@@ -0,0 +1,7 @@
+---
+SHA1:
+  metadata.gz: b14d1fd77f310af5875fcb9ad4ccd985a04c5abc
+  data.tar.gz: 78815bce0d5db5bb66103fb60132960256d9ba5c
+SHA512:
+  metadata.gz: 1db7713dbf1a667967d3d5d76c7de9587cf961e6f816cd4059c7145424bcb5e9b3ec1e9129fe4ed23ebdeeb41a80e13475d7a96208fa940a1ff059a9d7accbc2
+  data.tar.gz: 49cadf1084cfad53323fdfbc9af3d1bb238e4ab40c838dc9c937ec422df87a5bda95efcc2221821a6eb3d8e77994afb6306d355e274ae16e22b3999d1c770dd6

data/.gitignore

@@ -0,0 +1,18 @@
+*.gem
+*.rbc
+.bundle
+.config
+.yardoc
+Gemfile.lock
+InstalledFiles
+_yardoc
+coverage
+doc/
+lib/bundler/man
+pkg
+rdoc
+spec/reports
+test/tmp
+test/version_tmp
+tmp
+.idea

data/Gemfile

@@ -0,0 +1,4 @@
+source 'https://rubygems.org'
+
+# Specify your gem's dependencies in keyp.gemspec
+gemspec

data/LICENSE

@@ -0,0 +1,13 @@
+Copyright 2014 John Baldwin
+
+Licensed under the Apache License, Version 2.0 (the "License");
+you may not use this file except in compliance with the License.
+You may obtain a copy of the License at
+
+    http://www.apache.org/licenses/LICENSE-2.0
+
+Unless required by applicable law or agreed to in writing, software
+distributed under the License is distributed on an "AS IS" BASIS,
+WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+See the License for the specific language governing permissions and
+limitations under the License.

data/README.md

@@ -0,0 +1,112 @@
+# Keyp
+
+Keyp is an executable Ruby gem that manages user/machine specific key/value pairs for your Ruby application.
+
+Web applications generally need sensitive information, like salts and keys. Managing these generally involves writing
+ a custom solution for your application. Approaches are typically environment variables, custom data files, or
+ environment setting scripts. Following best practices, we don't want to store these in version control with our
+ application source. So I'm creating Keyp to make it simple to manage keys for your application across the development,
+ testing, and production environments.
+
+## Important
+
+Keyp is still in early development and is experimental. As such it is very much a work in progress. Not all features
+expressed in the documentation may be working. The documentation may be plain wrong. I don't recommend you use Keyp
+for any kind of production code at this point in this gem's lifecycle.
+
+## Quick Tour
+
+Keyp manages key value pairs in collections. As of version 0.0.1, Keyp refers to collections as *bags*. There is a
+default bag called *default*. Unless you specify a bag name, *default* will be used.
+
+Here are some command line examples showing some basic Keyp functionality using the default bag. Here we set a couple
+of keys, list all the key/value pairs in the default bag, and finally get the value for a single key.
+
+    $ keyp set cloud_access_id=BMT216AF63958
+    $ keyp set cloud_secret_key=eabca9a58834aec15af0578ac84abfbdab7c3795
+
+    $ keyp list
+    * bag:default
+    cloud_access_id: BMT216AF63958
+    cloud_secret_key: eabca9a58834aec15af0578ac84abfbdab7c3795
+
+    $ keyp get cloud_access_id
+    BMT216AF63958
+
+In your Ruby application, you can use Keyp as follows:
+
+    # get keys from the default key collection and use
+    bag = Keyp.bag
+    my_account.authenticate(bag['cloud_access_id'],bag['cloud_secret_key'])
+
+    # or update ENV
+    bag = Keyp.bag
+    Keyp::add_to_env(bag)
+
+    my_account.authenticate(ENV['cloud_access_id'],ENV['cloud_secret_key'])
+
+Keyp is not limited to just access keys. Any kind of string based name/value pair can be used.
+
+TODO: Improve description
+
+_CAVEAT:_ This gem is at a very early stage in development. Any and all functionality is subject to change.
+
+## Installation
+
+Add this line to your application's Gemfile:
+
+    gem 'keyp'
+
+And then execute:
+
+    $ bundle
+
+Or install it yourself as:
+
+    $ gem install keyp
+
+## Setup
+
+Run the following to set up default installation
+    $ keyp init
+This will create a $HOME/.keyp directory if one does not already exist, configure this director for use with Keyp.
+
+### Customization
+
+Keyp uses the ~/.keyp directory by default. To override, set the environment variable, KEYP_HOME to your choice
+of directory.
+
+TODO: add Bash config setting to export Keyp ENV vars to the ENV or make ENV vars accessible via Keyp hashes
+
+## Usage
+
+TODO: Write detailed usage instructions here
+
+###
+
+
+### Command line interface
+
+TODO: Write more detailed documentation, For now, see the quick start above and run the following to see CLI options
+    $ keyp --help
+
+## Development plan/Features to implement
+
+* Get basic functionality working soundly backed with effective tests
+* Implement .keyp directory setup
+* Add ENV vars to bag
+* Add bag vars to ENV
+* Incorporate with shell configuration
+* Write very clear documentation
+* Implement import/Export to YAML and/or JSON
+* Add API interfaces for other language, starting with Python
+* Consider: Add configuration options for storage (YAML,JSON, SQLITE)
+
+
+## Contributing
+
+1. Fork it ( http://github.com/<my-github-username>/keyp/fork )
+2. Create your feature branch (`git checkout -b my-new-feature`)
+3. Commit your changes (`git commit -am 'Add some feature'`)
+4. Push to the branch (`git push origin my-new-feature`)
+5. Create new Pull Request

data/Rakefile

@@ -0,0 +1,3 @@
+require "bundler/gem_tasks"
+require 'rspec/core/rake_task'
+RSpec::Core::RakeTask.new('spec')

data/bin/keyp

@@ -0,0 +1,195 @@
+#!/usr/bin/env ruby
+# encoding: UTF-8
+
+#
+# NOTE: This is my first ruby gem and first executable ruby gem. I see a bunch of different
+# implementations. A good number and a few well known use Thor, so seems like a good idea to
+# figure out how to use Thor as well.
+#
+# I'm trying out some of the different impementations for Keyp, learning how they work, pros and cons
+# Then I'll pick a single approach after exploring them
+
+# TO run in the project dir:
+# ruby -Ilib ./bin/keyp
+
+# resolve bin path, ignoring symlinks
+require 'pathname'
+bin_file = Pathname.new(__FILE__).realpath
+
+# http://davetron5000.github.io/gli/
+require 'gli'
+
+require 'pp'
+
+require 'keyp'
+include GLI::App
+
+# keyp set key=value
+# keyp get key
+# keyp
+
+
+# keyp create bag
+
+program_desc 'A command line linterface for the Keyp key/value manager'
+
+flag [:b,:bag], default_value: 'default'
+switch [:d, :debug]
+
+# TODO: fix this because this implies that we either already have a bag or it will create a new one
+pre do |global_options, command, options, args|
+  # initialize our store
+  $debug = global_options[:debug]
+  if $debug
+    puts "pre-hook"
+    puts "command:"
+    pp command
+    puts "options:"
+    puts options
+    puts "args: #{args}"
+    puts "args.class=#{args.class}"
+    puts "---- end prehook ---"
+  end
+
+  unless command.name ==  :setup
+
+    # check if we are configured
+    unless Keyp.configured?
+      puts "Please run setup to use Keyp. Run with --help to view help menu"
+      exit 1
+    end
+
+    $bag = Keyp.bag(global_options[:bag])
+  else
+    $bag = nil
+  end
+  true # hack to prevent
+end
+
+#
+# Key,value commands
+#arg_name 'keys', :multiple
+command :get do |c|
+  c.action do |global_options,options,args|
+  puts "--- get args= #{args}" if $debug
+    if args.length == 0
+      puts "Usage: keyp get KEY"
+      puts "Must specify a key."
+    else
+      val = $bag.data[args[0]]
+      unless val.nil?
+        puts val
+      else
+        puts ''
+      end
+    end
+  end
+end
+
+# TODO: set is not optimal. Right now it only handles a single key/value pair and
+# any global or command parameters after the key=value will be sucked into the value
+# Se we'll need to implement values in quotes if the value contains whitespace
+
+arg_name 'values', :multiple
+command :set do |c|
+  c.action do |global_options,options,args|
+    # When/if implementing multiple key assignments
+    # check args.length % 2
+    # parse the args,
+
+    # concatenate all the args
+    # then parse on =
+    buff = ''
+    args.each do |arg|
+      buff << arg << ' '
+      buff
+    end
+
+    nvp = Keyp.parse_arg_string buff
+
+    if nvp
+      $bag[nvp[:key]] = nvp[:value]
+    else
+      # puts "Usage keyp set KEY1=VALUE1 [KEY2=VALUE2 ...]"
+      puts "Usage: keyp set KEY=VALUE"
+    end
+
+    # $bag.data[]
+  end
+end
+
+command :unset do |c|
+  c.action do |global_options,options, args|
+    if args.length == 0
+      # puts 'Usage: keyp unset KEY1 [KEY2 ...]'
+      puts 'Usage: keyp unset KEY1'
+      puts 'Must specify a key to unset.'
+    else
+      printf "Unsetting #{args[0]}..."
+      # if delete
+      val = $bag.delete(args[0])
+      if val
+        puts "unset #{args[0]}: #{val}"
+        printf "done.\n"
+      else
+        puts "key \"#{args[0]}\" not found"
+      end
+
+    end
+  end
+end
+
+command :list do |c|
+  c.action do
+    puts "* bag:#{$bag.name}"
+
+    unless $bag.empty?
+      $bag.data.each do |key,value|
+        #printf("$s : $s\n", key,value)
+        puts "#{key}: #{value}"
+      end
+    else
+      puts "You have an empty bag."
+    end
+
+  end
+end
+
+
+command :setup do |c|
+  c.action do |global_options, options, args|
+    puts "keyp setup..."
+    Keyp::setup
+    $bag = Keyp::create_store 'default'
+  end
+end
+
+post do |global_options, command, options, args|
+  # if bag.data is dirty, then save
+  if $debug
+    puts "post-hook, state of bag.dirty = #{$bag.dirty}"
+  end
+
+  unless command.name == :setup
+    $bag.save
+  else
+    true
+  end
+
+
+
+end
+# bag management commands
+
+# create a bag
+# command :create
+
+# delete a bag (with confirmation)
+
+# show bags
+# command :show
+
+
+
+
+exit run(ARGV)

data/keyp.gemspec

@@ -0,0 +1,27 @@
+# encoding: utf-8
+lib = File.expand_path('../lib', __FILE__)
+$LOAD_PATH.unshift(lib) unless $LOAD_PATH.include?(lib)
+require 'keyp/version'
+
+Gem::Specification.new do |spec|
+  spec.name          = "keyp"
+  spec.version       = Keyp::VERSION
+  spec.authors       = ["John Baldwin"]
+  spec.email         = ["jlbaldwin@gmail.com"]
+  spec.summary       = %q{Manage environment/machine specific key/value pairs for your Ruby application.}
+  spec.description   = spec.summary=
+  spec.homepage      = "https://github.com/johnbaldwin/keyp-ruby"
+  spec.license       = "Apache v2"
+
+  spec.files         = `git ls-files`.split($/)
+  #spec.executables   = spec.files.grep(%r{^bin/}) { |f| File.basename(f) }
+  spec.test_files    = spec.files.grep(%r{^(test|spec|features)/})
+  spec.require_paths = ["lib"]
+
+  spec.add_development_dependency 'bundler', '~> 1.5'
+  spec.add_development_dependency 'rake',    '~> 10.1'
+  spec.add_development_dependency 'gli',     '~> 2.9'
+  spec.add_development_dependency 'rspec',   '~> 2.14'
+  spec.executables = 'keyp'
+
+end

data/lib/keyp/cli.rb

@@ -0,0 +1,11 @@
+module Keyp
+
+  # Manage the processing of command line options
+  class CLI
+
+
+
+
+
+  end
+end

data/lib/keyp/version.rb

@@ -0,0 +1,3 @@
+module Keyp
+  VERSION = "0.0.2"
+end

data/lib/keyp.rb

@@ -0,0 +1,298 @@
+require "keyp/version"
+require 'json'
+require 'yaml'
+
+#
+# TODO: build out cli.rb to trim the exe script, keyp to its bare minimum
+#
+module Keyp
+  # Your code goes here...
+  ORIGINAL_ENV = ENV.to_hash
+
+  # TODO:
+  # Put this in initializer so testing can create its own directory and not muck
+  # up the operational default
+
+
+  KEYP_HOME = File.join(ENV['HOME'], '.keyp')
+  DEFAULT_STORE = 'default'
+  DEFAULT_EXT = '.yml'
+  # This method sets up the keyp director
+  #def self.setup
+  #  # check if keyp directory exists. If not, set it up
+  #  unless Dir.exist?(File.join(DEFAULT_KEYP_DIRNAME))
+  #
+  #  end
+  #end
+
+  def self.configured?
+    Dir.exist?(KEYP_HOME)
+  end
+
+  def self.setup(options ={})
+
+    # check if keyp directory exists
+
+    unless Dir.exist?(KEYP_HOME)
+      puts "making directory #{KEYP_HOME}"
+      Dir.mkdir(KEYP_HOME, 0700)
+    else
+      Puts "#{KEYP_HOME} already exists"
+    end
+
+    KEYP_HOME
+=begin
+    if config_path == DEFAULT_STORE
+      # create the default file
+
+      f = File.open(DEFAULT_STORE,'w')
+      #f.puts("default:")
+      f.close
+      return {}
+    else
+      raise "Non default stores not yet implemented"
+    end
+=end
+  end
+
+  # NOTE: No copy method
+  # No method to explicitly copy one bag to another
+  # Too prone to unwanted overwriting
+  # Instead, use create and pass in the other bag as a
+  # named parameter
+
+  # create a new bag persist
+  # TODO: check options for a has to write to the bag
+  def self.create(bag, options={})
+    # two root sections in a bag
+    # meta:
+    #   meta will contain information for use by keyp about this particular bag
+    #   such as encoding rules, case sensitivity
+    # data:
+  end
+
+  # Convenience method to create a new Bag
+  def self.bag(name='default', options = {})
+    keyper = Keyper.new(name, options)
+    keyper
+  end
+
+
+  def self.add_to_env(bag)
+    # TODO: Add checking, upcase
+    bag.data.each do |key,value|
+      ENV[key] = value
+    end
+  end
+
+  def self.create_store(name, options = {} )
+    filepath = File.join(KEYP_HOME, name + DEFAULT_EXT)
+
+    time_now = Time.now.utc.iso8601
+    file_data = {}
+    file_data['meta'] = {
+      'name' => name,
+      'description' => '',
+      'created_at' => time_now,
+      'updated_at' => time_now
+    }
+    file_data['data'] = nil
+    unless File.exist? filepath
+      File.open(filepath, 'w') do |f|
+        f.write file_data.to_yaml
+        f.chmod(0600)
+      end
+    else
+      raise "Unable to create a new store at #{filepath}. One already exists."
+    end
+    bag name
+  end
+
+  def self.parse_arg_string(arg_string, options={})
+
+    mode = options[:token_mode] || :default
+
+    case mode
+      when :unstable
+        arg_re = /(?<key>\w*)\=(?<value>.*)/
+        nvp = arg_re.match(arg_string)
+      when :default
+        parsed = arg_string.partition('=')
+        if parsed[1] == '='
+          nvp = { key: parsed[0], value: parsed[2] }
+        else
+          # Consider: adding token_mode to error message
+          raise "unable to create a key/value pair from #{arg_string}"
+        end
+      else
+        raise "parse_arg_string unsupported mode #{mode}"
+    end
+    nvp
+  end
+
+
+  # ----------------------------------------------
+
+  # Some inspiration:
+  # http://stackoverflow.com/questions/2680523/dry-ruby-initialization-with-hash-argument
+  #
+  # TODO: add handling so that keys (hierarchical keys too) are accessed as members instead of
+  # hash access
+  #
+  # TODO: move to own file, rename to "Bag"
+  # TODO: i18n error messages
+  #
+  class Keyper
+
+    attr_reader :keypdir, :dirty
+    attr_accessor :name, :data, :file_hash
+
+    def config_path
+      File.join(@keypdir, @name)
+    end
+
+    # We expect
+    # I'm not happy with how creating instance variables works. There must be a cleaner way
+    def initialize(name, options = {})
+      @name = name
+      options.each do |k,v|
+        puts "processing options #{k} = #{v}"
+        instance_variable_set("@#{k}", v) unless v.nil?
+      end
+        # set attributes not set by params
+
+      @keypdir ||= Keyp::KEYP_HOME
+      @read_only ||= false
+      @ext ||= '.yml'
+      @keypfile = config_path+@ext
+      # load our resource
+
+      # load config file into hashes
+      # not the most efficient thing, but simpler and safe enough for now
+
+      unless File.exist? @keypfile
+        puts "Keuper.initialize, create_store #{@keypfile}"
+        Keyp::create_store(@keypfile)
+      end
+      file_data = load(@keypfile)
+
+      @meta = file_data[:meta]
+      @data = file_data[:data]|| {}
+      @file_hash = file_data[:file_hash]
+      @dirty = false
+    end
+
+    def [](key)
+      @data[key]
+    end
+
+    def []=(key, value)
+      set_prop(key, value)
+    end
+
+    def set_prop(key, value)
+      unless @read_only
+        # TODO: check if data has been modified
+        # maybe there is a way hash tells us its been modified. If not then
+        # just check if key,val is already in hash and matches
+        @data[key] = value
+        @dirty = true
+      else
+        raise "Keyper #{@name} is read only"
+      end
+    end
+
+    def delete(key)
+      unless @read_only
+        if @data.key? key
+          @dirty = true
+        end
+        val = @data.delete(key)
+      else
+        raise "Bag #{@name} is read only"
+      end
+      val
+    end
+
+    def empty?
+      @data.empty?
+    end
+
+    # Give full path, attempt to load
+    # sticking with YAML format for now
+    # May add new file format later in which case we'll
+    # TODO: consider changing to class method
+    def load (config_path)
+      #config_data = {}
+      # Get extension
+      file_ext = File.extname(config_path)
+
+      # check
+      # only YAML supported for initial version. Will consider adapters to
+      # abstract the persistence layer
+
+
+      # TODO: make this hardcoded case a hash of helpers
+      # TODO: Add two sections: Meta and data, then return as hash
+
+      if file_ext.downcase == '.yml'
+
+        # Either we are arbitrarily creating directories when
+        # given a path for a file that doesn't exist
+        # or we have special behavior for the default dir
+        # or we just fault and let the caller deal with it
+        unless File.exist? config_path
+          raise "Keyp config file not found: #{config_path}"
+        end
+
+        file_data = YAML.load_file(config_path)
+
+      else
+          raise "Keyp version x only supports YAML for config files. You tried a #{file_ext}"
+      end
+      { meta: file_data['meta'], data: file_data['data']||{}, file_hash: file_data.hash }
+    end
+
+    # NOT thread safe
+    # TODO: make thread safe
+    def save
+      if @read_only
+        raise "This bag instance is read only"
+      end
+      if @dirty
+        # lock file
+        # read checksum
+        # if checksum matches our saved checksum then update file and release lock
+        # otherwise, raise
+        # TODO: implement merge from updated file and raise only if conflict
+        begin
+          file_data = { 'meta' => @meta, 'data' => @data }
+
+          if File.exist? @keypfile
+            read_file_data = load(@keypfile)
+            unless @file_hash == read_file_data[:file_hash]
+              raise "Will not write to #{@keypfile}\nHashes differ. Expected hash =#{@file_hash}\n" +
+                  "found hash #{read_file_data[:file_hash]}"
+            end
+          end
+          File.open(@keypfile, 'w') do |f|
+            f.write file_data.to_yaml
+          end
+          @dirty = false
+        rescue
+          # TODO: log error
+
+        end
+      end
+    end
+  end
+
+
+  # Hmm, do we really need this or can we suffice with the meta hash in the bag
+  class Meta
+    attr_accessor :name, :description, :created, :updated
+    def initialize(hash, options = {})
+
+    end
+  end
+end

data/spec/keyp_spec.rb

@@ -0,0 +1,39 @@
+require 'spec_helper'
+
+describe Keyp do
+  it 'should return correct version string' do
+    #Keyp.version_string.should == "Keyp version #{Keyp::VERSION}"
+    Keyp::VERSION.should == '0.0.1'
+  end
+
+  it 'should return correct default keyp dir' do
+  # DEFAULT_KEYP_DIRNAME = ENV['KEYP_DIRNAME'] || '.keyp'
+    Keyp::KEYP_HOME.should == File.join(ENV['HOME'], '.keyp')
+  end
+
+  it 'should specify default store' do
+    Keyp::DEFAULT_STORE.should == 'default'
+  end
+  it 'should specify default store file' do
+    Keyp::DEFAULT_STORE_FILE.should == 'default.yml'
+  end
+
+  it 'should be able to override default keyp dir'
+
+  it 'should return default bag' do
+    keyper = Keyp::bag
+    keyper.bag.should == 'default'
+  end
+
+  it 'should return a key with data member'
+  it 'should return a key acting as a hash'
+  it 'should allow assigning a key if not read only'
+  it 'should not allow assigning a key if read only'
+  it 'should set the dirty flag if a new key is created'
+  it 'should set the dirty flag if a key is given a new value'
+  it 'should not set the dirty flag if a key is assigned a value equal to its existing value'
+
+  # Braindump of tests
+  # Should show no keys if empty bag
+  # should create default.yml if .keyp already exists but default.yml does not when run from command line
+end

data/spec/spec_helper.rb

@@ -0,0 +1,7 @@
+require 'rspec'
+require 'keyp'
+
+RSpec.configure do |config|
+  config.color_enabled = true
+  config.formatter     = 'documentation'
+end

metadata

@@ -0,0 +1,115 @@
+--- !ruby/object:Gem::Specification
+name: keyp
+version: !ruby/object:Gem::Version
+  version: 0.0.2
+platform: ruby
+authors:
+- John Baldwin
+autorequire: 
+bindir: bin
+cert_chain: []
+date: 2014-03-24 00:00:00.000000000 Z
+dependencies:
+- !ruby/object:Gem::Dependency
+  name: bundler
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - ~>
+      - !ruby/object:Gem::Version
+        version: '1.5'
+  type: :development
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - ~>
+      - !ruby/object:Gem::Version
+        version: '1.5'
+- !ruby/object:Gem::Dependency
+  name: rake
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - ~>
+      - !ruby/object:Gem::Version
+        version: '10.1'
+  type: :development
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - ~>
+      - !ruby/object:Gem::Version
+        version: '10.1'
+- !ruby/object:Gem::Dependency
+  name: gli
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - ~>
+      - !ruby/object:Gem::Version
+        version: '2.9'
+  type: :development
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - ~>
+      - !ruby/object:Gem::Version
+        version: '2.9'
+- !ruby/object:Gem::Dependency
+  name: rspec
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - ~>
+      - !ruby/object:Gem::Version
+        version: '2.14'
+  type: :development
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - ~>
+      - !ruby/object:Gem::Version
+        version: '2.14'
+description: https://github.com/johnbaldwin/keyp-ruby
+email:
+- jlbaldwin@gmail.com
+executables:
+- keyp
+extensions: []
+extra_rdoc_files: []
+files:
+- .gitignore
+- Gemfile
+- LICENSE
+- README.md
+- Rakefile
+- bin/keyp
+- keyp.gemspec
+- lib/keyp.rb
+- lib/keyp/cli.rb
+- lib/keyp/version.rb
+- spec/keyp_spec.rb
+- spec/spec_helper.rb
+homepage: https://github.com/johnbaldwin/keyp-ruby
+licenses:
+- Apache v2
+metadata: {}
+post_install_message: 
+rdoc_options: []
+require_paths:
+- lib
+required_ruby_version: !ruby/object:Gem::Requirement
+  requirements:
+  - - '>='
+    - !ruby/object:Gem::Version
+      version: '0'
+required_rubygems_version: !ruby/object:Gem::Requirement
+  requirements:
+  - - '>='
+    - !ruby/object:Gem::Version
+      version: '0'
+requirements: []
+rubyforge_project: 
+rubygems_version: 2.2.1
+signing_key: 
+specification_version: 4
+summary: https://github.com/johnbaldwin/keyp-ruby
+test_files:
+- spec/keyp_spec.rb
+- spec/spec_helper.rb