bodhi-slam 0.4.1 → 0.5.0

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA1:
-  metadata.gz: 0787ec3a9705faa25dab09c506a0a220e8d7d9a8
-  data.tar.gz: 7e5686d4a4417d53c0743596ef2b9e758c878a7b
+  metadata.gz: 98cf6623880d11b702a150492d82187dd4cba869
+  data.tar.gz: f9f949910898bac2ac07517e412aa5825ba29d72
 SHA512:
-  metadata.gz: bea65f3aed37d29efd1ef2fff6ab918341037656b2db0720000fc35d5aaa2645f60acc77b86bdab2c9714b81bb209af68ee7d1678b4d3258e6c8e1b0a9c96d99
-  data.tar.gz: 623c0e593b4e1b465bd3a4b5ad4890618b7d8e841c031367b18ca3a7efb33901c60bdc6e8bfdbb8ffe5f139a7a0e715e17da48773f6a468ea607c604161440a9
+  metadata.gz: badc323a3402c4ae09b67aeb19e431857204f28b940ee24beacf58fd8284627f606ef3cd73f6d9e6d9f3f32f6a5df2a1264f72c65ed6742b3112539a67b02bee
+  data.tar.gz: 4b911fde1096640d8620f1ace4237b08c921db7284f3d2166f021efebe41e580fe53136a7f9aaf96066330b9128dbe19df61e1fb1e416aa8848c13ef4d555ddd

data/lib/bodhi-slam.rb

@@ -8,10 +8,15 @@ require "SecureRandom"
 require 'regexp-examples'
 require 'active_model'
 
+require 'bodhi-slam/support'
+
 require 'bodhi-slam/validations'
 require 'bodhi-slam/errors'
 require 'bodhi-slam/context'
 
+require 'bodhi-slam/properties'
+require 'bodhi-slam/indexes'
+
 require 'bodhi-slam/batches'
 require 'bodhi-slam/enumerations'
 require 'bodhi-slam/factory'

data/lib/bodhi-slam/errors/api.rb

@@ -6,5 +6,10 @@ module Bodhi
       @body = params[:body]
       @status = params[:status]
     end
+
+    def to_json
+      { status: @status, body: @body }.to_json
+    end
+    alias :to_s :to_json
   end
 end

data/lib/bodhi-slam/factory.rb

@@ -1,4 +1,18 @@
 module Bodhi
+  module Factories
+    module ClassMethods
+      def factory; @factory; end
+      def generates(name, options)
+        @factory.add_generator(name.to_sym, options)
+      end
+    end
+
+    def self.included(base)
+      base.extend(ClassMethods)
+      base.instance_variable_set(:@factory, Bodhi::Factory.new(base))
+    end
+  end
+
   class Factory
     attr_reader :klass
     attr_accessor :generators

data/lib/bodhi-slam/indexes.rb

@@ -0,0 +1,20 @@
+module Bodhi
+  module Indexes
+    module ClassMethods
+      def indexes; @indexes; end
+      def index(keys, options={})
+        # symbolize the option keys
+        options = options.reduce({}) do |memo, (k, v)| 
+          memo.merge({ k.to_sym => v})
+        end
+
+        @indexes << Bodhi::TypeIndex.new(keys: keys.map(&:to_s), options: options)
+      end
+    end
+
+    def self.included(base)
+      base.extend(ClassMethods)
+      base.instance_variable_set(:@indexes, Array.new)
+    end
+  end
+end

data/lib/bodhi-slam/profiles.rb

@@ -1,47 +1,44 @@
 module Bodhi
   class Profile
+    include Bodhi::Factories
+    include Bodhi::Properties
     include Bodhi::Validations
 
-    ATTRIBUTES = [:name, :namespace, :dml, :subspace, :parent]
-    attr_accessor *ATTRIBUTES
     attr_accessor :bodhi_context
 
+    property :name, :namespace, :dml, :subspace, :parent
+
     validates :name, type: "String", required: true, is_not_blank: true
     validates :namespace, type: "String", required: true
     validates :dml, type: "Object", required: true
 
-    def initialize(params={})
-      # same as symbolize_keys!
-      params = params.reduce({}) do |memo, (k, v)| 
-        memo.merge({ k.to_sym => v})
+    generates :name, type: "String", required: true, is_not_blank: true
+    generates :namespace, type: "String", required: true
+    generates :dml, type: "Object", required: true
+
+    # Queries the Bodhi API for the given +user_name+ and
+    # returns a Bodhi::Profile
+    # 
+    #   context = BodhiContext.new(valid_params)
+    #   profile = Bodhi::Profile.find(context, "Profile1")
+    #   profile # => #<Bodhi::Profile:0x007fbff403e808 @name="Profile1">
+    def self.find(context, profile_name)
+      if context.invalid?
+        raise Bodhi::ContextErrors.new(context.errors.messages), context.errors.to_a.to_s
       end
 
-      # set attributes
-      ATTRIBUTES.each do |attribute|
-        send("#{attribute}=", params[attribute])
+      result = context.connection.get do |request|
+        request.url "/#{context.namespace}/profiles/#{profile_name}"
+        request.headers[context.credentials_header] = context.credentials
       end
-    end
 
-    # Returns a Hash of the Objects form attributes
-    # 
-    #   s = SomeResource.factory.build({foo:"test", bar:12345})
-    #   s.attributes # => { foo: "test", bar: 12345 }
-    def attributes
-      result = Hash.new
-      ATTRIBUTES.each do |attribute|
-        result[attribute] = send(attribute)
+      if result.status != 200
+        raise Bodhi::ApiErrors.new(body: result.body, status: result.status), "status: #{result.status}, body: #{result.body}"
       end
-      result
-    end
 
-    # Returns all the Objects attributes as JSON.
-    # It converts any nested Objects to JSON if they respond to +to_json+
-    # 
-    #   s = SomeResource.factory.build({foo:"test", bar:12345})
-    #   s.to_json # => "{ 'foo':'test', 'bar':12345 }"
-    def to_json(base=nil)
-      super if base
-      attributes.to_json
+      profile = Bodhi::Profile.new(result.body)
+      profile.bodhi_context = context
+      profile
     end
 
     # Saves the resource to the Bodhi Cloud.  Raises ArgumentError if record could not be saved.
@@ -73,38 +70,5 @@ module Bodhi
       end
     end
 
-    # Returns a factory for the Bodhi::User class
-    def self.factory
-      @factory ||= Bodhi::Factory.new(Bodhi::Profile).tap do |factory|
-        factory.add_generator(:name, type: "String", required: true, is_not_blank: true)
-        factory.add_generator(:namespace, type: "String", required: true)
-        factory.add_generator(:dml, type: "Object", required: true)
-      end
-    end
-
-    # Queries the Bodhi API for the given +user_name+ and
-    # returns a Bodhi::Profile
-    # 
-    #   context = BodhiContext.new(valid_params)
-    #   profile = Bodhi::Profile.find(context, "Profile1")
-    #   profile # => #<Bodhi::Profile:0x007fbff403e808 @name="Profile1">
-    def self.find(context, profile_name)
-      if context.invalid?
-        raise Bodhi::ContextErrors.new(context.errors.messages), context.errors.to_a.to_s
-      end
-
-      result = context.connection.get do |request|
-        request.url "/#{context.namespace}/profiles/#{profile_name}"
-        request.headers[context.credentials_header] = context.credentials
-      end
-
-      if result.status != 200
-        raise Bodhi::ApiErrors.new(body: result.body, status: result.status), "status: #{result.status}, body: #{result.body}"
-      end
-
-      profile = Bodhi::Profile.new(result.body)
-      profile.bodhi_context = context
-      profile
-    end
   end
 end

data/lib/bodhi-slam/properties.rb

