hattr 1.0.0

checksums.yaml

@@ -0,0 +1,7 @@
+---
+SHA1:
+  metadata.gz: 5dd222e1b2ce862fa5536322fb3f74bfd5d4f595
+  data.tar.gz: b4d8981ec1dde35e7f75063d3d60ee2ee3d3fb0f
+SHA512:
+  metadata.gz: bd01418591458c927dcb4c231bac87f8c6cbc4acd29087e119801020266f71fe82c0a33a07c23d7240767b433a1a89f72bbac8051cebb3da69f327509ba15dba
+  data.tar.gz: 799147fd6d7ff561f6737208655641faee1cddad1293acfdcef9fb525d7a70315c69e6684967e049f389a784b70b9e6573191cf30eda3239d749e054704b6324

data/.coveralls.yml

@@ -0,0 +1 @@
+service_name: travis-ci

data/.editorconfig

@@ -0,0 +1,12 @@
+root = true
+
+[*]
+indent_style = space
+indent_size = 2
+end_of_line = lf
+charset = utf-8
+trim_trailing_whitespace = true
+insert_final_newline = true
+
+[*.{sh,markdown}]edito
+indent_size = 4

data/.gitignore

@@ -0,0 +1,3 @@
+coverage
+.DS_Store
+Gemfile.lock

data/.rspec

@@ -0,0 +1,3 @@
+--color
+--require spec_helper
+--format=documentation

data/.rubocop.yml

@@ -0,0 +1,10 @@
+AllCops:
+  TargetRubyVersion: 2.3
+  DisplayCopNames: true
+  Include:
+    - 'lib/**/*'
+  Exclude:
+    - 'spec/**/*'
+    - 'vendor/**/*'
+
+inherit_from: .rubocop_todo.yml

data/.rubocop_todo.yml

@@ -0,0 +1,17 @@
+# This configuration was generated by
+# `rubocop --auto-gen-config`
+# on 2016-05-20 15:38:35 -0400 using RuboCop version 0.39.0.
+# The point is for the user to remove these configuration records
+# one by one as the offenses are removed from the code base.
+# Note that changes in the inspected code, or installation of new
+# versions of RuboCop, may require this file to be generated again.
+
+# Offense count: 5
+# Configuration parameters: AllowHeredoc, AllowURI, URISchemes.
+# URISchemes: http, https
+Metrics/LineLength:
+  Max: 108
+
+# Offense count: 3
+Style/Documentation:
+  Enabled: false

data/.travis.yml

@@ -0,0 +1,12 @@
+language: ruby
+sudo: false
+
+rvm:
+  - 1.9.3
+  - 2.1.8
+  - 2.2.4
+  - 2.3.0
+
+branches:
+  only:
+    - master

data/CHANGELOG.md

@@ -0,0 +1,7 @@
+### Next release
+
+Add your contribution here
+
+### v1.0.0
+
+First stable release!

data/Gemfile

@@ -0,0 +1,3 @@
+source 'https://rubygems.org'
+
+gemspec

data/LICENSE

@@ -0,0 +1,20 @@
+Copyright (c) 2015 Andrew Rempe and contributors.
+
+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/README.md

