betty_resource 0.0.7

data/.gitignore

@@ -0,0 +1,8 @@
+.DS_Store
+.bundle
+.rvmrc
+*.gem
+coverage/*
+pkg/*
+Gemfile.lock
+.credentials

data/CHANGELOG.rdoc

@@ -0,0 +1,16 @@
+= BettyResource CHANGELOG
+
+=== Version 0.0.5 / 2012-03-01
+
+* Created by Chiel
+
+=== Version 0.0.6 / 2013-01-22
+
+=== Version 0.0.7 / 2013-01-22
+
+* 5 improvements:
+
+  * Add changelog generation script
+  * Adjust author information
+  * Remove some sensitive details
+  * We have a hard dependency on multi_json

data/Gemfile

@@ -0,0 +1,15 @@
+source "https://rubygems.org"
+
+gemspec
+
+group :gem_default do
+  gem "betty_resource", :path => "."
+  gem "colorize"
+  gem "pry"
+end
+
+group :gem_test do
+  gem "minitest"
+  gem "mocha", :require => "mocha/setup"
+  gem "simplecov", ">= 0.4.0"
+end

data/README.md

@@ -0,0 +1,93 @@
+# BettyResource
+
+Map Betty5 application resources to Ruby objects through the JSON API!
+
+## Introduction
+
+This gem is created to map resources directly to the Betty5 API with ease. Just include the gem in your Gemfile, configure the Betty5 API credentials and your good to go!
+
+## Installation
+
+### Add `BettyResource` to your Gemfile
+
+    gem "betty_resource"
+
+### Install the gem dependencies
+
+    $ bundle
+
+### Configure the Betty5 API credentials
+
+At first, you will need to create a user within the Betty5 application provided with an `api_password`. Ask one of the BettyBlocks developers for more information.
+
+Afterwards, add the following in a Ruby file which gets required at startup of the application (e.g. within an `initializer`).
+
+    BettyResource.configure do |config|
+      config.host     = "https://<identifier>.bettyblocks.com"
+      config.user     = <user email>
+      config.password = <user api password>
+    end
+
+## Usage
+
+Using `BettyResource` is pretty straightforward. Let's say you want to load, edit and save a record of the `Relation` model with ID 1:
+
+    $ relation = BettyResource::Relation.get 1
+    $ relation.first_name = "Paul"
+    $ relation.save #=> true
+
+## Using the console
+
+The BettyResource repo is provided with `script/console` which you can use for development / testing purposes.
+
+Run the following command in your console:
+
+    $ script/console
+    Loading BettyResource development environment
+    Configured connection
+    [1] pry(main)> r = BettyResource::Relation.get 1
+    => #<Relation id: 1, last_name: "Willemse", first_name: "Daniel">
+    [2] pry(main)> r.dirty?
+    => false
+    [3] pry(main)> r.first_name = "Paul"
+    => "Paul"
+    [4] pry(main)> r.dirty?
+    => true
+    [5] pry(main)> r.changes
+    => {"first_name"=>["Daniel", "Paul"]}
+    [6] pry(main)> r.first_name_changed?
+    => true
+    [7] pry(main)> r.first_name_change
+    => ["Daniel", "Paul"]
+    [8] pry(main)> r.first_name_was
+    => "Daniel"
+    [9] pry(main)> r.save
+    => true
+    [10] pry(main)> r.dirty?
+    => false
+    [11] pry(main)> BettyResource::Relation.get(r.id).first_name
+    => "Paul"
+
+## Testing
+
+Run the following command for testing:
+
+    $ rake
+
+You can also run a single test:
+
+    $ ruby test/unit/model/test_record.rb
+
+## TODO
+
+* Typecasting of attributes
+
+## Contact us
+
+For support, remarks and requests, please mail us at [support@bettyblocks.com](mailto:support@bettyblocks.com).
+
+## License
+
+Copyright (c) 2013 BettyBlocks B.V.
+
+[http://bettyblocks.com](http://bettyblocks.com) - [info@bettyblocks.com](mailto:info@bettyblocks.com)

data/Rakefile

@@ -0,0 +1,77 @@
+require "bundler/gem_tasks"
+require "rake/testtask"
+
+task :default => :test
+
+Rake::TestTask.new do |t|
+  t.test_files = FileList["test/**/test_*.rb"]
+end
+
+desc "Changelog"
+task :changelog do
+  tag   = ENV["FROM"] || `git describe --abbrev=0 --tags`.strip
+  range = [tag, "HEAD"].compact.join ".."
+  cmd   = "git log --no-merges #{range} '--format=tformat:%B|||%aN|||%aE|||'"
+  now   = Time.new.strftime "%Y-%m-%d"
+
+  changes = `#{cmd}`.split(/\|\|\|/).each_slice(3).map do |msg, author, email|
+    msg.split(/\n/).reject { |s| s.empty? }
+  end
+
+  changes = changes.flatten
+
+  next if changes.empty?
+
+  $changes = Hash.new { |h,k| h[k] = [] }
+
+  codes = {
+    "!" => :major,
+    "+" => :minor,
+    "*" => :minor,
+    "-" => :bug,
+    "?" => :unknown,
+  }
+
+  codes_re = Regexp.escape codes.keys.join
+
+  changes.each do |change|
+    if change =~ /^\s*([#{codes_re}])\s*(.*)/ then
+      code, line = codes[$1], $2
+    else
+      code, line = codes["?"], change.chomp
+    end
+
+    $changes[code] << line
+  end
+
+  puts "=== #{ENV['VERSION'] || 'NEXT'} / #{now}"
+  puts
+  changelog_section :major
+  changelog_section :minor
+  changelog_section :bug
+  changelog_section :unknown
+  puts
+end
+
+def changelog_section code
+  name = {
+    :major   => "major enhancement",
+    :minor   => "minor enhancement",
+    :bug     => "bug fix",
+    :unknown => "unknown",
+  }[code]
+
+  changes = $changes[code]
+  count = changes.size
+  name += "s" if count > 1
+  name.sub!(/fixs/, 'fixes')
+
+  return if count < 1
+
+  puts "* #{count} #{name}:"
+  puts
+  changes.sort.each do |line|
+    puts "  * #{line}"
+  end
+  puts
+end

data/betty_resource.gemspec

@@ -0,0 +1,27 @@
+# -*- encoding: utf-8 -*-
+lib = File.expand_path('../lib', __FILE__)
+$LOAD_PATH.unshift(lib) unless $LOAD_PATH.include?(lib)
+require 'betty_resource/version'
+
+Gem::Specification.new do |gem|
+  gem.name        = "betty_resource"
+  gem.version     = BettyResource::VERSION
+  gem.authors     = ["Chiel Wester", "Stephan Kaag", "Daniel Willemse", "Paul Engel"]
+  gem.email       = ["chiel.wester@holder.nl", "stephan.kaag@bettyblocks.com", "daniel.willemse@holder.nl", "paul.engel@bettyblocks.com"]
+  gem.description = %q{Map Betty5 application resources to Ruby objects through the JSON API}
+  gem.summary     = %q{Map Betty5 application resources to Ruby objects}
+  gem.homepage    = "https://github.com/bettyblocks/betty_resource"
+
+  gem.files       = `git ls-files`.split($/)
+  gem.executables = gem.files.grep(%r{^bin/}).map{ |f| File.basename(f) }
+  gem.test_files  = gem.files.grep(%r{^(test|spec|features)/})
+  gem.require_paths = ["lib"]
+  gem.platform    = Gem::Platform::RUBY
+
+  gem.add_dependency "httparty"
+  gem.add_dependency "activesupport"
+  gem.add_dependency "crack"
+  gem.add_dependency "dirty_hashy", "0.1.3"
+  gem.add_dependency "multi_json"
+  gem.add_development_dependency "minitest"
+end

data/lib/betty_resource/api.rb

@@ -0,0 +1,10 @@
+module BettyResource
+  class Api
+    include HTTParty
+
+    base_uri "#{BettyResource.config.host}/api"
+    format :json
+    basic_auth BettyResource.config.user, BettyResource.config.password
+
+  end
+end

data/lib/betty_resource/configuration.rb

@@ -0,0 +1,20 @@
+require "singleton"
+
+module BettyResource
+  class Configuration
+    def initialize(args = {})
+      args.each do |key, value|
+        self.send("#{key}=", value) if [:host, :user, :password].include?(key.to_sym)
+      end
+    end
+
+    class InvalidError < StandardError; end
+
+    attr_accessor :host, :user, :password
+
+    def validate!
+      raise InvalidError if [:host, :user, :password].any?{|option| send(option).to_s.strip.empty?}
+    end
+
+  end
+end

data/lib/betty_resource/meta_data.rb

@@ -0,0 +1,13 @@
+module BettyResource
+  class MetaData
+
+    def models
+      @models ||= BettyResource::Model.parse(Api.get("/models").parsed_response)
+    end
+
+    def model(name)
+      models[name.to_s]
+    end
+
+  end
+end

data/lib/betty_resource/model/property.rb

@@ -0,0 +1,23 @@
+module BettyResource
+  class Model
+    class Property
+      attr_accessor :id, :name, :kind, :options
+
+      def self.parse(input)
+        input.collect do |row|
+          Property.new(row["id"], row["name"], row["kind"], row["options"])
+        end
+      end
+
+      def initialize(id, name, kind, options)
+        @id, @name, @kind, @options = id, name, kind, options
+      end
+
+      # TODO: Clean this up as this is a dirty quick fix for loading belongs_to properties at the moment
+      def model
+        BettyResource.meta_data.models.values.detect{|x| x.id == options["model"]} if kind == "belongs_to"
+      end
+
+    end
+  end
+end

data/lib/betty_resource/model/record.rb

@@ -0,0 +1,101 @@
+module BettyResource
+  class Model
+    class Record
+
+      include DirtyAttributes::InstanceMethods
+      include MethodMap
+      attr_reader :id, :model
+
+      alias :_class :class
+      def class
+        model
+      end
+
+      def initialize(model, attributes = {})
+        @model = model
+        @id = attributes.delete(:id) || attributes.delete("id")
+        @errors = {}
+        super()
+        self.attributes = Hash[model.attributes.collect{|x| [x, nil]}].merge attributes
+      end
+
+      def new_record?
+        @id.nil?
+      end
+
+      # TODO: Test this
+      def attributes=(other)
+        other.each do |key, value|
+          send "#{key}=", value
+        end
+      end
+
+      def errors
+        @errors.dup
+      end
+
+      def save
+        @errors.clear
+
+        result = begin
+          if new_record?
+            Api.post("/models/#{model.id}/records/new", to_params)
+          else
+            Api.put("/models/#{model.id}/records/#{id}", to_params)
+          end
+        end
+
+        (result.code.to_s[0..1] == "20").tap do |success|
+          if success
+            model.send :load, result.parsed_response, self
+          else
+            @errors = result.parsed_response ? result.parsed_response["errors"] : {"" => ["Er is iets mis gegaan met het verwerken van het formulier. Probeer u het later nog eens. Onze excuses voor het ongemak"]}
+          end
+        end
+      end
+
+      def inspect
+        inspection = "id: #{id.inspect}, #{attributes.collect{|key, value| "#{key}: #{value.inspect}"}.join(", ")}"
+        "#<#{model.name} #{inspection}>"
+      end
+      alias :to_s :inspect
+
+      # TODO: Test this update
+      def as_json(options = {})
+        attributes_as_json(options).merge! "id" => id
+      end
+
+    private
+
+      # TODO: Clean this mess up as this is a dirty quick fix for loading belongs_to properties at the moment
+      def method_missing(method, *args)
+        if method.to_s.match(/^(\w+).id=$/)
+          if model.attributes.include?($1)
+            instance = attributes[$1] ||= begin
+              if property = model.properties.detect{|x| x.name == $1}
+                property.model.new
+              end
+            end
+            if instance
+              return instance.instance_variable_set :@id, args.first
+            end
+          end
+        end
+        super
+      end
+
+      def to_params
+        {:body => {:record => attributes_as_json}}
+      end
+
+      # TODO: Test this update
+      def attributes_as_json(options = {})
+        attributes.inject({}) do |h, (k, v)|
+          h.merge! k => (v.respond_to?(:as_json) ? v.as_json(options) : v) if v
+          h
+        end
+      end
+
+    end
+  end
+end

data/lib/betty_resource/model.rb

@@ -0,0 +1,68 @@
+module BettyResource
+  class Model
+    autoload :Record, "betty_resource/model/record"
+    autoload :Property, "betty_resource/model/property"
+
+    attr_accessor :id, :name, :properties
+
+    def self.parse(input)
+      input.inject({}) do |hash, row|
+        hash.merge(row["name"] => Model.new(row["id"], row["name"], Property.parse(row["properties"])))
+      end
+    end
+
+    def initialize(id, name, properties = [])
+      @id, @name, @properties = id, name, properties
+    end
+
+    def attributes
+      properties.collect(&:name)
+    end
+
+    # TODO: Refactor this method in order to handle formatted view JSON correctly
+    def all(options = {})
+      begin
+        response = Api.get("/models/#{id}/records", :body => options).parsed_response
+        ((view_id = options.delete(:view_id) || options.delete("view_id")).nil? ? response : response["records"]).collect do |data|
+          load data
+        end
+      rescue MultiJson::DecodeError
+      end
+    end
+
+    def get(record_id)
+      begin
+        load Api.get("/models/#{id}/records/#{record_id}").parsed_response
+      rescue MultiJson::DecodeError
+      end
+    end
+
+    def new(attributes = {})
+      BettyResource::Model::Record.new(self, attributes)
+    end
+
+    def create(attributes = {})
+      new(attributes).tap do |record|
+        record.save
+      end
+    end
+
+    def to_s
+      name
+    end
+
+  private
+
+    def load(data, record = nil)
+      if data
+        id = data.delete "id"
+        (record || BettyResource::Model::Record.new(self)).tap do |record|
+          record.instance_variable_set :@id, id
+          record.attributes = data
+          record.clean_up!
+        end
+      end
+    end
+
+  end
+end

data/lib/betty_resource/version.rb

@@ -0,0 +1,7 @@
+module BettyResource
+  MAJOR = 0
+  MINOR = 0
+  TINY  = 7
+
+  VERSION = [MAJOR, MINOR, TINY].join(".")
+end

data/lib/betty_resource.rb

@@ -0,0 +1,39 @@
+require "active_support/core_ext/hash/indifferent_access" # See https://gist.github.com/1075643
+
+require "httparty"
+require "crack/json"
+require "dirty_hashy"
+
+module BettyResource
+  autoload :Api, "betty_resource/api"
+  autoload :Configuration, "betty_resource/configuration"
+  autoload :MetaData, "betty_resource/meta_data"
+  autoload :Model, "betty_resource/model"
+
+  def self.const_missing(name)
+    meta_data.model(name).tap do |model|
+       const_set(name, model)
+    end || super
+  end
+
+  def self.meta_data
+    @meta_data ||= MetaData.new
+  end
+
+  def self.config(validate = true)
+    (@configuration ||= Configuration.new).tap do |config|
+      config.validate! if validate
+    end
+  end
+
+  def self.configure(configuration = nil)
+    if configuration
+      @configuration = Configuration.new(configuration).tap do |config|
+        config.validate!
+      end
+    else
+      yield config(false)
+    end
+  end
+
+end

data/script/console

@@ -0,0 +1,11 @@
+#!/usr/bin/env ruby
+require "rubygems"
+require "bundler/setup"
+
+Bundler.require :gem_default
+
+BettyResource.configure(MultiJson.decode(File.read(File.expand_path('../../.credentials', __FILE__))))
+
+puts "Loading BettyResource development environment (#{BettyResource::VERSION})"
+puts "Configured connection with #{BettyResource.config.host}".yellow
+Pry.start

data/test/test_helper.rb

@@ -0,0 +1,18 @@
+ENV["RACK_ENV"] = "test"
+ENV["TESTOPTS"] = "-v"
+
+require "rubygems"
+require "bundler/setup"
+
+require "minitest/unit"
+require "minitest/autorun"
+
+require "simplecov"
+
+SimpleCov.start do
+  coverage_dir "coverage"
+  add_filter "/test/"
+end
+
+Bundler.require :gem_default, :gem_test
+BettyResource.configure(MultiJson.decode(File.read(File.expand_path('../../.credentials', __FILE__))))

data/test/unit/model/test_record.rb

@@ -0,0 +1,116 @@
+require_relative "../../test_helper"
+
+module Unit
+  module Record
+    class TestRecord < MiniTest::Unit::TestCase
+
+      describe BettyResource::Model::Record do
+        it "should return its model" do
+          assert_equal BettyResource::Relation, BettyResource::Relation.new.model
+          assert_equal BettyResource::Relation, BettyResource::Relation.new.class
+        end
+
+        it "should return its attributes" do
+          relation = BettyResource::Relation.new
+          assert_equal %w(first_name id last_name), relation.attributes.keys.sort
+        end
+
+        it "should create a method for writing each attribute" do
+          relation = BettyResource::Relation.new
+          assert relation.first_name = "my_first_name"
+          assert relation.last_name = "my_last_name"
+        end
+
+        it "should create a method for reading each attribute" do
+          relation = BettyResource::Relation.new
+          relation.first_name = "my_first_name"
+          assert_equal "my_first_name", relation.first_name
+        end
+
+        it "should store its values in the @attributes instance variable" do
+          relation = BettyResource::Relation.new
+          relation.first_name = "my_first_name"
+          assert_equal "my_first_name", relation.attributes[:first_name]
+        end
+
+        it "should allow mass-assignment when initializing" do
+          relation = BettyResource::Relation.new(:first_name => "my_first_name", :last_name => "my_last_name")
+          assert_equal "my_first_name", relation.first_name
+          assert_equal "my_last_name", relation.last_name
+        end
+
+        it "should allow mass-assignment when already initialized" do
+          relation = BettyResource::Relation.new
+          relation.attributes = {:first_name => "my_first_name", :last_name => "my_last_name"}
+          assert_equal "my_first_name", relation.first_name
+          assert_equal "my_last_name", relation.last_name
+        end
+
+        it "should not allow setting of id" do
+          relation = BettyResource::Relation.get(1)
+          assert_equal 1, relation.id
+          assert relation.id = 2
+          assert_equal 1, relation.id
+        end
+
+        it "should be able to represent itself as JSON" do
+          relation = BettyResource::Relation.new(:first_name => "Paul", :last_name => "Engel")
+          assert_equal({"id" => nil, "first_name" => "Paul", "last_name" => "Engel"}, relation.as_json)
+
+          relation = BettyResource::Relation.get(1)
+          assert_equal({"id" => 1, "first_name" => "Daniel", "last_name" => "Willemse"}, relation.as_json)
+        end
+
+        it "should save itself" do
+          relation = BettyResource::Relation.new(:first_name => "Stephan", :last_name => "Kaag")
+          assert relation.save
+          assert relation.id > 0
+
+          relation = BettyResource::Relation.get(relation.id)
+          assert_equal "Stephan", relation.first_name
+          assert_equal "Kaag", relation.last_name
+        end
+
+        it "should not save itself when invalid (first_name is required)" do
+          relation = BettyResource::Relation.new
+          assert !relation.save
+          assert_equal({"first_name"=>["is_required"]}, relation.errors)
+
+          relation.first_name = "Stephan"
+          assert relation.save
+        end
+
+        it "should have read-only errors messages" do
+          relation = BettyResource::Relation.create
+          assert_equal({"first_name"=>["is_required"]}, relation.errors)
+
+          relation.errors.clear
+          assert_equal({"first_name"=>["is_required"]}, relation.errors)
+        end
+
+        it "should not resave itself when invalid" do
+          relation = BettyResource::Relation.new :first_name => "Piet"
+          assert relation.save
+
+          relation.first_name = ""
+          assert !relation.save
+          assert relation.id > 0
+
+          assert_equal "Piet", BettyResource::Relation.get(relation.id).first_name
+        end
+
+        it "should update itself" do
+          relation = BettyResource::Relation.new(:first_name => "Stefan", :last_name => "Kaag")
+          relation.save
+
+          relation.first_name = "Stephan"
+          relation.save
+
+          relation = BettyResource::Relation.get(relation.id)
+          assert_equal "Stephan", relation.first_name
+        end
+      end
+
+    end
+  end
+end

data/test/unit/test_base.rb

@@ -0,0 +1,41 @@
+require_relative "../test_helper"
+
+module Unit
+  class TestBase < MiniTest::Unit::TestCase
+
+    describe BettyResource do
+      it "should validate its config" do
+        assert config = BettyResource.config
+
+        config.expects(:host).returns(nil)
+        assert_raises(BettyResource::Configuration::InvalidError) do
+          BettyResource.config
+        end
+
+        config.expects(:host).returns("")
+        assert_raises(BettyResource::Configuration::InvalidError) do
+          BettyResource.config
+        end
+
+        config.expects(:host).returns(" ")
+        assert_raises(BettyResource::Configuration::InvalidError) do
+          BettyResource.config
+        end
+
+        config.expects(:host).returns("localhost")
+        assert BettyResource.config
+      end
+
+      it "should return a model instance" do
+        assert BettyResource::Relation.is_a?(BettyResource::Model)
+      end
+
+      it "should raise NameError when an unknown model is requested" do
+        assert_raises(NameError) do
+          assert BettyResource::DoesNotExist
+        end
+      end
+    end
+
+  end
+end

data/test/unit/test_configuration.rb

@@ -0,0 +1,26 @@
+require_relative "../test_helper"
+
+module Unit
+  class TestBase < MiniTest::Unit::TestCase
+
+    describe BettyResource::Configuration do
+      it "should be able to validate itself" do
+        config = BettyResource::Configuration.new
+        assert_raises(BettyResource::Configuration::InvalidError) do
+          config.validate!
+        end
+
+        config.host = "localhost"
+        assert_raises(BettyResource::Configuration::InvalidError) do
+          config.validate!
+        end
+
+        config.host = "localhost"
+        config.user = "foo"
+        config.password = "bar"
+        assert_nil config.validate!
+      end
+    end
+
+  end
+end

data/test/unit/test_model.rb

@@ -0,0 +1,54 @@
+require_relative "../test_helper"
+
+module Unit
+  class TestModel < MiniTest::Unit::TestCase
+
+    describe BettyResource::Model do
+      it "should know its properties" do
+        assert BettyResource::Relation.properties.is_a?(Array)
+        assert BettyResource::Relation.properties.any?
+        assert BettyResource::Relation.properties[0].is_a?(BettyResource::Model::Property)
+      end
+
+      it "should know its attributes" do
+        assert_equal %w(first_name id last_name), BettyResource::Relation.attributes.sort
+      end
+
+      it "should return a new record instance" do
+        assert BettyResource::Relation.new.is_a?(BettyResource::Model::Record)
+      end
+
+      it "should not load unexisting records" do
+        assert_nil BettyResource::Relation.get(-1)
+      end
+
+      it "should fetch a record" do
+        relation = BettyResource::Relation.get(1)
+        assert_equal 1, relation.id
+        assert_equal "Daniel", relation.first_name
+        assert_equal "Willemse", relation.last_name
+      end
+
+      it "should fetch multiple records" do
+        relations = BettyResource::Relation.all
+        assert_equal 100, relations.size
+        assert relations.first.is_a?(BettyResource::Model::Record)
+
+        relations = BettyResource::Relation.all :limit => 10
+        assert_equal 10, relations.size
+        assert relations.first.is_a?(BettyResource::Model::Record)
+      end
+
+      it "should directly create a record" do
+        relation = BettyResource::Relation.create(:first_name => "Stephan", :last_name => "Kaag")
+        assert relation
+        assert relation.id > 0
+
+        relation = BettyResource::Relation.get(relation.id)
+        assert_equal "Stephan", relation.first_name
+        assert_equal "Kaag", relation.last_name
+      end
+    end
+
+  end
+end

metadata

@@ -0,0 +1,173 @@
+--- !ruby/object:Gem::Specification
+name: betty_resource
+version: !ruby/object:Gem::Version
+  version: 0.0.7
+  prerelease: 
+platform: ruby
+authors:
+- Chiel Wester
+- Stephan Kaag
+- Daniel Willemse
+- Paul Engel
+autorequire: 
+bindir: bin
+cert_chain: []
+date: 2013-01-22 00:00:00.000000000 Z
+dependencies:
+- !ruby/object:Gem::Dependency
+  name: httparty
+  requirement: !ruby/object:Gem::Requirement
+    none: false
+    requirements:
+    - - ! '>='
+      - !ruby/object:Gem::Version
+        version: '0'
+  type: :runtime
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    none: false
+    requirements:
+    - - ! '>='
+      - !ruby/object:Gem::Version
+        version: '0'
+- !ruby/object:Gem::Dependency
+  name: activesupport
+  requirement: !ruby/object:Gem::Requirement
+    none: false
+    requirements:
+    - - ! '>='
+      - !ruby/object:Gem::Version
+        version: '0'
+  type: :runtime
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    none: false
+    requirements:
+    - - ! '>='
+      - !ruby/object:Gem::Version
+        version: '0'
+- !ruby/object:Gem::Dependency
+  name: crack
+  requirement: !ruby/object:Gem::Requirement
+    none: false
+    requirements:
+    - - ! '>='
+      - !ruby/object:Gem::Version
+        version: '0'
+  type: :runtime
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    none: false
+    requirements:
+    - - ! '>='
+      - !ruby/object:Gem::Version
+        version: '0'
+- !ruby/object:Gem::Dependency
+  name: dirty_hashy
+  requirement: !ruby/object:Gem::Requirement
+    none: false
+    requirements:
+    - - '='
+      - !ruby/object:Gem::Version
+        version: 0.1.3
+  type: :runtime
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    none: false
+    requirements:
+    - - '='
+      - !ruby/object:Gem::Version
+        version: 0.1.3
+- !ruby/object:Gem::Dependency
+  name: multi_json
+  requirement: !ruby/object:Gem::Requirement
+    none: false
+    requirements:
+    - - ! '>='
+      - !ruby/object:Gem::Version
+        version: '0'
+  type: :runtime
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    none: false
+    requirements:
+    - - ! '>='
+      - !ruby/object:Gem::Version
+        version: '0'
+- !ruby/object:Gem::Dependency
+  name: minitest
+  requirement: !ruby/object:Gem::Requirement
+    none: false
+    requirements:
+    - - ! '>='
+      - !ruby/object:Gem::Version
+        version: '0'
+  type: :development
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    none: false
+    requirements:
+    - - ! '>='
+      - !ruby/object:Gem::Version
+        version: '0'
+description: Map Betty5 application resources to Ruby objects through the JSON API
+email:
+- chiel.wester@holder.nl
+- stephan.kaag@bettyblocks.com
+- daniel.willemse@holder.nl
+- paul.engel@bettyblocks.com
+executables: []
+extensions: []
+extra_rdoc_files: []
+files:
+- .gitignore
+- CHANGELOG.rdoc
+- Gemfile
+- README.md
+- Rakefile
+- betty_resource.gemspec
+- lib/betty_resource.rb
+- lib/betty_resource/api.rb
+- lib/betty_resource/configuration.rb
+- lib/betty_resource/meta_data.rb
+- lib/betty_resource/model.rb
+- lib/betty_resource/model/property.rb
+- lib/betty_resource/model/record.rb
+- lib/betty_resource/version.rb
+- script/console
+- test/test_helper.rb
+- test/unit/model/test_record.rb
+- test/unit/test_base.rb
+- test/unit/test_configuration.rb
+- test/unit/test_model.rb
+homepage: https://github.com/bettyblocks/betty_resource
+licenses: []
+post_install_message: 
+rdoc_options: []
+require_paths:
+- lib
+required_ruby_version: !ruby/object:Gem::Requirement
+  none: false
+  requirements:
+  - - ! '>='
+    - !ruby/object:Gem::Version
+      version: '0'
+required_rubygems_version: !ruby/object:Gem::Requirement
+  none: false
+  requirements:
+  - - ! '>='
+    - !ruby/object:Gem::Version
+      version: '0'
+requirements: []
+rubyforge_project: 
+rubygems_version: 1.8.24
+signing_key: 
+specification_version: 3
+summary: Map Betty5 application resources to Ruby objects
+test_files:
+- test/test_helper.rb
+- test/unit/model/test_record.rb
+- test/unit/test_base.rb
+- test/unit/test_configuration.rb
+- test/unit/test_model.rb
+has_rdoc: