bodhi-slam 0.5.4 → 0.6.0

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA1:
-  metadata.gz: 5555fc31ea61537f2cf853ef20bc9abcc3be90cd
-  data.tar.gz: 9e8a0aef642e02f2a562f882efb5e7209783ea5c
+  metadata.gz: 9e09a87b26acc4339643d71bf277dad6594e7ab4
+  data.tar.gz: 2e9a4a7d6c16223aeb5048f7db9ad62f67b16432
 SHA512:
-  metadata.gz: 95543f83c7aa4df83dd787c8286104408ef8c9f2eba82ed6716e7140549e2ed31ba7fd54710e1b3aded240d904b805bab3c4cb20ff50e83ea47ab28fc362b7c3
-  data.tar.gz: 07de99d9bbdc16829deb95a056cc979ac959d03ed054ecdb60b5e997ca7c411e0402d3c25ba9c8a50d68c50f4f0eaad7cfe075a640cd231f943e7c75a667b6ad
+  metadata.gz: b0bab9be47dc879b044428bd45ec76717d2bd0b9e75f14db089bd3d0777c53ee0ff8590ce0d4032cb507876b66c8fa460aa0e559d19cf79473b2421c4941d78e
+  data.tar.gz: b7be96e86df8a30bdc2692a025a873c68a5f6574badaa80a3bfc272de81a1adac11e857b6128f394d714e043d1a7e15c8d25ca321b6808d265b15315ac9ae0af

data/lib/bodhi-slam/context.rb

@@ -1,5 +1,3 @@
-require 'bodhi-slam/validations'
-
 module Bodhi
   class Context
     include Bodhi::Validations

data/lib/bodhi-slam/factory.rb

@@ -28,12 +28,9 @@ module Bodhi
     #   Resource.factory.build # => #<Resource:0x007fbff403e808 @name="2-3lmwp^oef@245">
     #   Resource.factory.build(name: "test") # => #<Resource:0x007fbff403e808 @name="test">
     def build(options={})
-      # symbolize the option keys
-      options = options.reduce({}) do |memo, (k, v)| 
-        memo.merge({ k.to_sym => v})
-      end
-
+      options = Bodhi::Support.symbolize_keys(options)
       object = klass.new(bodhi_context: options[:bodhi_context])
+
       @generators.each_pair do |attribute, generator|
         if options.has_key?(attribute)
           object.send("#{attribute}=", options[attribute])
@@ -41,6 +38,7 @@ module Bodhi
           object.send("#{attribute}=", generator.call)
         end
       end
+
       object
     end
 

data/lib/bodhi-slam/indexes.rb

@@ -3,11 +3,7 @@ module Bodhi
     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
-
+        options = Bodhi::Support.symbolize_keys(options)
         @indexes << Bodhi::TypeIndex.new(keys: keys.map(&:to_s), options: options)
       end
     end

data/lib/bodhi-slam/profiles.rb

@@ -6,7 +6,11 @@ module Bodhi
 
     attr_accessor :bodhi_context
 
-    property :name, :namespace, :dml, :subspace, :parent
+    property :dml,        type: "Object"
+    property :name,       type: "String"
+    property :namespace,  type: "String"
+    property :subspace,   type: "String"
+    property :parent,     type: "String"
 
     validates :name, type: "String", required: true, is_not_blank: true
     validates :namespace, type: "String", required: true

data/lib/bodhi-slam/properties.rb

@@ -7,10 +7,12 @@ module Bodhi
 
     module ClassMethods
       def properties; @properties; end
-      def property(*names)
-        attr_accessor *names.map(&:to_sym)
-        @properties << names.map(&:to_sym)
-        @properties.flatten!
+      def property_names; @properties.keys; end
+      def property(name, options)
+        attr_accessor name.to_sym
+        @properties[name.to_sym] = options.reduce({}) do |memo, (k, v)|
+          memo.merge({ Bodhi::Support.reverse_camelize(k.to_s).to_sym => v})
+        end
       end
     end
 
@@ -30,9 +32,15 @@ module Bodhi
       #   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)
+      def initialize(options={})
+        options = Bodhi::Support.symbolize_keys(options)
+        options.each do |property, value|
+          property_options = self.class.properties[property]
+          if property_options.nil?
+            send("#{property}=", value)
+          else
+            send("#{property}=", Bodhi::Support.coerce(value, property_options))
+          end
         end
       end
 