@@ -0,0 +1,84 @@
+module Bodhi
+  module Properties
+
+    SYSTEM_PROPERTIES = [:sys_created_at, :sys_version, :sys_modified_at, :sys_modified_by,
+      :sys_namespace, :sys_created_by, :sys_type_version, :sys_id, :sys_embeddedType]
+    attr_accessor *SYSTEM_PROPERTIES
+
+    module ClassMethods
+      def properties; @properties; end
+      def property(*names)
+        attr_accessor *names.map(&:to_sym)
+        @properties << names.map(&:to_sym)
+        @properties.flatten!
+      end
+    end
+
+    module InstanceMethods
+      def id; @sys_id; end
+      def persisted?; !@sys_id.nil?; end
+      def new_record?; @sys_id.nil?; end
+
+      # Initializes a new instance of the class.  Accepts a parameter Hash for mass assignment.
+      # If a parameter does not exist for the class, an UndefinedMethod error is raised.
+      #
+      #   klass = Class.new do
+      #     include Bodhi::Properties
+      #     property :name, :email
+      #   end
+      #
+      #   object = klass.new(name: "Bob", email: "some@email.com")
+      #   object.name #=> "Bob"
+      #   object.email #=> "some@email.com"
+      def initialize(params={})
+        params.each do |param_key, param_value|
+          send("#{param_key}=", param_value)
+        end
+      end
+
+      # Returns a Hash of the class properties and their values.
+      # 
+      #   object = SomeResource.new(foo:"test", bar:12345)
+      #   object.attributes # => { foo: "test", bar: 12345 }
+      def attributes
+        attributes = Hash.new
+        self.class.properties.each do |property|
+          attributes[property] = send(property)
+        end
+
+        attributes.delete_if { |k, v| v.nil? }
+        attributes
+      end
+
+      # Updates the resource with the given attributes Hash
+      # 
+      #   s = SomeResource.factory.build(foo:"test", bar:12345)
+      #   s.attributes # => { foo: "test", bar: 12345 }
+      #   s.update_attributes(bar: 10)
+      #   s.attributes # => { foo: "test", bar: 10 }
+      def update_attributes(params)
+        params.each do |param_key, param_value|
+          send("#{param_key}=", param_value)
+        end
+      end
+
+      # Returns all the classes properties as JSON.
+      # It converts any nested objects to JSON if they respond to +to_json+
+      # 
+      #   resource = SomeResource.new(foo:"test", bar:12345)
+      #   embedded_resources = AnotherResource.new( test: resource )
+      #   
+      #   resource.to_json # => "{ 'foo':'test', 'bar':12345 }"
+      #   embedded_resources.to_json # => "{ 'test': { 'foo':'test', 'bar':12345 } }"
+      def to_json(base=nil)
+        attributes.to_json
+      end
+    end
+
+    def self.included(base)
+      base.extend(ClassMethods)
+      base.include(InstanceMethods)
+      base.instance_variable_set(:@properties, Array.new)
+    end
+  end
+end

data/lib/bodhi-slam/resource.rb

@@ -1,14 +1,44 @@
 module Bodhi
   module Resource
 
-    SYSTEM_ATTRIBUTES = [:sys_created_at, :sys_version, :sys_modified_at, :sys_modified_by,
-      :sys_namespace, :sys_created_by, :sys_type_version, :sys_id, :sys_embeddedType]
-    SUPPORT_ATTRIBUTES = [:bodhi_context, :errors]
-    attr_accessor *SYSTEM_ATTRIBUTES
-    attr_accessor *SUPPORT_ATTRIBUTES
+    attr_accessor :bodhi_context
 
     module ClassMethods
-      def factory; @factory; end
+
+      def embedded(bool); @embedded = bool; end
+      def is_embedded?; @embedded; end
+
+      # Defines the given +name+ and +options+ as a form attribute for the class.
+      # The +name+ is set as a property, and validations & factory generators are added based on the supplied +options+
+      # 
+      #   class User
+      #     include Bodhi::Resource
+      #
+      #     field :first_name, type: "String", required: true, is_not_blank: true
+      #     field :last_name, type: "String", required: true, is_not_blank: true
+      #     field :email, type: "String", required: true, is_not_blank: true, is_email: true
+      #   end
+      #
+      #   object = User.new(first_name: "John", last_name: "Smith", email: "jsmith@email.com")
+      #   object.to_json #=> { "first_name": "John", "last_name": "Smith", "email": "jsmith@email.com" }
+      def field(name, options)
+        property(name.to_sym)
+        validates(name.to_sym, options)
+        generates(name.to_sym, options)
+      end
+
+      def build_type
+        # reduce the properties array into a Hash.
+        # lookup the validators for each property and add them as options for the property
+        type_properties = self.properties.reduce({}) do |result, property|
+          options = self.validators[property].map(&:to_options).reduce({}) do |options_result, options_hash|
+            options_result.merge(options_hash)
+          end
+          result.merge({ property => options})
+        end
+
+        Bodhi::Type.new(name: self.name, properties: type_properties, indexes: self.indexes, embedded: self.is_embedded?)
+      end
 
       # Saves a batch of resources to the Bodhi Cloud in the given +context+
       # Returns an array of JSON objects describing the results for each record in the batch
@@ -182,9 +212,6 @@ module Bodhi
     end
 
     module InstanceMethods
-      def id; @sys_id; end
-      def persisted?; !@sys_id.nil?; end
-      def new_record?; @sys_id.nil?; end
 
       def initialize(params={})
         params.each do |param_key, param_value|
@@ -207,46 +234,6 @@ module Bodhi
         end
       end
 
-      # 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
-          unless SYSTEM_ATTRIBUTES.include?(attribute_name) || SUPPORT_ATTRIBUTES.include?(attribute_name)
-            attributes[attribute_name] = send(attribute_name)
-          end
-        end
-        attributes
-      end
-
-      # Updates the resource with the given attributes Hash
-      # 
-      #   s = SomeResource.factory.build(foo:"test", bar:12345)
-      #   s.attributes # => { foo: "test", bar: 12345 }
-      #   s.update_attributes(foo:"12345", bar:10)
-      #   s.attributes # => { foo: "12345", bar: 10 }
-      def update_attributes(params)
-        self.instance_variables.each do |variable|
-          attribute_name = variable.to_s.delete('@').to_sym
-          unless SYSTEM_ATTRIBUTES.include?(attribute_name) || SUPPORT_ATTRIBUTES.include?(attribute_name)
-            send("#{attribute_name}=", params[attribute_name])
-          end
-        end
-      end
-
-      # Returns all the Objects attributes as JSON.
-      # It converts 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
-
       # Saves the resource to the Bodhi Cloud.  Returns true if record was saved
       # 
       #   obj = Resource.new
@@ -355,8 +342,8 @@ module Bodhi
 
     def self.included(base)
       base.extend(ClassMethods)
-      base.include(InstanceMethods, Bodhi::Validations, ActiveModel::Model)
-      base.instance_variable_set(:@factory, Bodhi::Factory.new(base))
+      base.include(InstanceMethods, Bodhi::Validations, Bodhi::Properties, Bodhi::Indexes, Bodhi::Factories, ActiveModel::Model)
+      base.instance_variable_set(:@embedded, false)
     end
   end
 end

data/lib/bodhi-slam/support.rb

@@ -0,0 +1,23 @@
+module Bodhi
+  class Support
+    def self.underscore(string)
+      string.gsub(/([A-Z]+)([A-Z][a-z])/,'\1_\2').
+      gsub(/([a-z\d])([A-Z])/,'\1_\2').
+      tr("-", "_").
+      downcase
+    end
+
+    def self.uncapitalize(string)
+      string[0, 1].downcase + string[1..-1]
+    end
+
+    def self.camelize(string)
+      underscore(string).split('_').collect(&:capitalize).join
+    end
+
+    def self.reverse_camelize(string)
+      result = underscore(string).split('_').collect(&:capitalize).join
+      uncapitalize(result)
+    end
+  end
+end

data/lib/bodhi-slam/types.rb

@@ -1,41 +1,42 @@
 module Bodhi
   class Type
+    include Bodhi::Factories
+    include Bodhi::Properties
     include Bodhi::Validations
 
-    SYSTEM_ATTRIBUTES = [:sys_created_at, :sys_version, :sys_modified_at, :sys_modified_by,
-      :sys_namespace, :sys_created_by, :sys_type_version, :sys_id, :sys_embeddedType]
-    ATTRIBUTES = [:name, :namespace, :package, :embedded, :properties, :version, :extends]
-
-    attr_accessor *ATTRIBUTES
-    attr_reader *SYSTEM_ATTRIBUTES
     attr_accessor :bodhi_context
 
+    property :name, :storage_name, :namespace,
+      :package, :embedded, :properties, :version,
+      :extends, :indexes, :hidden, :events, :documentation,
+      :metadata, :encapsulated
+
     validates :name, required: true, is_not_blank: true
-    validates :namespace, required: true
     validates :properties, required: true
+    validates :indexes, type: "Bodhi::TypeIndex", multi: true
 
-    # Returns a factory for the Bodhi::Type class
-    def self.factory
-      @factory ||= Bodhi::Factory.new(Bodhi::Type).tap do |factory|
-        factory.add_generator(:extends, type: "String", matches: "[a-zA-Z_-]{10,20}")
-        factory.add_generator(:name, type: "String", required: true, is_not_blank: true)
-        factory.add_generator(:namespace, type: "String", required: true)
-        factory.add_generator(:properties, type: "Object", required: true)
-        factory.add_generator(:package, type: "String")
-        factory.add_generator(:embedded, type: "Boolean")
-        factory.add_generator(:version, type: "String")
-      end
-    end
+    generates :extends, type: "String", matches: "[a-zA-Z_-]{10,20}"
+    generates :name, type: "String", required: true, is_not_blank: true
+    generates :namespace, type: "String", required: true
+    generates :properties, type: "Object", required: true
+    generates :package, type: "String"
+    generates :embedded, type: "Boolean"
+    generates :version, type: "String"
 
     def initialize(params={})
-      # same as symbolize_keys!
-      params = params.reduce({}) do |memo, (k, v)| 
-        memo.merge({ k.to_sym => v})
-      end
-
-      # set attributes
-      ATTRIBUTES.each do |attribute|
-        send("#{attribute}=", params[attribute])
+      params.each do |param_key, param_value|
+        if param_key.to_sym == :indexes
+          # check if the param_value is already an Array of Bodhi::TypeIndex objects
+          if param_value.is_a?(Array) && param_value.first.is_a?(Bodhi::TypeIndex)
+            send("#{param_key}=", param_value)
+          else
+            # the param_value is a raw json object and needs to be turned into an array of Bodhi::TypeIndex objects
+            values = param_value.map{ |index| Bodhi::TypeIndex.new(index) }
+            send("#{param_key}=", values)
+          end
+        else
+          send("#{param_key}=", param_value)
+        end
       end
 
       # Format type name to be compatible with Ruby Constants
@@ -44,29 +45,6 @@ module Bodhi
       end
     end
 
-    # Returns a Hash of the Objects form attributes
-    # 
-    #   s = SomeResource.factory.build({foo:"test", bar:12345})
-    #   s.attributes # => { foo: "test", bar: 12345 }
-    def attributes
-      result = Hash.new
-      ATTRIBUTES.each do |attribute|
-        result[attribute] = send(attribute)
-      end
-      result.delete_if { |k, v| v.nil? }
-      result
-    end
-
-    # Returns all the Objects attributes as JSON.
-    # It converts any nested Objects to JSON if they respond to +to_json+
-    # 
-    #   s = SomeResource.factory.build({foo:"test", bar:12345})
-    #   s.to_json # => "{ 'foo':'test', 'bar':12345 }"
-    def to_json(base=nil)
-      super if base
-      attributes.to_json
-    end
-
     # Saves the resource to the Bodhi Cloud.  Raises ArgumentError if record could not be saved.
     # 
     #   obj = Resouce.new
@@ -83,6 +61,10 @@ module Bodhi
       if result.status != 201
         raise Bodhi::ApiErrors.new(body: result.body, status: result.status), "status: #{result.status}, body: #{result.body}"
       end
+
+      if result.headers['location']
+        @sys_id = result.headers['location'].match(/types\/(?<name>[a-zA-Z0-9]+)/)[:name]
+      end
     end
 
     def delete!
@@ -170,19 +152,17 @@ module Bodhi
         raise ArgumentError.new("Expected #{type.class} to be a Bodhi::Type")
       end
 
-      klass = Object.const_set(type.name, Class.new {
-        include Bodhi::Resource
-        attr_accessor *type.properties.keys
-      })
+      klass = Object.const_set(type.name, Class.new { include Bodhi::Resource })
 
       type.properties.each_pair do |attr_name, attr_properties|
         attr_properties.delete_if{ |key, value| ["system", "trim", "unique", "default", "isCurrentUser", "toLower"].include?(key) }
-        klass.validates(attr_name.to_sym, attr_properties)
-        klass.factory.add_generator(attr_name.to_sym, attr_properties)
+        klass.field(attr_name, attr_properties)
       end
 
       klass
     end
 
   end
