bodhi-slam 0.1.0 → 0.2.0

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA1:
-  metadata.gz: 9ca91de0d49a0aa3ff8e084024cdc6114444814e
-  data.tar.gz: a7d550040d2b4e705ab10c7a0a6a8929aff7b967
+  metadata.gz: bb30e21e9283a1c741cb4fb387a671f7f274e0f5
+  data.tar.gz: 56da1e71e1010ec141edb8b7583c0cdde33da72d
 SHA512:
-  metadata.gz: 8e9231701b099974ee34f0708740e3882743677861153b82a0c996e218b9be6b66fbb638248af82a204abc1b2ffd7bbaa1a8b7055c78b62dc208203f2d8fe058
-  data.tar.gz: a4cc9b671833cf91bb0524d5bc4bd608a33d276f8f7aaa5e93eb00c86f853595675bfd366380704bb59f80a195829358458e7e9a482924d1aed6c7d6fc7be420
+  metadata.gz: adccca58ce46682c5efe48312bcee45f5c94312f10e0b46ea692dbb62df89e11e26f66134f56ab60a41e4413bcdca9f56aad9ab5253c74088d849432294c9492
+  data.tar.gz: e7c7b9b8fe73e71a1b18916cd59764b66be0944d705265e4b61acc5a589f1565b97fa677e4455849435e29071c44cc29e28854a064d784e0d89be1d820af68c0

data/lib/bodhi-slam.rb

@@ -1,6 +1,5 @@
 require "faraday"
 require 'net/http/persistent'
-require "factory_girl"
 require "json"
 require "time"
 
@@ -10,6 +9,7 @@ require 'bodhi-slam/resource'
 require 'bodhi-slam/types'
 require 'bodhi-slam/validations'
 require 'bodhi-slam/enumerations'
+require 'bodhi-slam/factory'
 
 class BodhiSlam
   def self.context(params, &block)
@@ -23,16 +23,9 @@ class BodhiSlam
   
   def self.analyze(context)
     raise context.errors unless context.valid?
-    
+
     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) }
-
-    embedded_types = all_types.select{ |type| type.embedded }
-    normal_types = all_types.select{ |type| !type.embedded }
-
-    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
+    all_types.collect{ |type| Bodhi::Type.create_class_with(type) }
   end
 end

data/lib/bodhi-slam/context.rb

@@ -10,8 +10,6 @@ module Bodhi
       validates :namespace, required: true, is_not_blank: true
     
     def initialize(params)
-      params.symbolize_keys!
-    
       @connection = Faraday.new(url: params[:server]) do |faraday|
         faraday.request  :url_encoded             # form-encode POST params
         #faraday.response :logger                  # log requests to STDOUT

data/lib/bodhi-slam/enumerations.rb

@@ -2,12 +2,26 @@ module Bodhi
   class Enumeration
     attr_reader :name, :values
     
-    def initialize(params={})
-      params.symbolize_keys!
-      
+    def initialize(params)
+      # same as symbolize_keys!
+      params = params.reduce({}) do |memo, (k, v)| 
+        memo.merge({ k.to_sym => v})
+      end
+
       @name = params[:name]
       @values = params[:values]
       self.class.cache[@name.to_sym] = self
+
+      @values = @values.map do |value|
+        if value.is_a? Hash
+          # same as symbolize_keys!
+          value = value.reduce({}) do |memo, (k, v)| 
+            memo.merge({ k.to_sym => v})
+          end
+        else
+          value
+        end
+      end
     end
     
     def self.find_all(context)

data/lib/bodhi-slam/factory.rb

