bodhi-slam 0.0.5 → 0.1.0

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA1:
-  metadata.gz: 74f006a6012ceaab5f918a7b6832a832d1dbf9b4
-  data.tar.gz: fe5a4a8bdc2c6e803ef560f892fa60a56ab3b79b
+  metadata.gz: 9ca91de0d49a0aa3ff8e084024cdc6114444814e
+  data.tar.gz: a7d550040d2b4e705ab10c7a0a6a8929aff7b967
 SHA512:
-  metadata.gz: 8ca2122a8f1ae97c087033e60d81befc12b3c90f2e7e34595e75cd1907e805192dde8c5eaf870738aa29db56b9c18939cd82eeae7c73193d879e194dab525b7a
-  data.tar.gz: 9db6d4a31a8893620aded4fb57dcc44b5589c5ae3e283b8d3bc34dd9a1b91bcaf84226998e05aa3d6db47afe7e230953a27020098ec74896b9238e8aa98f23f3
+  metadata.gz: 8e9231701b099974ee34f0708740e3882743677861153b82a0c996e218b9be6b66fbb638248af82a204abc1b2ffd7bbaa1a8b7055c78b62dc208203f2d8fe058
+  data.tar.gz: a4cc9b671833cf91bb0524d5bc4bd608a33d276f8f7aaa5e93eb00c86f853595675bfd366380704bb59f80a195829358458e7e9a482924d1aed6c7d6fc7be420

data/lib/bodhi-slam.rb

@@ -1,4 +1,5 @@
 require "faraday"
+require 'net/http/persistent'
 require "factory_girl"
 require "json"
 require "time"
@@ -6,10 +7,13 @@ require "time"
 require 'bodhi-slam/context'
 require 'bodhi-slam/errors'
 require 'bodhi-slam/resource'
+require 'bodhi-slam/types'
+require 'bodhi-slam/validations'
+require 'bodhi-slam/enumerations'
 
 class BodhiSlam
   def self.context(params, &block)
-    bodhi_context = BodhiContext.new params
+    bodhi_context = Bodhi::Context.new params
     raise bodhi_context.errors unless bodhi_context.valid?
 
     #puts "Switching context to: #{bodhi_context.attributes}"
@@ -19,116 +23,16 @@ class BodhiSlam
   
   def self.analyze(context)
     raise context.errors unless context.valid?
-
-    #Get the types for this namespace
-    result = context.connection.get do |request|
-      request.url "/#{context.namespace}/types"
-      request.headers[context.credentials_header] = context.credentials
-    end
-    
-    if result.status != 200
-      errors = JSON.parse result.body
-      errors.each{|error| error['status'] = result.status } if errors.is_a? Array
-      errors["status"] = result.status if errors.is_a? Hash
-      raise errors.to_s
-    end
-    types = JSON.parse(result.body)
-    
-    #Get the enumerations for this namespace
-    result = context.connection.get do |request|
-      request.url "/#{context.namespace}/enums"
-      request.headers[context.credentials_header] = context.credentials
-    end
-    
-    if result.status != 200
-      errors = JSON.parse result.body
-      errors.each{|error| error['status'] = result.status } if errors.is_a? Array
-      errors["status"] = result.status if errors.is_a? Hash
-      raise errors.to_s
-    end
-    enumerations = JSON.parse(result.body)
-    
-    embedded_types = types.select{ |type| type["embedded"] }
-    normal_types = types.select{ |type| !type["embedded"] }
-    
-    embedded_types.each{ |type| create_type(type, enumerations) }
-    normal_types.each{ |type| create_type(type, enumerations) }
     
-    #Party!
-  end
-  
-  # - Create a BodhiResource from the given type definition and enumerations
-  def self.create_type(type, enumerations)
-    if type["package"] != "system"
-      properties = type["properties"].keys.collect{ |key| key.to_sym }
-      klass = Object.const_set(type["name"], Class.new {
-        include BodhiResource
-        attr_accessor *properties
-      })
-      klass.define_singleton_method(:find) do |id, context|
-        result = context.connection.get do |request|
-          request.url "/#{context.namespace}/resources/#{klass.name}/#{id}"
-          request.headers[context.credentials_header] = context.credentials
-        end
-
-        if result.status != 200
-          errors = JSON.parse result.body
-          errors.each{|error| error['status'] = result.status } if errors.is_a? Array
-          errors["status"] = result.status if errors.is_a? Hash
-          raise errors.to_s
-        end
+    all_types = Bodhi::Type.find_all(context)
+    all_enums = Bodhi::Enumeration.find_all(context)
+    klasses = all_types.collect{ |type| Bodhi::Type.create_class_with(type) }
 