-end
+end
+
+Dir[File.dirname(__FILE__) + "/types/*.rb"].each { |file| require file }

data/lib/bodhi-slam/types/index.rb

@@ -0,0 +1,11 @@
+module Bodhi
+  class TypeIndex
+    include Bodhi::Properties
+    include Bodhi::Validations
+
+    property :keys, :options
+
+    validates :keys, required: true, multi: true, type: "String"
+    validates :options, type: "Object"
+  end
+end

data/lib/bodhi-slam/users.rb

@@ -1,11 +1,13 @@
 module Bodhi
   class User
+    include Bodhi::Factories
+    include Bodhi::Properties
     include Bodhi::Validations
 
-    ATTRIBUTES = [:username, :password, :profiles, :email, :firstName, :lastName, :phone]
-    attr_accessor *ATTRIBUTES
     attr_accessor :bodhi_context
 
+    property :username, :password, :profiles, :authorizations, :email, :firstName, :lastName, :phone, :usertype, :namespace
+
     validates :username, type: "String", required: true, is_not_blank: true
     validates :password, type: "String", required: true, is_not_blank: true
     validates :profiles, type: "String", required: true, multi: true
@@ -14,81 +16,13 @@ module Bodhi
     validates :lastName, type: "String"
     validates :phone, type: "String"
 
-    def initialize(params={})
-      # same as symbolize_keys!
-      params = params.reduce({}) do |memo, (k, v)| 
-        memo.merge({ k.to_sym => v})
-      end
-
-      # set attributes
-      ATTRIBUTES.each do |attribute|
-        send("#{attribute}=", params[attribute])
-      end
-    end
-
-    # Returns a Hash of the Objects form attributes
-    # 
-    #   s = SomeResource.factory.build({foo:"test", bar:12345})
-    #   s.attributes # => { foo: "test", bar: 12345 }
-    def attributes
-      result = Hash.new
-      ATTRIBUTES.each do |attribute|
-        result[attribute] = send(attribute)
-      end
-      result
-    end
-
-    # Returns all the Objects attributes as JSON.
-    # It converts any nested Objects to JSON if they respond to +to_json+
-    # 
-    #   s = SomeResource.factory.build({foo:"test", bar:12345})
-    #   s.to_json # => "{ 'foo':'test', 'bar':12345 }"
-    def to_json(base=nil)
-      super if base
-      attributes.to_json
-    end
-
-    # Saves the resource to the Bodhi Cloud.  Raises ArgumentError if record could not be saved.
-    # 
-    #   obj = Resouce.new
-    #   obj.save!
-    #   obj.persisted? # => true
-    def save!
-      result = bodhi_context.connection.post do |request|
-        request.url "/#{bodhi_context.namespace}/users"
-        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
-        raise Bodhi::ApiErrors.new(body: result.body, status: result.status), "status: #{result.status}, body: #{result.body}"
-      end
-    end
-
-    def delete!
-      result = bodhi_context.connection.delete do |request|
-        request.url "/#{bodhi_context.namespace}/users/#{username}"
-        request.headers[bodhi_context.credentials_header] = bodhi_context.credentials
-      end
-
-      if result.status != 204
-        raise Bodhi::ApiErrors.new(body: result.body, status: result.status), "status: #{result.status}, body: #{result.body}"
-      end
-    end
-
-    # Returns a factory for the Bodhi::User class
-    def self.factory
-      @factory ||= Bodhi::Factory.new(Bodhi::User).tap do |factory|
-        factory.add_generator(:username, type: "String", required: true, is_not_blank: true)
-        factory.add_generator(:password, type: "String", required: true, is_not_blank: true)
-        factory.add_generator(:profiles, type: "String", required: true, multi: true)
-        factory.add_generator(:email, type: "String", is_email: true)
-        factory.add_generator(:firstName, type: "String")
-        factory.add_generator(:lastName, type: "String")
-        factory.add_generator(:phone, type: "String")
-      end
-    end
+    generates :username, type: "String", required: true, is_not_blank: true
+    generates :password, type: "String", required: true, is_not_blank: true
+    generates :profiles, type: "String", required: true, multi: true
+    generates :email, type: "String", is_email: true
+    generates :firstName, type: "String"
+    generates :lastName, type: "String"
+    generates :phone, type: "String"
 
     # Queries the Bodhi API for the given +user_name+ and
     # returns a Bodhi::User
@@ -135,5 +69,35 @@ module Bodhi
 
       result.body
     end
+
+    # Saves the resource to the Bodhi Cloud.  Raises ArgumentError if record could not be saved.
+    # 
+    #   obj = Resouce.new
+    #   obj.save!
+    #   obj.persisted? # => true
+    def save!
+      result = bodhi_context.connection.post do |request|
+        request.url "/#{bodhi_context.namespace}/users"
+        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
+        raise Bodhi::ApiErrors.new(body: result.body, status: result.status), "status: #{result.status}, body: #{result.body}"
+      end
+    end
+
+    def delete!
+      result = bodhi_context.connection.delete do |request|
+        request.url "/#{bodhi_context.namespace}/users/#{username}"
+        request.headers[bodhi_context.credentials_header] = bodhi_context.credentials
+      end
+
+      if result.status != 204
+        raise Bodhi::ApiErrors.new(body: result.body, status: result.status), "status: #{result.status}, body: #{result.body}"
+      end
+    end
+
   end
 end

data/lib/bodhi-slam/validators.rb

@@ -16,10 +16,8 @@ module Bodhi
     #   type.to_sym # => :type
     #   is_not_blank.to_sym # => :is_not_blank
     def to_sym
-      underscore.
-      gsub("bodhi/", "").
-      gsub("_validator", "").
-      to_sym
+      name = self.underscore.gsub("bodhi::", "").gsub("_validator", "")
+      Bodhi::Support.reverse_camelize(name).to_sym
     end
     
     # Returns the validation's class name in snake_case.
@@ -30,11 +28,7 @@ module Bodhi
     #   type.underscore # => "bodhi/type_validator"
     #   is_not_blank.underscore # => "bodhi/is_not_blank_validator"
     def underscore
-      self.class.name.gsub(/::/, '/').
-      gsub(/([A-Z]+)([A-Z][a-z])/,'\1_\2').
-      gsub(/([a-z\d])([A-Z])/,'\1_\2').
-      tr("-", "_").
-      downcase
+      Bodhi::Support.underscore(self.class.name)
     end
     
     # Returns the validation as an options Hash.
@@ -55,9 +49,8 @@ module Bodhi
     #   Bodhi::Validator.constantize("type") # => #<Bodhi::TypeValidator:0x007fbff403e808>
     #   Bodhi::Validator.constantize("is_not_blank") # => #<Bodhi::IsNotBlankValidator:0x007fbff403e808>
     def self.constantize(name)
-      camelized_name = name.to_s.split('_').collect(&:capitalize).join
-      full_name = "Bodhi::#{camelized_name}Validator"
-      Object.const_get(full_name)
+      camelized_name = Bodhi::Support.camelize(name.to_s)
+      Object.const_get("Bodhi::#{camelized_name}Validator")
     end
   end
 end

metadata

@@ -1,14 +1,14 @@
 --- !ruby/object:Gem::Specification
 name: bodhi-slam
 version: !ruby/object:Gem::Version
-  version: 0.4.1
+  version: 0.5.0
 platform: ruby
 authors:
 - willdavis
 autorequire: 
 bindir: bin
 cert_chain: []
-date: 2015-10-26 00:00:00.000000000 Z
+date: 2015-11-16 00:00:00.000000000 Z
 dependencies:
 - !ruby/object:Gem::Dependency
   name: faraday
@@ -165,10 +165,14 @@ files:
 - lib/bodhi-slam/errors/api.rb
 - lib/bodhi-slam/errors/context.rb
 - lib/bodhi-slam/factory.rb
+- lib/bodhi-slam/indexes.rb
 - lib/bodhi-slam/profiles.rb
+- lib/bodhi-slam/properties.rb
 - lib/bodhi-slam/queries.rb
 - lib/bodhi-slam/resource.rb
+- lib/bodhi-slam/support.rb
 - lib/bodhi-slam/types.rb
+- lib/bodhi-slam/types/index.rb
 - lib/bodhi-slam/users.rb
 - lib/bodhi-slam/validations.rb
 - lib/bodhi-slam/validators.rb