@@ -0,0 +1,169 @@
+module Bodhi
+  class Factory
+    attr_reader :klass
+    attr_accessor :generators
+
+    def initialize(base)
+      @klass = base
+      @generators = Hash.new
+    end
+
+    def build(*args)
+      if args.last.is_a?(Hash)
+        params = args.last.reduce({}) do |memo, (k, v)| 
+          memo.merge({ k.to_sym => v})
+        end
+      else
+        params = Hash.new
+      end
+
+      object = klass.new
+      @generators.each_pair do |attribute, generator|
+        if params[attribute]
+          object.send("#{attribute}=", params[attribute])
+        else
+          object.send("#{attribute}=", generator.call)
+        end
+      end
+      object
+    end
+
+    def build_list(size, *args)
+      size.times.collect{ build(*args) }
+    end
+
+    def create(context, params={})
+      if context.invalid?
+        raise context.errors
+      end
+
+      object = build(params)
+      object.bodhi_context = context
+      object.save!
+      object
+    end
+
+    def create_list(size, context, params={})
+      if context.invalid?
+        raise context.errors
+      end
+
+      resources = build_list(size, params)
+      result = context.connection.post do |request|
+        request.url "/#{context.namespace}/resources/#{klass}"
+        request.headers['Content-Type'] = 'application/json'
+        request.headers[context.credentials_header] = context.credentials
+        request.body = resources.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"
+
+      resources
+    end
+
+    def add_generator(name, options)
+      case options[:type]
+      when "String"
+        characters = [('a'..'z'), ('A'..'Z'), ('0'..'9')].map { |i| i.to_a }.flatten
+        "~!@#$%^&*()_+-=:;<>?,./ ".each_char{ |c| characters.push(c) }
+
+        generator = lambda do
+          if options[:multi]
+            [*0..5].sample.times.collect{ [*0..50].sample.times.map{ characters[rand(characters.length)] }.join }
+          else
+            [*0..50].sample.times.map{ characters[rand(characters.length)] }.join
+          end
+        end
+
+      when "DateTime"
+        if options[:multi]
+          generator = lambda { [*0..5].sample.times.collect{ Time.at(rand * Time.now.to_i).iso8601 } }
+        else
+          generator = lambda { Time.at(rand * Time.now.to_i).iso8601 }
+        end
+
+      when "Integer"
+        options[:min].nil? ? min = -2147483647 : min = options[:min]
+        options[:max].nil? ? max = 2147483647 : max = options[:max]
+
+        if options[:multi]
+          generator = lambda { [*0..5].sample.times.collect{ rand(min..max) } }
+        else
+          generator = lambda { rand(min..max) }
+        end
+
+      when "Real"
+        if options[:multi]
+          generator = lambda { [*0..5].sample.times.collect{ SecureRandom.random_number*[-1,1,1,1].sample*[10,100,1000,10000].sample } }
+        else
+          generator = lambda { SecureRandom.random_number*[-1,1,1,1].sample*[10,100,1000,10000].sample }
+        end
+
+      when "Boolean"
+        if options[:multi]
+          generator = lambda { [*0..5].sample.times.collect{ [true, false].sample } }
+        else
+          generator = lambda { [true, false].sample }
+        end
+
+      when "GeoJSON"
+        if options[:multi]
+          generator = lambda { [*0..5].sample.times.collect{ {type: "Point", coordinates: [10,20]} } }
+        else
+          generator = lambda { {type: "Point", coordinates: [10,20]} }
+        end
+
+      when "Object"
+        if options[:multi]
+          generator = lambda { [*0..5].sample.times.collect{ {SecureRandom.hex => SecureRandom.hex} } }
+        else
+          generator = lambda { {SecureRandom.hex => SecureRandom.hex} }
+        end
+
+      when "Enumerated"
+        generator = lambda do
+          ref = options[:ref].split('.')
+          name = ref[0]
+          field = ref[1]
+
+          if options[:multi]
+            if field.nil?
+              [*0..5].sample.times.collect{ Bodhi::Enumeration.cache[name.to_sym].values.sample }
+            else
+              [*0..5].sample.times.collect{ Bodhi::Enumeration.cache[name.to_sym].values.sample[field.to_sym] }
+            end
+          else
+            if field.nil?
+              Bodhi::Enumeration.cache[name.to_sym].values.sample
+            else
+              Bodhi::Enumeration.cache[name.to_sym].values.sample[field.to_sym]
+            end
+          end
+        end
+
+      else
+        generator = lambda do
+          embedded_klass = Object.const_get(options[:type])
+
+          if options[:multi]
+            [*0..5].sample.times.collect{ embedded_klass.factory.build }
+          else
+            embedded_klass.factory.build
+          end
+        end
+      end
+
+      @generators[name.to_sym] = generator
+    end
+
+  end
+end

data/lib/bodhi-slam/resource.rb

@@ -1,48 +1,11 @@
 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]