-        object_hash = JSON.parse(result.body)
-        object_hash["bodhi_context"] = context
-        return FactoryGirl.build(klass.name, object_hash)
-      end
+    embedded_types = all_types.select{ |type| type.embedded }
+    normal_types = all_types.select{ |type| !type.embedded }
 
-      create_factory(klass.name, type["properties"], enumerations) unless FactoryGirl.factories.registered?(klass.name)
-      puts "Created Class & Factory for: #{klass.name}"
-    end
-  end
-  
-  # - Create a Factory with the given name, properties, and available enumerations
-  def self.create_factory(name, properties, enumerations)
-    FactoryGirl.define do
-      factory name.to_sym do
-        properties.each_pair do |k,v|
-          unless v["system"]
-            
-            case v["type"]
-            when "GeoJSON"
-              send(k) { {type: "Point", coordinates: [10,20]} } if v["multi"].nil?
-              send(k) { [*0..5].sample.times.collect{ {type: "Point", coordinates: [10,20]} } } if v["multi"]
-            when "Boolean"
-              send(k) { [true, false].sample } if v["multi"].nil?
-              send(k) { [*0..5].sample.times.collect{ [true, false].sample } } if v["multi"]
-            when "Enumerated"
-              enum = enumerations.select{ |enumeration| enumeration["name"] == v["ref"].split('.')[0] }[0]
-              send(k) { enum["values"].sample[v["ref"].split('.')[1]] } if v["multi"].nil?
-              send(k) { [*0..5].sample.times.collect{ enum["values"].sample[v["ref"].split('.')[1]] } } if v["multi"]
-            when "Object"
-              send(k) { {"foo" => SecureRandom.hex} } if v["multi"].nil?
-              send(k) { [*0..5].sample.times.collect{ {"foo" => SecureRandom.hex} } } if v["multi"]
-            when "String"
-              send(k) { SecureRandom.hex } if v["multi"].nil?
-              send(k) { [*0..5].sample.times.collect{ SecureRandom.hex } } if v["multi"]
-            when "DateTime"
-              send(k) { Time.at(rand * Time.now.to_i).iso8601 } if v["multi"].nil?
-              send(k) { [*0..5].sample.times.collect{ Time.at(rand * Time.now.to_i).iso8601 } } if v["multi"]
-            when "Integer"
-              send(k) { SecureRandom.random_number(100) } if v["multi"].nil?
-              send(k) { [*0..5].sample.times.collect{ SecureRandom.random_number(100) } } if v["multi"]
-            when "Real"
-              send(k) { SecureRandom.random_number } if v["multi"].nil?
-              send(k) { [*0..5].sample.times.collect{ SecureRandom.random_number } } if v["multi"]
-            else # Its an embedded type
-              send(k) { FactoryGirl.build(v["type"]).attributes } if v["multi"].nil?
-              send(k) { [*0..5].sample.times.collect{ FactoryGirl.build(v["type"]).attributes } } if v["multi"]
-            end
-            
-          end
-        end
-      end
-    end
+    embedded_factories = embedded_types.each{ |type| Bodhi::Type.create_factory_with(type) }
+    normal_factories = normal_types.each{ |type| Bodhi::Type.create_factory_with(type) }
+    klasses
   end
 end

data/lib/bodhi-slam/context.rb

@@ -1,59 +1,45 @@
-class BodhiContext
-  attr_reader :errors, :connection, :server, :namespace, 
-    :credentials, :credentials_type, :credentials_header
+require 'bodhi-slam/validations'
 
-  def initialize(params)
-    params.symbolize_keys!
+module Bodhi
+  class Context
+    include Bodhi::Validations
+    attr_reader :connection, :server, :namespace, 
+      :credentials, :credentials_type, :credentials_header
     
-    @connection = Faraday.new(url: params[:server]) do |faraday|
-      faraday.request  :url_encoded             # form-encode POST params
-      #faraday.response :logger                  # log requests to STDOUT
-      faraday.adapter  Faraday.default_adapter  # make requests with Net::HTTP
-    end
-    @server = params[:server]
-    @namespace = params[:namespace]
-    
-    if params[:cookie]
-      @credentials = params[:cookie]
-      @credentials_header = "Cookie"
-      @credentials_type = "HTTP_COOKIE"
-    else
-      @credentials = @connection.basic_auth params[:username], params[:password]
-      @credentials_header = "Authorization"
-      @credentials_type = "HTTP_BASIC"
-    end
+      validates :server, required: true, is_not_blank: true, url: true
+      validates :namespace, required: true, is_not_blank: true
     
-    @errors = Bodhi::Errors.new
-  end
-  
-  def attributes
-    attributes = Hash.new
-    self.instance_variables.each do |variable|
-      attribute_name = variable.to_s.delete('@').to_sym
-      attributes[attribute_name] = send(attribute_name)
-    end
-    attributes
-  end
-  
-  # - Runs all the specified validations and returns true if no errors were added otherwise false.
-  def valid?
-    errors.add(:server, "must be present") if server.nil?
-    errors.add(:server, "must be a string") unless server.is_a? String
+    def initialize(params)
+      params.symbolize_keys!
     
-    errors.add(:namespace, "must be present") if namespace.nil?
-    errors.add(:namespace, "must be a string") unless namespace.is_a? String
+      @connection = Faraday.new(url: params[:server]) do |faraday|
+        faraday.request  :url_encoded             # form-encode POST params
+        #faraday.response :logger                  # log requests to STDOUT
+        #faraday.adapter  Faraday.default_adapter  # make requests with Net::HTTP
+        faraday.adapter :net_http_persistent
+      end
+      @server = params[:server]
+      @namespace = params[:namespace]
     
-    return !errors.messages.any?
-  end
+      if params[:cookie]
+        @credentials = params[:cookie]
+        @credentials_header = "Cookie"
+        @credentials_type = "HTTP_COOKIE"
+      else
+        @credentials = @connection.basic_auth params[:username], params[:password]
+        @credentials_header = "Authorization"
+        @credentials_type = "HTTP_BASIC"
+      end
+    end
   
-  # - Performs the opposite of valid?. Returns true if errors were added, false otherwise.
-  def invalid?
-    errors.add(:server, "must be present") if server.nil?
-    errors.add(:server, "must be a string") unless server.is_a? String
-    
-    errors.add(:namespace, "must be present") if namespace.nil?
-    errors.add(:namespace, "must be a string") unless namespace.is_a? String
-    
-    return errors.messages.any?
+    def attributes
+      attributes = Hash.new
+      self.instance_variables.each do |variable|
+        attribute_name = variable.to_s.delete('@').to_sym
+        attributes[attribute_name] = send(attribute_name)
+      end
+      attributes
+    end
+
   end
 end

data/lib/bodhi-slam/enumerations.rb

@@ -0,0 +1,35 @@
+module Bodhi
+  class Enumeration
+    attr_reader :name, :values
+    
+    def initialize(params={})
+      params.symbolize_keys!
+      
+      @name = params[:name]
+      @values = params[:values]
+      self.class.cache[@name.to_sym] = self
+    end
+    
+    def self.find_all(context)
+      raise context.errors unless context.valid?
+      
+      result = context.connection.get do |request|
+        request.url "/#{context.namespace}/enums"
+        request.headers[context.credentials_header] = context.credentials
+      end
+    
+      if result.status != 200
+        errors = JSON.parse result.body
+        errors.each{|error| error['status'] = result.status } if errors.is_a? Array
+        errors["status"] = result.status if errors.is_a? Hash
+        raise errors.to_s
+      end
+    
+      JSON.parse(result.body).collect{ |enum| Bodhi::Enumeration.new(enum) }
+    end
+
+    def self.cache
+      @cache ||= Hash.new
+    end
+  end
+end

data/lib/bodhi-slam/errors.rb

@@ -1,24 +1,101 @@
 module Bodhi
   class Errors < Exception
+    include Enumerable
     attr_accessor :messages
     
     def initialize(errors={})
       @messages = errors
     end
-
-    def add(symbol, msg)
-      @messages[symbol] = [] unless @messages.has_key?(symbol)
-      @messages[symbol].push(msg)
+    
+    # Adds the given +message+ to the errors hash under the +name+ key
+    #
+    # user.errors.add(:test, "has bad value")
+    # user.errors.any?  # => true
+    def add(name, message)
+      @messages.has_key?(name) ? @messages[name].push(message) : @messages[name] = [message]
     end
     