@@ -0,0 +1,136 @@
+Hattr
+=====
+
+[![Build Status](https://travis-ci.org/arempe93/hattr.svg?branch=master)](https://travis-ci.org/arempe93/hattr)
+[![Gem Version](https://badge.fury.io/rb/hattr.svg)](https://rubygems.org/gems/hattr)
+[![Coverage Status](https://coveralls.io/repos/arempe93/hattr/badge.svg?branch=master&service=github)](https://coveralls.io/github/arempe93/hattr?branch=master)
+
+A simple library for interacting with the PSQL `hstore` extension in `ActiveRecord`. Hattr supports coercion of `hstore` attributes based on a simple dsl and will eventually support more advanced features such as Rails validations and more configurable options.
+
+## Basic Usage
+
+Hattr was designed to be simple. All you need is to extend the `Hattr` module and start building your spec.
+
+```ruby
+class Television < ActiveRecord::Base
+  extend Hattr
+
+  hattr :metadata, :weight, type: Float
+  hattr :metadata, :screen_class, type: Integer
+end
+```
+
+Now when you call `metadata` on your `Television` object, instead of getting an ugly hash back that looks like this:
+
+```ruby
+{ "weight" => "35.6", "screen_class" => "55" }
+```
+
+You can get back data that matches your specification - like this:
+
+```ruby
+{ weight: 35.6, screen_class: 55 }
+```
+
+## Advanced Usage
+
+While Hattr was designed to be simple, it was also meant to be flexible to many use cases.
+
+### Attribute Options
+
+#### :type
+
+Sets the type of the attribute which defaults to `String` if not specified. Valid values include `String`, `Integer`, `Fixnum`, `Float`, `Symbol`, `Array`, and `Hash`. Errors may be raised if coercion cannot be completed
+
+```ruby
+class Person < ActiveRecord::Base
+  extend Hattr
+
+  hattr :metadata, :name    # :type == String
+end
+```
+**Super advanced usage**
+
+For `Array` and `Hash` types, you can specify the types of the keys/values. For example, for an array of numbers and a hash of strings mapped to floats, you can do:
+
+```ruby
+class Person < ActiveRecord::Base
+  extend Hattr
+
+  hattr :metadata, :array, type: Array[Fixnum]
+  hattr :metadata, :hash, type: Hash[String => Float]
+end
+```
+
+The inner values are subject to inclusion in the list above for normal types.
+
+**NOT ADVANCED ENOUGH**
+
+Since it recursively calls `typecast` on the values of the array and **values** of the hash, you can do some pretty crazy stuff
+
+```ruby
+class Person < ActiveRecord::Base
+  extend Hattr
+
+  hattr :metadata, :wtf, type: Hash[Symbol => Array[Hash[String => Hash[Symbol => Float]]]]
+end
+```
+
+Also, in case you're curious, just plain `Hash` and `Array` in the "normal" types list map to `Hash[Symbol => String]` and `Array[String]` respectively behind the scenes.
+
+### Group Options
+
+#### :string_keys
+
+Leaves hash keys as strings instead of symbolizing them. Defaults to `false` if `hattr_group` is not called or `:string_keys` is not specified.
+
+```ruby
+class Television < ActiveRecord::Base
+  extend Hattr
+
+  hattr_group :metadata, string_keys: true
+  hattr :metadata, :weight, type: Float
+  hattr :metadata, :screen_class, type: Integer
+end
+```
+
+### Multiple Attributes
+
+```ruby
+class Person < ActiveRecord::Base
+  extend Hattr
+
+  hattr :address, :line1, type: String
+  hattr :address, :line2, type: String
+  hattr :address, :zip, type: Integer
+
+  hattr :metadata, :age, type: Integer
+  hattr :metadata, :weight, type: Float
+end
+```
+
+## Contributing
+
+I would like to add more options to attribute and group dealing with validation, but if you have an idea feel free to open an issue/pull request!
+
+## Installation
+
+#### With RubyGems
+
+To install Hattr with RubyGems:
+
+```
+gem install hattr
+```
+
+#### With Bundler
+
+To use Hattr with a Bundler managed project:
+
+```
+gem 'hattr'
+```
+
+## License
+
+Released under the MIT license

data/Rakefile

@@ -0,0 +1,29 @@
+require 'rubygems'
+require 'bundler'
+Bundler.setup :default, :test, :development
+
+Bundler::GemHelper.install_tasks
+
+require 'rspec/core/rake_task'
+RSpec::Core::RakeTask.new(:spec) do |spec|
+  spec.pattern = 'spec/**/*_spec.rb'
+end
+
+RSpec::Core::RakeTask.new(:rcov) do |spec|
+  spec.pattern = 'spec/**/*_spec.rb'
+  spec.rcov = true
+end
+
+task :spec
+
+require 'rubocop/rake_task'
+RuboCop::RakeTask.new
+
+task default: [:rubocop, :spec]
+
+require 'yard'
+DOC_FILES = ['lib/**/*.rb', 'README.md']
+
+YARD::Rake::YardocTask.new(:doc) do |t|
+  t.files = DOC_FILES
+end

data/hattr.gemspec

@@ -0,0 +1,30 @@
+#!/usr/bin/env gem build
+# encoding: utf-8
+
+require 'base64'
+require File.expand_path("../lib/hattr/version", __FILE__)
+
+Gem::Specification.new do |s|
+  s.name        = 'hattr'
+  s.version     = Hattr::VERSION.dup
+  s.platform    = Gem::Platform::RUBY
+  s.authors     = ['Andrew Rempe']
+  s.email       = [Base64.decode64('YW5kcmV3cmVtcGVAZ21haWwuY29t\n')]
+  s.summary     = 'PSQL hstore attributes'
+  s.description = 'A translation for the string centric hstore extension'
+  s.license     = 'MIT'
+
+  s.required_ruby_version = Gem::Requirement.new '>= 1.9.3'
+
+  s.add_dependency 'activesupport', '>= 3.0.0'
+
+  s.add_development_dependency 'rake', '~> 10.5.0'
+  s.add_development_dependency 'rubocop'
+  s.add_development_dependency 'yard'
+  s.add_development_dependency 'rspec', '~> 3.4.0'
+  s.add_development_dependency 'coveralls'
+
+  s.files         = `git ls-files`.split "\n"
+  s.test_files    = `git ls-files -- spec/*`.split "\n"
+  s.require_paths = [ 'lib' ]
+end

data/lib/hattr.rb

@@ -0,0 +1,17 @@
+# frozen_string_literal: true
+require 'active_support/core_ext/class/attribute'
+require 'active_support/core_ext/hash/keys'
+
+require 'hattr/version'
+
+require 'hattr/class_methods'
+require 'hattr/hash_builder'
+
+module Hattr
+  def self.extended(receiver)
+    receiver.class_attribute :hattr_groups, instance_reader: false, instance_writer: false
+    receiver.hattr_groups = {}
+
+    receiver.extend ClassMethods
+  end
+end

data/lib/hattr/class_methods.rb

@@ -0,0 +1,59 @@
+# frozen_string_literal: true
+module Hattr
+  module ClassMethods
+    GROUP_OPTIONS = [:string_keys].freeze
+    ATTR_OPTIONS  = [:type].freeze
+
+    GROUP_DEFAULTS = { string_keys: false }.freeze
+    ATTR_DEFAULTS  = { type: String }.freeze
+
+    OPTIONS_STORAGE_KEY = :_hattr_options
+
+    ARRAY_DEFAULT = Array[String]
+    HASH_DEFAULT  = Hash[Symbol => String]
+
+    def hattr_group(field, opts = {})
+      validate_options(opts, GROUP_OPTIONS)
+      store_group(field, GROUP_DEFAULTS.merge(opts))
+    end
+
+    def hattr(field, attribute, opts = {})
+      raise ArgumentError, "`#{OPTIONS_STORAGE_KEY}` is reserved" if attribute.to_sym == OPTIONS_STORAGE_KEY
+
+      validate_options(opts, ATTR_OPTIONS)
+      store_attribute(field, attribute, ATTR_DEFAULTS.merge(opts))
+    end
+
+    def build_group_hash(spec, value)
+      HashBuilder.generate(spec, value)
+    end
+
+    private
+
+    def validate_options(opts, valid_keys)
+      opts.keys.each do |k|
+        unless valid_keys.include?(k)
+          raise ArgumentError, "invalid option `#{k}`. Valid options include: :#{valid_keys.join(', :')}"
+        end
+      end
+    end
+
+    def store_group(field, opts)
+      hattr_groups[field.to_sym] = { OPTIONS_STORAGE_KEY => opts }
+      create_reader_method(field)
+    end
+
+    def store_attribute(field, attribute, opts)
+      store_group(field, GROUP_DEFAULTS.dup) unless hattr_groups[field]
+      hattr_groups[field][attribute.to_sym] = opts
+    end
+
+    def create_reader_method(field)
+      class_eval do
+        define_method field do
+          self.class.build_group_hash(self.class.hattr_groups[field].dup, read_attribute(field))
+        end
+      end
+    end
+  end
+end

data/lib/hattr/hash_builder.rb

@@ -0,0 +1,58 @@
+# frozen_string_literal: true
+module Hattr
+  module HashBuilder
+    module_function
+
+    ARRAY_TYPE_DEFAULT = Array[String]
+    HASH_TYPE_DEFAULT  = Hash[Symbol => String]
+
+    def generate(spec, raw)
+      opts = spec.delete(ClassMethods::OPTIONS_STORAGE_KEY)
+
+      raw = raw.symbolize_keys unless opts[:string_keys]
+      raw.each { |k, v| raw[k] = typecast(v, spec.fetch(k.to_sym, ClassMethods::ATTR_DEFAULTS)[:type]) }
+    end
+
+    def typecast(value, type)
+      case
+      when type.class == Hash then hash_typecast(value, type)
+      when type.class == Array then array_typecast(value, type)
+      else primitive_typecast(value, type)
+      end
+    end
+
+    def primitive_typecast(value, type)
+      case
+      when type == Integer, type == Fixnum then value.to_i
+      when type == Float then value.to_f
+      when type == Symbol then value.to_sym
+      when type == Array then array_typecast(value, ARRAY_TYPE_DEFAULT)
+      when type == Hash then hash_typecast(value, HASH_TYPE_DEFAULT)
+      else value
+      end
+    end
+
+    def hash_typecast(value, model)
+      key_type, val_type = model.flatten
+      hash = string_to_hash(value)
+
+      hash = key_type == Symbol ? hash.symbolize_keys : hash
+      hash.each { |k, v| hash[k] = typecast(v, val_type) }
+    end
+
+    def array_typecast(value, model)
+      val_type = model.first
+      array = string_to_array(value)
+
+      array.map { |elem| typecast(elem, val_type) }
+    end
+
+    def string_to_hash(str)
+      Hash[str.tr('{}:" ', '').split(',').map { |pair| pair.split('=>') }]
+    end
+
+    def string_to_array(str)
+      str.tr('[]:" ', '').split(',')
+    end
+  end
+end

data/lib/hattr/version.rb

@@ -0,0 +1,4 @@
+# frozen_string_literal: true
+module Hattr
+  VERSION = '1.0.0'
+end

data/spec/integration/hash_output_spec.rb

@@ -0,0 +1,11 @@
+describe Hattr::HashBuilder, '#generate' do
+  subject { described_class }
+
+  it 'simple example' do
+    spec   = { _hattr_options: Hattr::ClassMethods::GROUP_DEFAULTS, int: { type: Integer }, arr: { type: Array }, hsh: { type: Hash[Symbol => Float] } }
+    raw    = { 'int' => '123', arr: ['one', 'two', 'three'].to_s, hsh: { 'one' => '1.0', 'two' => '2.0', 'three' => '3.0' }.to_s }
+    output = { int: 123, arr: ['one', 'two', 'three'], hsh: { one: 1.0, two: 2.0, three: 3.0 } }
+
+    expect(subject.generate(spec, raw)).to eql output
+  end
+end

data/spec/spec_helper.rb

@@ -0,0 +1,15 @@
+require 'rspec'
+
+$LOAD_PATH.unshift File.expand_path('../lib', __FILE__)
+
+require 'bundler'
+Bundler.setup :default, :test
+Bundler.require
+
+require 'coveralls'
+Coveralls.wear!
+
+require 'hattr'
+
+RSpec.configure do |config|
+end

data/spec/unit/hattr/class_methods_spec.rb

@@ -0,0 +1,125 @@
+describe Hattr::ClassMethods do
+  subject { Class.new.extend(Hattr) }
+
+  context '::hattr_group' do
+    let(:field) { :group }
+    let(:options) { Hash.new }
+    after { subject.hattr_group(field, options) }
+
+    it 'should validate group level options' do
+      expect(subject).to receive(:validate_options).with(options, described_class::GROUP_OPTIONS)
+    end
+
+    it 'should store group' do
+      expect(subject).to receive(:store_group).with(field, described_class::GROUP_DEFAULTS.merge(options))
+    end
+  end
+
+  context '::hattr' do
+    let(:field) { :group }
+    let(:attribute) { :attr }
+    let(:options) { Hash.new }
+
+    context 'when using reserved attribute name' do
+      let(:attribute) { described_class::OPTIONS_STORAGE_KEY }
+
+      it 'should raise ArgumentError' do
+        expect { subject.hattr(field, attribute, options) }.to raise_error ArgumentError
+      end
+    end
+
+    context 'when valid input provided' do
+      after { subject.hattr(field, attribute, options) }
+
+      it 'should validate attribute level options' do
+        expect(subject).to receive(:validate_options).with(options, described_class::ATTR_OPTIONS)
+      end
+
+      it 'should store attribute' do
+        expect(subject).to receive(:store_attribute).with(field, attribute, described_class::ATTR_DEFAULTS.merge(options))
+      end
+    end
+  end
+
+  context '::validate_options' do
+    let(:options) { described_class::GROUP_DEFAULTS }
+
+    context 'when invalid keys given' do
+      let(:options) { Hash[foo: :bar] }
+
+      it 'should raise ArgumentError' do
+        expect { subject.send(:validate_options, options, described_class::GROUP_OPTIONS) }.to raise_error ArgumentError
+      end
+    end
+
+    context 'when all keys are valid' do
+      it 'should not raise error' do
+        expect { subject.send(:validate_options, options, described_class::GROUP_OPTIONS) }.to_not raise_error
+      end
+    end
+  end
+
+  context '::store_group' do
+    let(:field) { :group }
+    let(:options) { Hash[foo: :bar] }
+    before { subject.send(:store_group, field, options) }
+    after  { subject.send(:store_group, field, options) }
+
+    it 'should store options in `hattr_groups`' do
+      expect(subject.hattr_groups[field]).to eql Hash[described_class::OPTIONS_STORAGE_KEY => options]
+    end
+
+    it 'should create reader method for field' do
+      expect(subject).to receive(:create_reader_method).with(field)
+    end
+  end
+
+  context '::store_attribute' do
+    let(:field) { :group }
+    let(:attribute) { :attr }
+    let(:options) { Hash[foo: :bar] }
+
+    context 'when group not yet defined' do
+      after { subject.send(:store_attribute, field, attribute, options) }
+
+      it 'should store group with default options' do
+        expect(subject).to receive(:store_group).with(field, described_class::GROUP_DEFAULTS) do |field, opts|
+          subject.hattr_groups[field] = { described_class::OPTIONS_STORAGE_KEY => opts.dup }
+        end
+      end
+    end
+
+    context 'when group already defined' do
+      before { subject.hattr_groups[field] = { described_class::OPTIONS_STORAGE_KEY => described_class::GROUP_DEFAULTS } }
+      after  { subject.send(:store_attribute, field, attribute, options) }
+
+      it 'should not store group again' do
+        expect(subject).to_not receive(:store_group)
+      end
+    end
+
+    it 'should store options in group' do
+      subject.send(:store_attribute, field, attribute, options)
+      expect(subject.hattr_groups[field][attribute]).to eql options
+    end
+  end
+
+  context '::create_reader_method' do
+    let(:field) { :group }
+    before { subject.send(:create_reader_method, field) }
+
+    it 'should add instance method with name field' do
+      expect(subject.new).to respond_to field
+    end
+  end
+
+  context '::build_group_hash' do
+    let(:spec) { Hash[foo: :bar] }
+    let(:value) { Hash.new[boo: :baz]}
+    after { subject.send(:build_group_hash, spec, value) }
+
+    it 'should generate hash' do
+      expect(Hattr::HashBuilder).to receive(:generate).with(spec, value)
+    end
+  end
+end

data/spec/unit/hattr/hash_builder_spec.rb

@@ -0,0 +1,130 @@
+describe Hattr::HashBuilder do
+  subject { described_class }
+
+  TYPECAST_TEST_SET = {
+    Integer => { pre: '123', post: 123 },
+    Fixnum  => { pre: '123', post: 123 },
+    String  => { pre: 'foo', post: 'foo' },
+    Float   => { pre: '1.2', post: 1.2 },
+    Symbol  => { pre: 'foo', post: :foo }
+  }
+
+  context '::typecast' do
+    let(:value) { nil }
+    after { subject.typecast(value, type) }
+
+    context 'when type is Hash' do
+      let(:type) { Hash[foo: :bar] }
+      it 'should cast with hash_typecast' do
+        expect(subject).to receive(:hash_typecast).with(value, type)
+      end
+    end
+
+    context 'when type is Array' do
+      let(:type) { Array[:foo] }
+      it 'should cast with array_typecast' do
+        expect(subject).to receive(:array_typecast).with(value, type)
+      end
+    end
+
+    context 'when type is Class' do
+      let(:type) { Class }
+      it 'should cast with primitive_typecast' do
+        expect(subject).to receive(:primitive_typecast).with(value, type)
+      end
+    end
+  end
+
+  context '::primitive_typecast' do
+    context 'when class is primitive type' do
+      before { @result = subject.primitive_typecast(value, type) }
+
+      TYPECAST_TEST_SET.each do |key, value|
+        context "when type is #{key}" do
+          let(:value) { value[:pre] }
+          let(:type) { key }
+
+          it 'should cast correctly' do
+            expect(@result).to eql value[:post]
+          end
+        end
+      end
+    end
+
+    context 'when class is data structure' do
+      let(:value) { nil }
+      after { subject.primitive_typecast(value, type) }
+
+      context 'when type is Array' do
+        let(:type) { Array }
+        it 'should call array_typecast' do
+          expect(subject).to receive(:array_typecast).with(value, described_class::ARRAY_TYPE_DEFAULT)
+        end
+      end
+
+      context 'when type is Hash' do
+        let(:type) { Hash }
+        it 'should call hash_typecast' do
+          expect(subject).to receive(:hash_typecast).with(value, described_class::HASH_TYPE_DEFAULT)
+        end
+      end
+    end
+  end
+
+  context '::hash_typecast' do
+    let(:key_type) { String }
+    let(:val_type) { Integer }
+    let(:value) { Hash['one' => '1'] }
+    let(:model) { Hash[key_type => val_type] }
+    after { subject.hash_typecast(value.to_s, model) }
+
+    it 'should convert string to hash' do
+      expect(subject).to receive(:string_to_hash).with(value.to_s).and_return(value)
+    end
+
+    it 'should convert each value to given type' do
+      value.values.each do |val|
+        expect(subject).to receive(:typecast).with(val, val_type)
+      end
+    end
+
+    context 'when key type is Symbol' do
+      let(:key_type) { Symbol }
+      it 'should symbolize keys' do
+        expect(subject).to receive(:string_to_hash).with(value.to_s).and_return(value)
+        expect(value).to receive(:symbolize_keys).and_return(value.symbolize_keys)
+      end
+    end
+  end
+
+  context '::array_typecast' do
+    let(:val_type) { Integer }
+    let(:value) { Array['1'] }
+    let(:model) { Array[val_type] }
+    after { subject.array_typecast(value.to_s, model) }
+
+    it 'should convert string to array' do
+      expect(subject).to receive(:string_to_array).with(value.to_s).and_return(value)
+    end
+
+    it 'should convert each value to given type' do
+      value.each do |val|
+        expect(subject).to receive(:typecast).with(val, val_type)
+      end
+    end
+  end
+
+  context '::string_to_hash' do
+    let(:value) { Hash['foo' => 'bar'] }
+    it 'should reverse hash.to_s' do
+      expect(subject.string_to_hash(value.to_s)).to eql value
+    end
+  end
+
+  context '::string_to_array' do
+    let(:value) { Array['foo', 'bar'] }
+    it 'should reverse array.to_s' do
+      expect(subject.string_to_array(value.to_s)).to eql value
+    end
+  end
+end

data/spec/unit/hattr_spec.rb

@@ -0,0 +1,15 @@
+describe Hattr do
+  context '::extended' do
+    let(:receiver) { Class.new }
+    before { receiver.extend Hattr }
+
+    it 'should extend ClassMethods' do
+      expect(receiver).to respond_to :hattr
+      expect(receiver).to respond_to :hattr_group
+    end
+
+    it 'should create `hattr_groups` class variable' do
+      expect(receiver.hattr_groups).to be_a Hash
+    end
+  end
+end

metadata

@@ -0,0 +1,156 @@
+--- !ruby/object:Gem::Specification
+name: hattr
+version: !ruby/object:Gem::Version
+  version: 1.0.0
+platform: ruby
+authors:
+- Andrew Rempe
+autorequire: 
+bindir: bin
+cert_chain: []
+date: 2016-05-20 00:00:00.000000000 Z
+dependencies:
+- !ruby/object:Gem::Dependency
+  name: activesupport
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - ">="
+      - !ruby/object:Gem::Version
+        version: 3.0.0
+  type: :runtime
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - ">="
+      - !ruby/object:Gem::Version
+        version: 3.0.0
+- !ruby/object:Gem::Dependency
+  name: rake
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: 10.5.0
+  type: :development
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: 10.5.0
+- !ruby/object:Gem::Dependency
+  name: rubocop
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - ">="
+      - !ruby/object:Gem::Version
+        version: '0'
+  type: :development
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - ">="
+      - !ruby/object:Gem::Version
+        version: '0'
+- !ruby/object:Gem::Dependency
+  name: yard
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - ">="
+      - !ruby/object:Gem::Version
+        version: '0'
+  type: :development
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - ">="
+      - !ruby/object:Gem::Version
+        version: '0'
+- !ruby/object:Gem::Dependency
+  name: rspec
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: 3.4.0
+  type: :development
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: 3.4.0
+- !ruby/object:Gem::Dependency
+  name: coveralls
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - ">="
+      - !ruby/object:Gem::Version
+        version: '0'
+  type: :development
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - ">="
+      - !ruby/object:Gem::Version
+        version: '0'
+description: A translation for the string centric hstore extension
+email:
+- andrewrempe@gmail.com
+executables: []
+extensions: []
+extra_rdoc_files: []
+files:
+- ".coveralls.yml"
+- ".editorconfig"
+- ".gitignore"
+- ".rspec"
+- ".rubocop.yml"
+- ".rubocop_todo.yml"
+- ".travis.yml"
+- CHANGELOG.md
+- Gemfile
+- LICENSE
+- README.md
+- Rakefile
+- hattr.gemspec
+- lib/hattr.rb
+- lib/hattr/class_methods.rb
+- lib/hattr/hash_builder.rb
+- lib/hattr/version.rb
+- spec/integration/hash_output_spec.rb
+- spec/spec_helper.rb
+- spec/unit/hattr/class_methods_spec.rb
+- spec/unit/hattr/hash_builder_spec.rb
+- spec/unit/hattr_spec.rb
+homepage: 
+licenses:
+- MIT
+metadata: {}
+post_install_message: 
+rdoc_options: []
+require_paths:
+- lib
+required_ruby_version: !ruby/object:Gem::Requirement
+  requirements:
+  - - ">="
+    - !ruby/object:Gem::Version
+      version: 1.9.3
+required_rubygems_version: !ruby/object:Gem::Requirement
+  requirements:
+  - - ">="
+    - !ruby/object:Gem::Version
+      version: '0'
+requirements: []
+rubyforge_project: 
+rubygems_version: 2.5.1
+signing_key: 
+specification_version: 4
+summary: PSQL hstore attributes
+test_files:
+- spec/integration/hash_output_spec.rb
+- spec/spec_helper.rb
+- spec/unit/hattr/class_methods_spec.rb
+- spec/unit/hattr/hash_builder_spec.rb
+- spec/unit/hattr_spec.rb
+has_rdoc: