hashme 0.1.0

checksums.yaml

@@ -0,0 +1,7 @@
+---
+SHA1:
+  metadata.gz: 4f9cb6f4cdaff6724a27b50649492558e063d895
+  data.tar.gz: 821a1a3dd493decc292af29ba65b25ded28a6ce8
+SHA512:
+  metadata.gz: 2ce2e52be2471ebc0ea3a4e379d0b03722f9e393548e6daa22ace5f110e655198771161ccd3351a49cd9ab365f9a4d4ed6dab2c31525b58bedca5f2d700a43f8
+  data.tar.gz: 913eeffb93e61a1304dd37297b39f0e0b896a2e39f37d45ce100bac68c16ec320d3ceeb7f1c54ba6052148fe24c2e07c6b142acc772df794de99649639feb7e3

data/.gitignore

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

data/Gemfile

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

data/LICENSE.txt

@@ -0,0 +1,22 @@
+Copyright (c) 2014 Sam Lown
+
+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.

data/README.md

@@ -0,0 +1,95 @@
+# Hashme
+
+Hashes are great, but sometimes you need a bit more structure.
+
+Hashme helps you create simple models that allow you to initialize and
+generate hashes that you can serialize and store as you wish.
+
+Its a bit like ActiveRecord, but without all the messy database stuff,
+and of course you can nest to you're hearts content.
+
+## Installation
+
+Add this line to your application's Gemfile:
+
+    gem 'hashme'
+
+And then execute:
+
+    $ bundle
+
+Or install it yourself as:
+
+    $ gem install hashme
+
+## Usage
+
+Create a class, include the `Hashme` module, and define some properties:
+
+````ruby
+# Our cat class!
+class Cat
+  include Hashme
+
+  property :name,        String
+  property :description, String
+end
+
+# Do something with it
+kitty = Cat.new(:name => "Catso", :description => "Meows a lot")
+kitty.name     # Catso
+kitty.to_hash  # {:name => "Catso", :description => "Meows a lot"}
+kitty.to_json  # "{\"name\":\"Catso\",\"description\":\"Meows a lot\"}"
+
+kitty2 = Cat.new(kitty.to_hash)
+kitty2.to_hash == kitty.to_hash  # true!
+````
+
+Models can also be nested, which is probably the most useful part:
+
+````ruby
+# A kennel full of kitties
+class Kennel
+  include Hashme
+
+  property :name,      String
+  property :location,  Point
+  property :cats,      [Cat]
+end
+
+# Build a kennel
+kennel = Kennel.new(:name => "Goaway Kitty Home", :location => Point.new(40.333,-3.4555))
+
+# Add a kitten using an object
+kennel << kitty
+
+# Add a new cat using a raw hash
+kennel << {
+  :name => "Felix",
+  :description => "Black and white"
+}
+
+# Serialize and deserialize to recreate the whole structure
+store = kennel.to_hash
+kennel = Kennel.new(store)
+kennel.cats.length == 2    # true!
+````
+
+## Contributing
+
+1. Fork it
+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
+
+## Authors
+
+ * Sam Lown <me@samlown.com>
+
+## History
+
+### 0.1.0 - 2014-01-15
+
+ * First release!
+

data/Rakefile

@@ -0,0 +1 @@
+require "bundler/gem_tasks"

data/hashme.gemspec

@@ -0,0 +1,26 @@
+# coding: utf-8
+lib = File.expand_path('../lib', __FILE__)
+$LOAD_PATH.unshift(lib) unless $LOAD_PATH.include?(lib)
+require 'hashme/version'
+
+Gem::Specification.new do |spec|
+  spec.name          = "hashme"
+  spec.version       = Hashme::VERSION
+  spec.authors       = ["Sam Lown"]
+  spec.email         = ["me@samlown.com"]
+  spec.description   = %q{Modeling with Hashes made easy.}
+  spec.summary       = %q{Easily define simple models that can be easily serialized and de-serialized.}
+  spec.homepage      = ""
+  spec.license       = "MIT"
+
+  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_dependency "activemodel", "~> 3.0"
+
+  spec.add_development_dependency "bundler", "~> 1.3"
+  spec.add_development_dependency "rake"
+  spec.add_development_dependency "rspec"
+end