+    # Clears all error messages
+    #
+    # user.errors.add(:name, "is wrong")
+    # user.errors.clear # => nil
+    # user.errors.any?  # => false
     def clear
       @messages.clear
     end
     
+    # Returns an array of all error messages
     def full_messages
       results = []
       @messages.each{ |key, values| values.each{ |value| results.push("#{key} #{value}") }}
       results
     end
+    alias :to_a :full_messages
+    
+    # Converts the messages hash to json
+    def to_json
+      @messages.to_json
+    end
+    
+    # Iterates through each error key, value pair in the error messages hash.
+    # Yields the attribute and the error for that attribute. If the attribute
+    # has more than one error message, yields once for each error message.
+    # 
+    # user.errors.add(:test, "is required")
+    # user.errors.each do |attribute, error|
+    #   # yields :test and "is required"
+    # end
+    # 
+    # user.errors.add(:foo, "is awesome!")
+    # user.errors.each do |attribute, error|
+    #   # yields :test and "is required"
+    #   # then yields :foo and "is awesome!"
+    # end
+    def each
+      @messages.each_key do |attribute|
+        @messages[attribute].each{ |error| yield attribute, error }
+      end
+    end
+    
+    # Returns +true+ if the error messages include an error for the given key
+    # +attribute+, +false+ otherwise.
+    #
+    #   user.errors.messages        # => {:name=>["is required"]}
+    #   user.errors.include?(:name) # => true
+    #   user.errors.include?(:foo)  # => false
+    def include?(attribute)
+      !@messages[attribute].nil?
+    end
+    alias :has_key? :include?
+    alias :key? :include?
+    
+    # When passed a symbol or a name of a method, returns an array of errors
+    # for the method.
+    #
+    #   user.errors[:name]  # => ["is required"]
+    #   user.errors['name'] # => ["is required"]
+    def [](attribute)
+      @messages[attribute.to_sym]
+    end
+    
+    # Returns the number of error messages.
+    #
+    #   user.errors.add(:name, "is required")
+    #   user.errors.size # => 1
+    #   user.errors.add(:name, "can not be blank")
+    #   user.errors.size # => 2
+    def size
+      full_messages.size
+    end
+    alias :count :size
+    
+    # Returns +true+ if no errors are present, +false+ otherwise.
+    #
+    # user.errors.add(:name, "test error")
+    # user.errors.empty?  # => false
+    def empty?
+      size == 0
+    end
+    alias :blank? :empty?
   end
 end

data/lib/bodhi-slam/resource.rb