+      :sys_namespace, :sys_created_by, :sys_type_version, :sys_id, :sys_embeddedType]
     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 factory; @factory; end
 
       def find(context, id)
         raise context.errors unless context.valid?
@@ -64,7 +27,7 @@ module Bodhi
         end
 
         resource_attributes = JSON.parse(result.body)
-        self.build(context, resource_attributes)
+        factory.build(context, resource_attributes)
       end
 
       def aggregate(context, pipeline)
@@ -109,7 +72,7 @@ module Bodhi
         end
 
         resources = JSON.parse(result.body)
-        resources.map{ |attributes| self.build(context, attributes) }
+        resources.map{ |attributes| factory.build(context, attributes) }
       end
 
       def delete_all(context)
@@ -207,6 +170,7 @@ module Bodhi
     def self.included(base)
       base.extend(ClassMethods)
       base.include(InstanceMethods, Bodhi::Validations)
+      base.instance_variable_set(:@factory, Bodhi::Factory.new(base))
     end
   end
 end

data/lib/bodhi-slam/types.rb

@@ -1,191 +1,102 @@
 module Bodhi
   class Type
     include Bodhi::Validations
-    
+
     BODHI_SYSTEM_ATTRIBUTES = [:sys_created_at, :sys_version, :sys_modified_at, :sys_modified_by,
-      :sys_namespace, :sys_created_by, :sys_type_version, :sys_id]
+      :sys_namespace, :sys_created_by, :sys_type_version, :sys_id, :sys_embeddedType]
     BODHI_TYPE_ATTRIBUTES = [:name, :namespace, :package, :embedded, :properties]
-    
+
     attr_accessor *BODHI_TYPE_ATTRIBUTES
     attr_reader *BODHI_SYSTEM_ATTRIBUTES
     attr_reader :validations
-    
+
     validates :name, required: true, is_not_blank: true
     validates :namespace, required: true
     validates :properties, required: true
-    
+
     def initialize(params={})
-      params.symbolize_keys!
-      
+      # same as symbolize_keys!
+      params = params.reduce({}) do |memo, (k, v)| 
+        memo.merge({ k.to_sym => v})
+      end
+
+      # set attributes
       BODHI_TYPE_ATTRIBUTES.each do |attribute|
         send("#{attribute}=", params[attribute])
       end
-      
+
+      if !name.nil? && name[0] == name[0].downcase
+        name.capitalize!
+      end
+
+      # build validator objects
       @validations = {}
       if properties
-        properties.symbolize_keys!
         properties.each_pair do |attr_name, attr_properties|
-          attr_properties.symbolize_keys!
-          @validations[attr_name] = []
+          @validations[attr_name.to_sym] = []
           attr_properties.each_pair do |option, value|
             underscored_name = option.to_s.gsub(/::/, '/').gsub(/([A-Z]+)([A-Z][a-z])/,'\1_\2').gsub(/([a-z\d])([A-Z])/,'\1_\2').tr("-", "_").downcase.to_sym
-            unless [:system, :trim, :ref, :unique, :default, :is_current_user].include? underscored_name
+            unless [:system, :trim, :ref, :unique, :default, :is_current_user, :to_lower].include? underscored_name
               klass = Bodhi::Validator.constantize(underscored_name)
-              if option == :type && value == "Enumerated"
-                if attr_properties[:ref].nil?
+              if option.to_s == "type" && value == "Enumerated"
+                if attr_properties["ref"].nil?
                   raise RuntimeError.new("No reference property found!  Cannot build enumeration validator for #{name}.#{attr_name}")
                 end
-
-                @validations[attr_name] << klass.new(value, attr_properties[:ref])
+                @validations[attr_name.to_sym] << klass.new(value, attr_properties["ref"])
               else
-                @validations[attr_name] << klass.new(value)
+                @validations[attr_name.to_sym] << klass.new(value)
               end
             end
           end
         end
       end
     end
-    
+
     def self.find_all(context)
       raise context.errors unless context.valid?