data/lib/hashme.rb

@@ -0,0 +1,45 @@
+require "hashme/version"
+
+# External dependencies
+
+require "active_model"
+require "active_model/naming"
+require "active_model/serialization"
+
+require "active_support/core_ext"
+require "active_support/json"
+
+# Local dependencies
+
+require "hashme/attributes"
+require "hashme/castable"
+require "hashme/casted_array"
+require "hashme/properties"
+require "hashme/property"
+
+module Hashme
+  extend ActiveSupport::Concern
+
+  include ActiveModel::Validations
+
+  included do
+    include Castable
+    include Attributes
+    include Properties
+    # Eventually! include Validations
+  end
+
+  def initialize(attrs = {})
+    # Use the `Properties` module's `#set_attribtues` method
+    set_attributes(attrs)
+  end
+
+  module ClassMethods
+    # Little help. Equivalent to new.tap
+    def build(*attrs)
+      instance = self.new(*attrs)
+      yield instance if block_given?
+      instance
+    end
+  end
+end

data/lib/hashme/attributes.rb

@@ -0,0 +1,56 @@
+module Hashme
+  module Attributes
+    include Enumerable
+    
+    extend Forwardable
+
+    def_delegators :_attributes, :to_a,
+      :==, :eql?, :keys, :values, :each,
+      :reject, :reject!, :empty?, :clear, :merge, :merge!,
+      :encode_json, :as_json, :to_json, :to_hash,
+      :frozen?
+
+    def []=(key, value)
+      _attributes[key.to_sym] = value
+    end
+
+    def [](key)
+      _attributes[key.to_sym]
+    end
+
+    def has_key?(key)
+      _attributes.has_key?(key.to_sym)
+    end
+
+    def delete(key)
+      _attributes.delete(key.to_sym)
+    end
+
+    def dup
+      new = super
+      @_attributes = @_attributes.dup
+      new
+    end
+
+    def clone
+      new = super
+      @_attributes = @_attributes.clone
+      new
+    end
+
+    def inspect
+      string = keys.collect{|key|
+        "#{key}: #{self[key].inspect}"
+      }.compact.join(", ")
+      "#<#{self.class} #{string}>"
+    end
+
+    private
+
+    def _attributes
+      @_attributes ||= {}
+      @_attributes
+    end
+
+  end
+end

data/lib/hashme/castable.rb

@@ -0,0 +1,10 @@
+module Hashme
+  module Castable
+    extend ActiveSupport::Concern
+
+    included do
+      attr_accessor :casted_by
+      attr_accessor :casted_by_property
+    end
+  end
+end

data/lib/hashme/casted_array.rb

@@ -0,0 +1,61 @@
+require 'forwardable'
+
+module Hashme
+
+  # The Hashme CastedArray is a special object wrapper that allows other Model's
+  # or Objects to be stored in an array, but maintain casted ownership.
+  #
+  # Adding objects will automatically assign the Array's owner, as opposed
+  # to the array itself.
+  #
+  class CastedArray
+    extend Forwardable
+    include Castable
+
+    def_delegators :@_array,
+      :to_a, :==, :eql?, :size,
+      :first, :last, :at, :length,
+      :each, :reject, :empty?, :map,
+      :clear, :pop, :shift, :delete, :delete_at,
+      :encode_json, :as_json, :to_json,
+      :inspect, :any?
+
+    def initialize(owner, property, values = [])
+      @_array = []
+      self.casted_by = owner
+      self.casted_by_property = property
+      if values.respond_to?(:each)
+        values.each do |value|
+          self.push(value)
+        end
+      end
+    end
+
+    def <<(obj)
+      @_array << instantiate_and_build(obj)
+    end
+
+    def push(obj)
+      @_array.push(instantiate_and_build(obj))
+    end
+
+    def unshift(obj)
+      @_array.unshift(instantiate_and_build(obj))
+    end
+    
+    def [] index
+      @_array[index]
+    end
+
+    def []= index, obj
+      @_array[index] = instantiate_and_build(obj)
+    end
+    
+    protected
+
+    def instantiate_and_build(obj)
+      casted_by_property.build(casted_by, obj)
+    end
+
+  end
+end

data/lib/hashme/properties.rb

@@ -0,0 +1,80 @@
+module Hashme
+  module Properties
+    extend ActiveSupport::Concern
+
+    def get_attribute(name)
+      self[name]
+    end
+
+    def set_attribute(name, value)
+      property = get_property(name)
+      if property.nil?
+        self[name.to_sym] = value
+      else
+        self[property.name] = value.present? ?  property.cast(self, value) : value
+      end
+    end
+
+    protected
+
+    # Internal method to go through each attribute and set the
+    # values via the set_attribute method.
+    def set_attributes(attrs = {})
+      attrs.each do |key, value|
+        set_attribute(key, value)
+      end
+    end
+    
+    private
+    
+    def get_property(name)
+      # not only search in the class, search in the superclass too if the superclass can respond to properties[]. Using a class method for this
+      self.class.search_property(name)
+    end
+
+    module ClassMethods
+
+      attr_accessor :properties
+
+      def property(*args)
+        self.properties ||= {}
+
+        # Prepare the property object and methods
+        property = Property.new(*args)
+        properties[property.name] = property
+        define_property_methods(property)
+
+        property
+      end
+      
+      # Recursive search the property in the superclass chain
+      def search_property(name)        
+        name = name.to_sym
+        
+        if properties[name]
+          properties[name]
+        elsif superclass.respond_to?(:search_property)
+          superclass.search_property(name)
+        else
+          nil
+        end
+      end
+
+      protected
+
+      def define_property_methods(property)
+        # Getter
+        define_method(property.name) do
+          get_attribute(property.name) || property.default
+        end
+        # Setter
+        define_method "#{property.name}=" do |value|
+          set_attribute(property.name, value)
+        end
+      end
+
+    end
+
+
+  end
+end

data/lib/hashme/property.rb

@@ -0,0 +1,63 @@
+module Hashme
+  class Property
+
+    attr_accessor :name, :type, :default
+
+    def initialize(name, type, opts = {})
+      self.name = name.to_sym
+
+      # Always set type to base type
+      if type.is_a?(Array) && !type.first.nil?
+        @_use_casted_array = true
+        klass = type.first
+      else
+        @_use_casted_array = false
+        klass = type
+      end
+
+      self.type = klass
+
+      # Handle options
+      self.default = opts[:default]
+    end
+
+    def to_s
+      name.to_s
+    end
+
+    def to_sym
+      name
+    end
+
+    # Use cast method when we do not know if we may need to handle a
+    # casted array of objects.
+    def cast(owner, value)
+      if use_casted_array?
+        CastedArray.new(owner, self, value)
+      else
+        build(owner, value)
+      end
+    end
+
+    # Build a new object of the type defined by the property.
+    # Will not deal create CastedArrays!
+    def build(owner, value)
+      obj   = nil
+      if value.is_a?(type)
+        obj = value
+      elsif type == Date
+        obj = type.parse(value)
+      else
+        obj = type.new(value)
+      end
+      obj.casted_by = owner if obj.respond_to?(:casted_by=)
+      obj.casted_by_property = self if obj.respond_to?(:casted_by_property=)
+      obj
+    end
+
+    def use_casted_array?
+      @_use_casted_array
+    end
+
+  end
+end

data/lib/hashme/version.rb

@@ -0,0 +1,3 @@
+module Hashme
+  VERSION = "0.1.0"
+end

data/spec/hashme/attributes_spec.rb

@@ -0,0 +1,79 @@
+require 'spec_helper'
+
+describe Hashme::Attributes do
+
+
+  before :each do
+    @model = Class.new do
+      include Hashme
+    end
+    @obj = @model.new
+  end
+
+  let :attribs do
+    @obj.send(:_attributes)
+  end
+
+  describe "forwarded methods" do
+    before :each do
+      @hash = {:key1 => 'value1', :key2 => 'value2'}
+      @obj[:key1] = 'value1'
+      @obj[:key2] = 'value2'
+    end
+
+    it "should assign some of the basic hash methods" do
+      (@obj == @hash).should be_true
+      @obj.eql?(@hash).should be_true
+      @obj.keys.should eql(@hash.keys)
+      @obj.values.should eql(@hash.values)
+      @obj.to_hash.should eql(@hash)
+    end
+  end
+
+  describe "#[]=" do
+    it "should assign values to attributes hash" do
+      @obj[:akey] = "test"
+      attribs[:akey].should eql("test")
+      @obj['akey'] = "anothertest"
+      attribs[:akey].should eql("anothertest")
+      attribs['akey'].should be_nil
+    end
+  end
+
+  describe "#delete" do
+    it "should remove attribtue entry" do
+      @obj[:key] = 'value'
+      @obj.delete(:key)
+      @obj[:key].should be_nil
+    end
+  end
+
+  describe "#dup" do
+    it "should duplicate attributes" do
+      @obj[:key] = 'value'
+      @obj2 = @obj.dup
+      @obj2.send(:_attributes).object_id.should_not eql(@obj.send(:_attributes).object_id)
+    end
+  end
+
+  describe "#clone" do
+    it "should clone attributes" do
+      @obj[:key] = 'value'
+      @obj2 = @obj.clone
+      @obj2.send(:_attributes).object_id.should_not eql(@obj.send(:_attributes).object_id)
+    end
+  end
+
+
+  describe "#inspect" do
+
+    it "should provide something useful" do
+      @obj[:key1] = 'value1'
+      @obj[:key2] = 'value2'
+      @obj.inspect.should match(/#<.+ key1: "value1", key2: "value2">/)
+    end
+
+  end
+
+end
+

data/spec/hashme/base_spec.rb

@@ -0,0 +1,38 @@
+require 'spec_helper'
+
+describe Hashme do
+  
+  before :each do
+    @model = Class.new do
+      include Hashme
+      property :name, String
+    end
+  end
+  
+  describe '.build' do
+    it "should create a Model and give a block to build it" do
+      @model.should_receive(:call_in_block)
+      @model.build do |model|
+        @model.call_in_block
+        model.should be_kind_of(@model)
+      end
+    end
+  end
+
+  describe "#initialize" do
+
+    it "should accept nil" do
+      expect {
+        @obj = @model.new
+      }.to_not raise_error
+    end
+
+    it "should accept and set attributes" do
+      @obj = @model.new(:name => "Sam")
+      @obj.name.should eql("Sam")
+    end
+
+  end
+
+end
+

data/spec/hashme/casted_array_spec.rb

@@ -0,0 +1,56 @@
+require 'spec_helper'
+
+describe Hashme::CastedArray do
+
+  let :owner do
+    double()
+  end
+
+  let :submodel do
+    Class.new do
+      include Hashme
+      property :name, String
+    end
+  end
+
+  describe "#initialize" do
+    before :each do
+      @prop = Hashme::Property.new(:name, String)
+      @obj = Hashme::CastedArray.new(owner, @prop, ['test'])
+    end
+
+    it "should prepare array" do
+      @obj.length.should eql(1)
+    end
+
+    it "should set owner and property" do
+      @obj.casted_by.should eql(owner)
+      @obj.casted_by_property.should eql(@prop)
+    end
+
+    it "should instantiate and cast each value" do
+      @obj.first.should eql("test")
+      @obj.first.class.should eql(String)
+    end
+  end
+
+  describe "adding to array" do
+
+    before :each do
+      @prop = Hashme::Property.new(:item, submodel)
+      @obj = Hashme::CastedArray.new(owner, @prop, [{:name => 'test'}])
+    end
+
+    it "should cast new items" do
+      @obj << {:name => 'test2'}
+      @obj.last.class.should eql(submodel)
+      @obj.first.name.should eql('test')
+      @obj.last.name.should eql('test2')
+
+      @obj.last.casted_by.should eql(owner)
+      @obj.last.casted_by_property.should eql(@prop)
+    end
+
+  end
+
+end

data/spec/hashme/properties_spec.rb

@@ -0,0 +1,101 @@
+require 'spec_helper'
+
+describe Hashme::Properties do
+  
+  before :all do
+    @aux_model = Class.new do
+      include Hashme
+      property :age, Fixnum
+    end
+    Kernel.const_set("Aux", @aux_model)
+  end
+
+  before :each do
+    @model = Class.new do
+      include Hashme
+      property :name, String
+    end
+    
+    @obj = @model.new
+  end
+
+
+  describe "#get_attribute" do
+    it "should provide object in model" do
+      @obj[:key1] = 'value'
+      @obj.get_attribute(:key1).should eql('value')
+    end
+  end
+
+  describe "#set_attribute" do
+    it "should be posible to set attribute not defined as property" do
+      @obj.set_attribute('key1', 'value1')
+      @obj.set_attribute(:key2, 'value2')
+      @obj[:key1].should eql('value1')
+      @obj[:key2].should eql('value2')
+    end
+
+    it "should set and cast attribute with property" do
+      property = @model.send(:properties)[:name]
+      name = "Fred Flinstone"
+      property.should_receive(:cast).with(@obj, name).and_return(name)
+      @obj.set_attribute(:name, name)
+      @obj[:name].should eql(name)
+    end
+  end
+
+  describe ".properties" do
+
+    it "should be instantiated after property set" do
+      @model.properties.should_not be_nil
+      @model.properties.class.should eql(Hash)
+    end
+
+    it "should be null if no properties" do
+      model = Class.new do
+        include Hashme
+      end
+      model.properties.should be_nil
+    end
+
+  end
+
+  describe ".property" do
+
+    it "should fail if no type is defined" do
+      @model.properties.length.should eql(1)
+      expect {
+        @model.property :foobar
+      }.to raise_error(ArgumentError)
+      @model.properties.length.should eql(1)
+    end
+
+    it "should create a new property with helper methods" do
+      @model.properties.length.should eql(1)
+      @model.property :desc, String
+      @model.properties.length.should eql(2)
+
+      prop = @model.properties[:desc]
+      prop.class.should eql(Hashme::Property)
+
+      @obj.should respond_to(:desc)
+      @obj.should respond_to(:desc=)
+
+      @obj.desc = "test"
+      @obj.desc.should eql("test")
+    end
+    
+    it "should return nil on property with no default" do
+      @model.property :nickname, String
+      @obj.nickname.should be_nil
+    end
+
+    it "should create helper method with support for default values" do
+      @model.property :name, String, :default => "Sam"
+      @obj.name.should eql("Sam")
+    end
+
+  end
+
+
+end

data/spec/hashme/property_spec.rb

@@ -0,0 +1,92 @@
+require 'spec_helper'
+
+describe Hashme::Property do
+
+  let :owner do
+    double()
+  end
+
+  let :klass do
+    Hashme::Property
+  end
+
+  let :submodel do
+    Class.new do
+      include Hashme
+      property :name, String
+    end
+  end
+
+  describe "#initialize" do
+
+    it "should copy name and type" do
+      prop = klass.new("name", String)
+      prop.name.should eql(:name)
+      prop.type.should eql(String)
+      prop.use_casted_array?.should be_false
+    end
+
+    it "should convert Array to CastedArray type" do
+      prop = klass.new("names", [String])
+      prop.name.should eql(:names)
+      prop.type.should eql(String)
+      prop.use_casted_array?.should be_true
+    end
+
+    it "should accept a default option" do
+      prop = klass.new(:name, String, :default => "Freddo")
+      prop.default.should eql("Freddo")
+    end
+
+  end
+
+  describe "#to_s" do
+    it "should use property's name" do
+      prop = klass.new(:name, String)
+      prop.to_s.should eql("name")
+    end
+  end
+
+  describe "#to_sym" do
+    it "should return the name" do
+      prop = klass.new(:name, String)
+      prop.to_sym.should eql (:name)
+    end
+  end
+
+  describe "#cast" do
+    context "without an array" do
+      it "should build a new object" do
+        prop = klass.new(:date, Time)
+        obj = prop.cast(owner, "2013-06-02T12:00:00")
+        obj.class.should eql(Time)
+        obj.should eql(Time.new("2013-06-02T12:00:00"))
+      end
+
+      it "should assign casted by and property" do
+        prop = klass.new(:item, submodel)
+        obj = prop.cast(owner, {:name => 'test'})
+        obj.casted_by.should eql(owner)
+        obj.casted_by_property.should eql(prop)
+      end
+    end
+
+    context "with an array" do
+      it "should convert regular array to casted array" do
+        prop = klass.new(:dates, [Time])
+        obj = prop.cast(owner, ["2013-06-02T12:00:00"])
+        obj.class.should eql(Hashme::CastedArray)
+        obj.first.class.should eql(Time)
+      end
+      it "should handle complex objects" do
+        prop = klass.new(:items, [submodel])
+        obj = prop.cast(owner, [{:name => 'test'}])
+        obj.class.should eql(Hashme::CastedArray)
+        obj.first.class.should eql(submodel)
+        obj.first.name.should eql('test')
+      end
+    end
+  end
+
+
+end

data/spec/spec_helper.rb

@@ -0,0 +1,8 @@
+require 'bundler/setup'
+require 'rspec'
+
+lib = File.expand_path('../lib', __FILE__)
+$LOAD_PATH.unshift(lib) unless $LOAD_PATH.include?(lib)
+
+require 'hashme'
+

metadata

@@ -0,0 +1,125 @@
+--- !ruby/object:Gem::Specification
+name: hashme
+version: !ruby/object:Gem::Version
+  version: 0.1.0
+platform: ruby
+authors:
+- Sam Lown
+autorequire: 
+bindir: bin
+cert_chain: []
+date: 2014-01-15 00:00:00.000000000 Z
+dependencies:
+- !ruby/object:Gem::Dependency
+  name: activemodel
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - ~>
+      - !ruby/object:Gem::Version
+        version: '3.0'
+  type: :runtime
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - ~>
+      - !ruby/object:Gem::Version
+        version: '3.0'
+- !ruby/object:Gem::Dependency
+  name: bundler
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - ~>
+      - !ruby/object:Gem::Version
+        version: '1.3'
+  type: :development
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - ~>
+      - !ruby/object:Gem::Version
+        version: '1.3'
+- !ruby/object:Gem::Dependency
+  name: rake
+  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: '0'
+  type: :development
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - '>='
+      - !ruby/object:Gem::Version
+        version: '0'
+description: Modeling with Hashes made easy.
+email:
+- me@samlown.com
+executables: []
+extensions: []
+extra_rdoc_files: []
+files:
+- .gitignore
+- Gemfile
+- LICENSE.txt
+- README.md
+- Rakefile
+- hashme.gemspec
+- lib/hashme.rb
+- lib/hashme/attributes.rb
+- lib/hashme/castable.rb
+- lib/hashme/casted_array.rb
+- lib/hashme/properties.rb
+- lib/hashme/property.rb
+- lib/hashme/version.rb
+- spec/hashme/attributes_spec.rb
+- spec/hashme/base_spec.rb
+- spec/hashme/casted_array_spec.rb
+- spec/hashme/properties_spec.rb
+- spec/hashme/property_spec.rb
+- spec/spec_helper.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: '0'
+required_rubygems_version: !ruby/object:Gem::Requirement
+  requirements:
+  - - '>='
+    - !ruby/object:Gem::Version
+      version: '0'
+requirements: []
+rubyforge_project: 
+rubygems_version: 2.0.3
+signing_key: 
+specification_version: 4
+summary: Easily define simple models that can be easily serialized and de-serialized.
+test_files:
+- spec/hashme/attributes_spec.rb
+- spec/hashme/base_spec.rb
+- spec/hashme/casted_array_spec.rb
+- spec/hashme/properties_spec.rb
+- spec/hashme/property_spec.rb
+- spec/spec_helper.rb