@@ -43,7 +51,7 @@ module Bodhi
       def attributes
         attributes = Hash.new
 
-        self.class.properties.each do |property|
+        self.class.property_names.each do |property|
           value = send(property)
           if value.respond_to?(:attributes)
             attributes[property] = value.attributes.delete_if { |k, v| v.nil? }
@@ -86,7 +94,7 @@ module Bodhi
     def self.included(base)
       base.extend(ClassMethods)
       base.include(InstanceMethods)
-      base.instance_variable_set(:@properties, Array.new)
+      base.instance_variable_set(:@properties, Hash.new)
     end
   end
 end

data/lib/bodhi-slam/resource.rb

@@ -22,22 +22,13 @@ module Bodhi
       #   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)
+        property(name.to_sym, options)
         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?)
+        Bodhi::Type.new(name: self.name, properties: self.properties, indexes: self.indexes, embedded: self.is_embedded?)
       end
 
       # Saves a batch of resources to the Bodhi Cloud in the given +context+
@@ -212,28 +203,6 @@ module Bodhi
     end
 
     module InstanceMethods
-
-      def initialize(params={})
-        params.each do |param_key, param_value|
-          if param_value.is_a? Hash
-            type_validator = self.class.validators[param_key.to_sym].find{ |validator| validator.is_a? Bodhi::TypeValidator }
-            if Object.const_defined?(type_validator.type)
-              klass = Object.const_get(type_validator.type)
-              if klass.ancestors.include?(Bodhi::Resource)
-                object = klass.new(param_value)
-                send("#{param_key}=", object)
-              else
-                send("#{param_key}=", param_value)
-              end
-            else
-              send("#{param_key}=", param_value)
-            end
-          else
-            send("#{param_key}=", param_value)
-          end
-        end
-      end
-
       # Saves the resource to the Bodhi Cloud.  Returns true if record was saved
       # 
       #   obj = Resource.new

data/lib/bodhi-slam/support.rb

@@ -19,5 +19,71 @@ module Bodhi
       result = underscore(string).split('_').collect(&:capitalize).join
       uncapitalize(result)
     end
+
+    def self.symbolize_keys(hash)
+      hash.reduce({}) do |memo, (k, v)|
+        value = v.is_a?(Hash) ? symbolize_keys(v) : v
+        value = value.is_a?(Array) && value.first.is_a?(Hash) ? value.map{|item| symbolize_keys(item) } : value
+        memo.merge({ k.to_sym => value })
+      end
+    end
+
+    def self.coerce(value, options)
+      options = symbolize_keys(options)
+      case options[:type].to_s
+      when "Object"
+        if options[:multi] == true
+          if value.is_a?(String)
+            values = JSON.parse(value)
+            values.map{|item| Bodhi::Support.symbolize_keys(item) }
+          elsif value.is_a?(Array) && value.first.is_a?(Hash)
+            value.map{|item| Bodhi::Support.symbolize_keys(item) }
+          else
+            raise RuntimeError.new("Unable to coerce: #{value} to a JSON Object")
+          end
+        else
+          if value.is_a?(Hash)
+            Bodhi::Support.symbolize_keys(value)
+          else
+            Bodhi::Support.symbolize_keys(JSON.parse(value))
+          end
+        end
+      when "String"
+        if options[:multi] == true
+          value.map(&:to_s)
+        else
+          value.to_s
+        end
+      when "Real"
+        if options[:multi] == true
+          value.map(&:to_f)
+        else
+          value.to_f
+        end
+      when "Integer"
+        if options[:multi] == true
+          value.map(&:to_i)
+        else
+          value.to_i
+        end
+      when "DateTime"
+        if options[:multi] == true
+          value.map{|item| Time.parse(item.to_s) }
+        else
+          Time.parse(value.to_s)
+        end
+      else
+        if Object.const_defined?(options[:type].to_s) && Object.const_get(options[:type].to_s).ancestors.include?(Bodhi::Properties)
+          klass = Object.const_get(options[:type].to_s)
+          if options[:multi] == true
+            value.map{|item| klass.new(item) }
+          else
+            klass.new(value)
+          end
+        else
+          value
+        end
+      end
+    end
   end
 end

data/lib/bodhi-slam/types.rb