@@ -1,75 +1,212 @@
-module BodhiResource
-  SYSTEM_ATTRIBUTES = [:bodhi_context, :sys_created_at, :sys_version, :sys_modified_at, :sys_modified_by,
-    :sys_namespace, :sys_created_by, :sys_type_version, :sys_id]
-  attr_accessor *SYSTEM_ATTRIBUTES
-  
-  # - Returns a Hash of the Objects form attributes
-  def attributes
-    attributes = Hash.new
-    self.instance_variables.each do |variable|
-      attribute_name = variable.to_s.delete('@').to_sym
-      attributes[attribute_name] = send(attribute_name) unless SYSTEM_ATTRIBUTES.include?(attribute_name)
+module Bodhi
+  module Resource
+    SYSTEM_ATTRIBUTES = [:bodhi_context, :sys_created_at, :sys_version, :sys_modified_at, :sys_modified_by,
+      :sys_namespace, :sys_created_by, :sys_type_version, :sys_id]
+    attr_accessor *SYSTEM_ATTRIBUTES
+
+    module ClassMethods
+      def build(context, params={})
+        params.merge!({bodhi_context: context})
+        FactoryGirl.build(name, params)
+      end
+
+      def build_list(context, amount, params={})
+        params.merge!({bodhi_context: context})
+        FactoryGirl.build_list(name, amount, params)
+      end
+
+      def create(context, params={})
+        params.merge!({bodhi_context: context})
+        FactoryGirl.create(name, params)
+      end
+
+      def create_list(context, amount, params={})
+        params.merge!({bodhi_context: context})
+        records = FactoryGirl.build_list(name, amount, params)
+        result = context.connection.post do |request|
+          request.url "/#{context.namespace}/resources/#{name}"
+          request.headers['Content-Type'] = 'application/json'
+          request.headers[context.credentials_header] = context.credentials
+          request.body = records.to_json
+        end
+
+        #puts "\033[33mResult Body\033[0m: \033[36m#{result.body}\033[0m"
+
+        if result.status != 200
+          errors = JSON.parse result.body
+          errors.each{|error| error['status'] = result.status } if errors.is_a? Array
+          errors["status"] = result.status if errors.is_a? Hash
+          raise errors.to_s
+        end
+
+        #puts "\033[33mRecords\033[0m: \033[36m#{records.map(&:attributes)}\033[0m"
+
+        records
+      end
+
+      def find(context, id)
+        raise context.errors unless context.valid?
+
+        unless id.is_a? String
+          raise ArgumentError.new("Expected 'id' to be a String. 'id' #=> #{id.class}")
+        end
+
+        result = context.connection.get do |request|
+          request.url "/#{context.namespace}/resources/#{name}/#{id}"
+          request.headers[context.credentials_header] = context.credentials
+        end
+
+        if result.status != 200
+          errors = JSON.parse result.body
+          errors.each{|error| error['status'] = result.status } if errors.is_a? Array
+          errors["status"] = result.status if errors.is_a? Hash
+          raise errors.to_s
+        end
+
+        resource_attributes = JSON.parse(result.body)
+        self.build(context, resource_attributes)
+      end
+
+      def aggregate(context, pipeline)
+        raise context.errors unless context.valid?
+
+        unless pipeline.is_a? String
+          raise ArgumentError.new("Expected 'pipeline' to be a String. 'pipeline' #=> #{pipeline.class}")
+        end
+
+        result = context.connection.get do |request|
+          request.url "/#{context.namespace}/resources/#{name}/aggregate?pipeline=#{pipeline}"
+          request.headers[context.credentials_header] = context.credentials
+        end
+
+        if result.status != 200
+          errors = JSON.parse result.body
+          errors.each{|error| error['status'] = result.status } if errors.is_a? Array
+          errors["status"] = result.status if errors.is_a? Hash
+          raise errors.to_s
+        end
+
+        JSON.parse(result.body)
+      end
+
+      def where(context, query)
+        raise context.errors unless context.valid?
+
+        unless query.is_a? String
+          raise ArgumentError.new("Expected 'query' to be a String. 'query' #=> #{query.class}")
+        end
+
+        result = context.connection.get do |request|
+          request.url "/#{context.namespace}/resources/#{name}?where=#{query}"
+          request.headers[context.credentials_header] = context.credentials
+        end
+
+        if result.status != 200
+          errors = JSON.parse result.body
+          errors.each{|error| error['status'] = result.status } if errors.is_a? Array
+          errors["status"] = result.status if errors.is_a? Hash
+          raise errors.to_s
+        end
+
+        resources = JSON.parse(result.body)
+        resources.map{ |attributes| self.build(context, attributes) }
+      end
+
+      def delete_all(context)
+        raise context.errors unless context.valid?
+
+        result = context.connection.delete do |request|
+          request.url "/#{context.namespace}/resources/#{name}"
+          request.headers[context.credentials_header] = context.credentials
+        end
+
+        if result.status != 204
+          errors = JSON.parse result.body
+          errors.each{|error| error['status'] = result.status } if errors.is_a? Array
+          errors["status"] = result.status if errors.is_a? Hash
+          raise errors.to_s
+        end
+      end
     end
-    attributes
-  end
+
+    module InstanceMethods
+      # Returns a Hash of the Objects form attributes
+      # 
+      # s = SomeResource.build({foo:"test", bar:12345})
+      # s.attributes # => { foo: "test", bar: 12345 }
+      def attributes
+        attributes = Hash.new
+        self.instance_variables.each do |variable|
+          attribute_name = variable.to_s.delete('@').to_sym
+          attributes[attribute_name] = send(attribute_name) unless SYSTEM_ATTRIBUTES.include?(attribute_name)
+        end
+        attributes
+      end
   