-      
-      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
-    
-      JSON.parse(result.body).collect{ |type| Bodhi::Type.new(type) }
+      page = 1
+      all_records = []
+
+      begin
+        result = context.connection.get do |request|
+          request.url "/#{context.namespace}/types?paging=page:#{page}"
+          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
+
+        page += 1
+        records = JSON.parse(result.body)
+        all_records << records
+      end while records.size == 100
+
+      all_records.flatten.collect{ |type| Bodhi::Type.new(type) }
     end
-    
+
     def self.create_class_with(type)
       unless type.is_a? Bodhi::Type
         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
       })
-      
+
       type.validations.each_pair do |attribute, validations|
         attr_options = Hash.new
         validations.each{ |validation| attr_options.merge!(validation.to_options) }
         klass.validates(attribute, attr_options)
+        klass.factory.add_generator(attribute, attr_options)
       end
-      
+
       klass
     end
-    
-    def self.create_factory_with(type)
-      unless type.is_a? Bodhi::Type
-        raise ArgumentError.new("Expected #{type.class} to be a Bodhi::Type")
-      end
-
-      FactoryGirl.define do
-        factory type.name.to_sym do
-          type.properties.each_pair do |attribute, options|
-            unless options[:system]
-
-              case options[:type]
-              when "GeoJSON"
-                if options[:multi].nil?
-                  send(attribute) { {type: "Point", coordinates: [10,20]} }
-                else
-                  send(attribute) { [*0..5].sample.times.collect{ {type: "Point", coordinates: [10,20]} } }
-                end
-
-              when "Boolean"
-                if options[:multi].nil?
-                  send(attribute) { [true, false].sample }
-                else
-                  send(attribute) { [*0..5].sample.times.collect{ [true, false].sample } }
-                end
-
-              when "Enumerated"
-                reference = options[:ref].split('.')
-                name = reference[0]
-                field = reference[1]
-
-                if options[:multi].nil?
-                  if field.nil?
-                    send(attribute) { Bodhi::Enumeration.cache[name.to_sym].values.sample }
-                  else
-                    Bodhi::Enumeration.cache[name.to_sym].values.map!{ |value| value.symbolize_keys! }
-                    send(attribute) { Bodhi::Enumeration.cache[name.to_sym].values.sample[field.to_sym] }
-                  end
-                else
-                  if field.nil?
-                    send(attribute) { [*0..5].sample.times.collect{ Bodhi::Enumeration.cache[name.to_sym].values.sample } }
-                  else
-                    send(attribute) { [*0..5].sample.times.collect{ Bodhi::Enumeration.cache[name.to_sym].values.sample[field.to_sym] } }
-                  end
-                end
-
-              when "Object"
-                if options[:multi].nil?
-                  send(attribute) { {SecureRandom.hex => SecureRandom.hex} }
-                else
-                  send(attribute) { [*0..5].sample.times.collect{ {SecureRandom.hex => SecureRandom.hex} } }
-                end
 
-              when "String"
-                if options[:multi].nil?
-                  send(attribute) { SecureRandom.hex }
-                else
-                  send(attribute) { [*0..5].sample.times.collect{ SecureRandom.hex } }
-                end
-
-              when "DateTime"
-                if options[:multi].nil?
-                  send(attribute) { Time.at(rand * Time.now.to_i).iso8601 }
-                else
-                  send(attribute) { [*0..5].sample.times.collect{ Time.at(rand * Time.now.to_i).iso8601 } }
-                end
-
-              when "Integer"
-                min = -10000
-                max = 10000
-                if options[:min]
-                  min = options[:min]
-                end
-
-                if options[:max]
-                  max = options[:max]
-                end
-
-                if options[:multi].nil?
-                  send(attribute) { rand(min..max) }
-                else
-                  send(attribute) { [*0..5].sample.times.collect{ rand(min..max) } }
-                end
-
-              when "Real"
-                if options[:multi].nil?
-                  send(attribute) { SecureRandom.random_number*[-1,1,1,1].sample*[10,100,1000,10000].sample }
-                else
-                  send(attribute) { [*0..5].sample.times.collect{ SecureRandom.random_number*[-1,1,1,1].sample*[10,100,1000,10000].sample } }
-                end
-
-              else # Its an embedded type
-                if options[:multi].nil?
-                  send(attribute) { FactoryGirl.build(options[:type]) }
-                else
-                  send(attribute) { [*0..5].sample.times.collect{ FactoryGirl.build(options[:type]) } }
-                end
-              end
-            
-            end
-          end
-        end
-      end
-
-    end
   end
 end