@@ -6,10 +6,23 @@ module Bodhi
 
     attr_accessor :bodhi_context
 
-    property :name, :storage_name, :namespace,
-      :package, :embedded, :properties, :version,
-      :extends, :indexes, :hidden, :events, :documentation,
-      :metadata, :encapsulated
+    property :properties,     type: "Object"
+    property :indexes,        type: "Bodhi::TypeIndex", multi: true
+    property :events,         type: "Object"
+
+    property :name,           type: "String"
+    property :storage_name,   type: "String"
+    property :namespace,      type: "String"
+    property :package,        type: "String"
+    property :version,        type: "String"
+    property :extends,        type: "String"
+
+    property :hidden,         type: "Boolean"
+    property :embedded,       type: "Boolean"
+    property :metadata,       type: "Boolean"
+    property :encapsulated,   type: "Boolean"
+
+    property :documentation,  type: "Link"
 
     validates :name, required: true, is_not_blank: true
     validates :properties, required: true
@@ -23,28 +36,6 @@ module Bodhi
     generates :embedded, type: "Boolean"
     generates :version, type: "String"
 
-    def initialize(params={})
-      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
-      if !name.nil? && name[0] == name[0].downcase
-        name.capitalize!
-      end
-    end
-
     # Saves the resource to the Bodhi Cloud.  Raises ArgumentError if record could not be saved.
     # 
     #   obj = Resouce.new
@@ -161,10 +152,7 @@ module Bodhi
       klass = Object.const_set(type.name, Class.new { include Bodhi::Resource })
 
       type.properties.each_pair do |attr_name, attr_properties|
-        # symbolize the attr_properties keys
-        attr_properties = attr_properties.reduce({}) do |memo, (k, v)|
-          memo.merge({ k.to_sym => v})
-        end
+        attr_properties = Bodhi::Support.symbolize_keys(attr_properties)
 
         # remove Sanitizers
         attr_properties.delete_if{ |key, value| [:trim, :unique, :default, :isCurrentUser, :toLower].include?(key) }
@@ -181,12 +169,7 @@ module Bodhi
           if index.is_a? Bodhi::TypeIndex
             klass.index index.keys, index.options
           else
-            # index is a raw json object
-            # symbolize the index option keys
-            index = index.reduce({}) do |memo, (k, v)|
-              memo.merge({ k.to_sym => v})
-            end
-
+            index = Bodhi::Support.symbolize_keys(index)
             klass.index index[:keys], index[:options]
           end
         end

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

@@ -1,11 +1,17 @@
 module Bodhi
   class TypeIndex
+    include Enumerable
     include Bodhi::Properties
     include Bodhi::Validations
 
-    property :keys, :options
+    property :keys, type: "String", multi: true, required: true
+    property :options, type: "Object"
 
     validates :keys, required: true, multi: true, type: "String"
     validates :options, type: "Object"
+
+    def each
+      self.attributes.each{ |k, v| yield(k, v) }
+    end
   end
 end

data/lib/bodhi-slam/users.rb

@@ -6,7 +6,16 @@ module Bodhi
 
     attr_accessor :bodhi_context
 
-    property :username, :password, :profiles, :authorizations, :email, :firstName, :lastName, :phone, :usertype, :namespace
+    property :username,       type: "String"
+    property :password,       type: "String"
+    property :profiles,       type: "String", multi: true
+    property :authorizations, type: "BodhiAuthorization", multi: true
+    property :email,          type: "String"
+    property :firstName,      type: "String"
+    property :lastName,       type: "String"
+    property :phone,          type: "String"
+    property :usertype,       type: "String"
+    property :namespace,      type: "String"
 
     validates :username, type: "String", required: true, is_not_blank: true
     validates :password, type: "String", required: true, is_not_blank: true

metadata

@@ -1,14 +1,14 @@
 --- !ruby/object:Gem::Specification
 name: bodhi-slam
 version: !ruby/object:Gem::Version
-  version: 0.5.4
+  version: 0.6.0
 platform: ruby
 authors:
 - willdavis
 autorequire: 
 bindir: bin
 cert_chain: []
-date: 2015-12-10 00:00:00.000000000 Z
+date: 2015-12-14 00:00:00.000000000 Z
 dependencies:
 - !ruby/object:Gem::Dependency
   name: faraday