-  # - Converts all the Objects attributes to JSON
-  def to_json
-    attributes = Hash.new
-    self.instance_variables.each do |variable|
-      attribute_name = variable.to_s.delete('@').to_sym
-      attributes[attribute_name] = send(attribute_name)
-    end
-    attributes.to_json
-  end
+      # Returns all the Objects attributes as JSON.
+      # Will convert any nested Objects to JSON if they respond to :to_json
+      # 
+      # s = SomeResource.build({foo:"test", bar:12345})
+      # s.to_json # => { "foo":"test", "bar":12345 }
+      def to_json(base=nil)
+        super if base
+        attributes.to_json
+      end
 
-  def save!
-    result = bodhi_context.connection.post do |request|
-      request.url "/#{bodhi_context.namespace}/resources/#{self.class}"
-      request.headers['Content-Type'] = 'application/json'
-      request.headers[bodhi_context.credentials_header] = bodhi_context.credentials
-      request.body = attributes.to_json
-    end
+      def save!
+        result = bodhi_context.connection.post do |request|
+          request.url "/#{bodhi_context.namespace}/resources/#{self.class}"
+          request.headers['Content-Type'] = 'application/json'
+          request.headers[bodhi_context.credentials_header] = bodhi_context.credentials
+          request.body = attributes.to_json
+        end
   
-    if result.status != 201
-      errors = JSON.parse result.body
-      errors.each{|error| error['status'] = result.status } if errors.is_a? Array
-      errors["status"] = result.status if errors.is_a? Hash
-      raise errors.to_s
-    end
+        if result.status != 201
+          errors = JSON.parse result.body
+          errors.each{|error| error['status'] = result.status } if errors.is_a? Array
+          errors["status"] = result.status if errors.is_a? Hash
+          raise errors.to_s
+        end
+
+        if result.headers['location']
+          @sys_id = result.headers['location'].match(/(?<id>[a-zA-Z0-9]{24})/)[:id]
+        end
+      end
+
+      def delete!
+        result = bodhi_context.connection.delete do |request|
+          request.url "/#{bodhi_context.namespace}/resources/#{self.class}/#{sys_id}"
+          request.headers[bodhi_context.credentials_header] = bodhi_context.credentials
+        end
   
-    if result.headers['location']
-      @sys_id = result.headers['location'].match(/(?<id>[a-zA-Z0-9]{8}-[a-zA-Z0-9]{4}-[a-zA-Z0-9]{4}-[a-zA-Z0-9]{4}-[a-zA-Z0-9]{12})/)[:id]
-    end
-  end
+        if result.status != 204
+          errors = JSON.parse result.body
+          errors.each{|error| error['status'] = result.status } if errors.is_a? Array
+          errors["status"] = result.status if errors.is_a? Hash
+          raise errors.to_s
+        end
+      end
 
-  def delete!
-    result = bodhi_context.connection.delete do |request|
-      request.url "/#{bodhi_context.namespace}/resources/#{self.class}/#{sys_id}"
-      request.headers[bodhi_context.credentials_header] = bodhi_context.credentials
-    end
+      def patch!(params)
+        result = bodhi_context.connection.patch do |request|
+          request.url "/#{bodhi_context.namespace}/resources/#{self.class}/#{sys_id}"
+          request.headers['Content-Type'] = 'application/json'
+          request.headers[bodhi_context.credentials_header] = bodhi_context.credentials
+          request.body = params
+        end
   
-    if result.status != 204
-      errors = JSON.parse result.body
-      errors.each{|error| error['status'] = result.status } if errors.is_a? Array
-      errors["status"] = result.status if errors.is_a? Hash
-      raise errors.to_s
+        if result.status != 204
+          errors = JSON.parse result.body
+          errors.each{|error| error['status'] = result.status } if errors.is_a? Array
+          errors["status"] = result.status if errors.is_a? Hash
+          raise errors.to_s
+        end
+      end
     end
-  end
 
-  def patch!(params)
-    result = bodhi_context.connection.patch do |request|
-      request.url "/#{bodhi_context.namespace}/resources/#{self.class}/#{sys_id}"
-      request.headers['Content-Type'] = 'application/json'
-      request.headers[bodhi_context.credentials_header] = bodhi_context.credentials
-      request.body = params
+    def self.included(base)
+      base.extend(ClassMethods)
+      base.include(InstanceMethods, Bodhi::Validations)
     end
-  
-    if result.status != 204
-      errors = JSON.parse result.body
-      errors.each{|error| error['status'] = result.status } if errors.is_a? Array
-      errors["status"] = result.status if errors.is_a? Hash
-      raise errors.to_s
-    end
-  end  
+  end
 end