data/lib/bodhi-slam/validators/length.rb

@@ -0,0 +1,27 @@
+module Bodhi
+  class LengthValidator < Validator
+    attr_reader :value
+
+    def initialize(value)
+      @value = value
+    end
+
+    def validate(record, attribute, value)
+      unless value.nil?
+        
+        if value.is_a?(Array)
+          unless value.empty?
+            record.errors.add(attribute, "must all be #{value} characters long") unless value.select{ |item| !item.length == @value }.empty?
+          end
+        else
+          record.errors.add(attribute, "must be #{value} characters long") unless value.length == @value
+        end
+        
+      end
+    end
+    
+    def to_options
+      {self.to_sym => @value}
+    end
+  end
+end

data/lib/bodhi-slam/validators/max.rb

@@ -19,7 +19,7 @@ module Bodhi
 
       end
     end
-    
+
     def to_options
       {self.to_sym => @value}
     end

data/lib/bodhi-slam/validators/min.rb

@@ -19,7 +19,7 @@ module Bodhi
 
       end
     end
-    
+
     def to_options
       {self.to_sym => @value}
     end

data/lib/bodhi-slam/validators/multi.rb

@@ -6,7 +6,7 @@ module Bodhi
     def validate(record, attribute, value)
       record.errors.add(attribute, "must be an array") unless value.is_a? Array
     end
-    
+
     def to_options
       {self.to_sym => true}
     end

metadata

@@ -1,14 +1,14 @@
 --- !ruby/object:Gem::Specification
 name: bodhi-slam
 version: !ruby/object:Gem::Version
-  version: 0.1.0
+  version: 0.2.0
 platform: ruby
 authors:
 - willdavis
 autorequire: 
 bindir: bin
 cert_chain: []
-date: 2015-06-23 00:00:00.000000000 Z
+date: 2015-06-29 00:00:00.000000000 Z
 dependencies:
 - !ruby/object:Gem::Dependency
   name: net-http-persistent
@@ -24,20 +24,6 @@ dependencies:
     - - "~>"
       - !ruby/object:Gem::Version
         version: '2.9'
-- !ruby/object:Gem::Dependency
-  name: factory_girl
-  requirement: !ruby/object:Gem::Requirement
-    requirements:
-    - - "~>"
-      - !ruby/object:Gem::Version
-        version: '4.5'
-  type: :runtime
-  prerelease: false
-  version_requirements: !ruby/object:Gem::Requirement
-    requirements:
-    - - "~>"
-      - !ruby/object:Gem::Version
-        version: '4.5'
 - !ruby/object:Gem::Dependency
   name: faraday
   requirement: !ruby/object:Gem::Requirement
@@ -108,7 +94,7 @@ dependencies:
     - - ">="
       - !ruby/object:Gem::Version
         version: '0'
-description: BodhiSlam is an ORM for the Bodhi API and helps with randomly generating.
+description: 
 email: will.davis@hotschedules.com
 executables: []
 extensions: []
@@ -118,12 +104,14 @@ files:
 - lib/bodhi-slam/context.rb
 - lib/bodhi-slam/enumerations.rb
 - lib/bodhi-slam/errors.rb
+- lib/bodhi-slam/factory.rb
 - lib/bodhi-slam/resource.rb
 - lib/bodhi-slam/types.rb
 - lib/bodhi-slam/validations.rb
 - lib/bodhi-slam/validators.rb
 - lib/bodhi-slam/validators/blank.rb
 - lib/bodhi-slam/validators/email.rb
+- lib/bodhi-slam/validators/length.rb
 - lib/bodhi-slam/validators/matches.rb
 - lib/bodhi-slam/validators/max.rb
 - lib/bodhi-slam/validators/min.rb
@@ -152,8 +140,8 @@ required_rubygems_version: !ruby/object:Gem::Requirement
       version: '0'
 requirements: []
 rubyforge_project: 
-rubygems_version: 2.2.2
+rubygems_version: 2.4.5
 signing_key: 
 specification_version: 4
-summary: Ruby bindings for the Bodhi API
+summary: Ruby bindings for the Bodhi API + factories for random data generation
 test_files: []