bodhi-slam 0.7.3 → 0.8.0

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA1:
-  metadata.gz: 1fbe5ba6be9aceacf0acdc118e78a1a95ddd32ee
-  data.tar.gz: a7eae1661963319627d4694dfc90dd8bc5b1e327
+  metadata.gz: 7a728bbc653fe51f2aa54fd7fcc07874205616c8
+  data.tar.gz: ecd5e410504d479843dfcc4ebe2823815161c6fe
 SHA512:
-  metadata.gz: 938995fe271d5b2085a80c153931e3d0378c05daf587e247ef7baad00c2f48d4741b59299842c4042c0bbb3cf56ab44445983c200fbd6936e445d6ba3fb07dd1
-  data.tar.gz: 8f72e7317218ece3d876e7b803f738e55176e2de400bc368fa1c4d50bb1700c40f58be5d219fa1c2841d63a00a5d8a3cf18b0d1d393c64b30ae96213ef30ff75
+  metadata.gz: 3ca39c510350b552edbd793a8b0c42700f0c3125ca103f613fd8ee1a8c618076e2063f9630a739b7e67a99c05378f0b0d9b2a05249c2c3162fbba64c60d3d3e4
+  data.tar.gz: 32749263d7225845eb31e8780a02b446c19ad2a559fcc295bc01767157f1f15a958f90fd32bb904346f4595bad27e3262794b696287e631ed734e1c5c2482fab

data/lib/bodhi-slam/properties.rb

@@ -80,8 +80,13 @@ module Bodhi
       #   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)
+        params.each do |property, value|
+          property_options = self.class.properties[property.to_sym]
+          if property_options.nil?
+            send("#{property}=", value)
+          else
+            send("#{property}=", Bodhi::Support.coerce(value, property_options))
+          end
         end
       end
 

data/lib/bodhi-slam/simulation/normal_distribution.rb

@@ -0,0 +1,103 @@
+module Bodhi
+  module Simulation
+    class NormalDistributionCurve
+      include Bodhi::Properties
+      include Bodhi::Validations
+
+      property :mean, type: Float
+      property :mean_range, type: Float, multi: true
+
+      property :std_dev, type: Float
+      property :std_dev_range, type: Float, multi: true
+
+      property :scale, type: Float
+      property :title, type: String
+
+      validates :mean, required: true
+      validates :std_dev, required: true, min: 0.0001
+      validates :scale, required: true, min: 0.0, max: 1.0
+    end
+
+    class NormalDistribution
+      include Bodhi::Properties
+      include Bodhi::Validations
+
+      GAUSSIAN_FUNCTION = lambda{|x,u,o,s| 1/Math.sqrt(2*Math::PI*(o**2)) * Math.exp(-((x-u)**2)/(2*(o**2))) * s }
+
+      property :curves, type: Bodhi::Simulation::NormalDistributionCurve, multi: true
+      validates :curves, required: true
+
+      # ================
+      # Class Methods
+      # ================
+
+      # Accepts an array of Bodhi::Simulation::NormalDistribution::Curves objects
+      # Randomizes the +mean+ and +std_dev+ properties based on the given
+      # +mean_range+ and +std_dev_range+ properties
+      # Returns a new Bodhi::Simulation::NormalDistribution object with the randomized properties
+      #
+      #   curves = [{mean_range: [45.4, 50.0], std_dev_range: [1.2, 2.2], scale: 0.2, title: "Dinner rush"}]
+      #
+      #   Bodhi::Simulation::NormalDistribution.randomize(curves)
+      #     #=> #<Bodhi::Simulation::NormalDistribution @mean=47.1234 @std_dev=1.7543 @mean_range=[45.4, 50.0] @std_dev_range=[1.2, 2.2] @scale=0.2 @title="Dinner rush">
+      #
+      def self.randomize(curves)
+        unless curves.is_a?(Array)
+          raise ArgumentError.new("+curves+ must be an Array")
+        end
+
+        randomized_curves = curves.collect do |curve|
+          # Coerce the given +curve+ into a Bodhi::Simulation::NormalDistributionCurve
+          unless curve.is_a?(Bodhi::Simulation::NormalDistributionCurve)
+            begin
+              curve = Bodhi::Simulation::NormalDistributionCurve.new(curve)
+            rescue Exception => e
+              raise ArgumentError.new("The value: #{curve} is not a valid Bodhi::Simulation::NormalDistributionCurve object.  Error: #{e}")
+            end
+          end
+
+          # Check if the user supplied a range for mean and std_dev values
+          # These are optional properies, but a required for randomizing a curve
+          if curve.mean_range.nil? || curve.std_dev_range.nil?
+            raise ArgumentError.new("Unable to randomize the curve: #{curve.to_json}. Reason: missing mandatory +mean_range+ OR +std_dev_range+ properties.")
+          end
+
+          # Calculate a random mean and standard deviation
+          random_mean = rand(curve.mean_range[0]..curve.mean_range[1])
+          random_std_dev = rand(curve.std_dev_range[0]..curve.std_dev_range[1])
+
+          # Create a new randomized curve object
+          randomized_curve = curve.clone
+          randomized_curve.mean = random_mean
+          randomized_curve.std_dev = random_std_dev
+
+          # Check if the randomized curve is valid
+          if randomized_curve.invalid?
+            raise ArgumentError.new("Invalid Bodhi::Simulation::NormalDistributionCurve.  Reasons: #{randomized_curve.errors.to_a}")
+          end
+
+          # return the randomized curve
+          randomized_curve
+        end
+
+        # Return a new NormalDistribution with the randomized curves
+        Bodhi::Simulation::NormalDistribution.new(curves: randomized_curves)
+      end
+
+      # ================
+      # Instance Methods
+      # ================
+
+      # Evaluates the value of +y+ at position +x+
+      # Raises ArgumentError if +x+ is not a Float or Integer
+      def calculate(x)
+        unless x.is_a?(Integer) || x.is_a?(Float)
+          raise ArgumentError.new("Expected Integer or Float but recieved: #{x.class}")
+        end
+
+        curves.collect{ |curve| GAUSSIAN_FUNCTION.call(x, curve.mean, curve.std_dev, curve.scale) }.reduce(:+)
+      end
+
+    end
+  end
+end

data/lib/bodhi-slam/simulator.rb

@@ -0,0 +1,94 @@
+module Bodhi
+  class SimulationFrame
+    include Bodhi::Properties
+    include Bodhi::Validations
+
+    property :iteration, type: Integer, default: 0
+    property :time, type: DateTime
+  end
+
+  class Simulator
+    include Bodhi::Properties
+    include Bodhi::Validations
+
+    # Initial conditions
+    property :starts_at, type: DateTime
+    property :iterations, type: Integer
+    property :time_units, type: String
+    property :time_scale, type: Integer, default: 1
+
+    # Dynamic attributes
+    # Updated every iteration
+    property :current_frame, type: SimulationFrame
+
+    # Model validations
+    validates :starts_at, required: true
+    validates :iterations, required: true, min: 1
+    validates :time_units, required: true
+    validates :time_scale, min: 1
+
+    # ================
+    # Class Methods
+    # ================
+
+    # Run a new simulation using the given +settings+ and +&block+
+    # Yields the +simulation.current_time+ to the user defined +&block+
+    # Ignores +current_frame+ settings and zero's them before the simulation
+    #
+    #   Bodhi::Simulator.execute(starts_at: "2016-05-10", iterations: 10, time_units: "days") do |current_time|
+    #     # do some simulation stuff!
+    #   end
+    #
+    #   # You can even go crazy and do things like:
+    #   Bodhi::Simulator.execute(...) do |outer_time|
+    #     # do some simulation stuff!
+    #     Bodhi::Simulator.execute(...) do |inner_time|
+    #       # do a nested simulation!
+    #     end
+    #     # do more stuff after the netsted simulation...
+    #   end
+    def self.execute(settings, &block)
+      simulation = Bodhi::Simulator.new(settings)
+
+      if simulation.invalid?
+        raise ArgumentError.new("Invalid settings: #{simulation.errors.to_a}")
+      end
+
+      if simulation.current_frame.nil?
+        simulation.current_frame = Bodhi::SimulationFrame.new(iteration: 0, time: simulation.starts_at)
+      else
+        simulation.current_frame.iteration = 0
+        simulation.current_frame.time = simulation.starts_at
+      end
+
+      until simulation.complete?
+        yield simulation.current_frame.clone
+        simulation.increment
+      end
+    end
+
+    # ================
+    # Instance Methods
+    # ================
+
+    # returns true if the simulation has processed all iterations
+    def complete?
+      self.current_frame.iteration == self.iterations
+    end
+
+    # Increments the simulation loop by one iteration
+    # Updates +current_time+ to the new time offset
+    # Updates +current_iteration+ to the next iteration
+    #
+    #   simulation = Bodhi::Simulator.new(starts_at: "2016-05-13", iterations: 2, time_units: "days")
+    #   simulation.increment
+    #   simulation #=> #<Bodhi::Simulator @starts_at: "2016-05-13" @iterations: 2, @time_units: "days", @current_time: "2016-05-14", @current_iteration: 1 >
+    #
+    def increment
+      self.current_frame.iteration += 1
+      self.current_frame.time = self.starts_at + (self.current_frame.iteration * 1.send(self.time_units) * self.time_scale)
+    end
+  end
+end
+
+Dir[File.dirname(__FILE__) + "/simulation/*.rb"].each { |file| require file }

data/lib/bodhi-slam/types.rb

@@ -148,13 +148,13 @@ 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 })
+      klass = Object.const_set(type.name, Class.new { include Bodhi::Resource, ActiveModel::Model })
 
       type.properties.each_pair do |attr_name, attr_properties|
         attr_properties = Bodhi::Support.symbolize_keys(attr_properties)
 
         # remove Sanitizers
-        attr_properties.delete_if{ |key, value| [:trim, :unique, :default, :isCurrentUser, :toLower].include?(key) }
+        attr_properties.delete_if{ |key, value| [:trim, :unique, :default, :isCurrentUser, :toLower, :encrypt].include?(key) }
 
         # Do not add factories or validations for system properties
         unless attr_properties[:system] == true

data/lib/bodhi-slam.rb

@@ -7,6 +7,11 @@ require 'faraday-http-cache'
 require 'net/http/persistent'
 require 'regexp-examples'
 
+# Active Support
+require 'active_model'
+require 'active_support'
+require 'active_support/core_ext'
+
 require 'bodhi-slam/support'
 require 'bodhi-slam/validations'
 require 'bodhi-slam/errors'
@@ -25,6 +30,9 @@ require 'bodhi-slam/users'
 require 'bodhi-slam/profiles'
 require 'bodhi-slam/queries'
 
+# Discrete Event Simulator
+require 'bodhi-slam/simulator'
+
 class BodhiSlam
   # Defines a context to interact with the Bodhi API
   # Including a +server+, +namespace+, +username+, +password+ or +cookie+

metadata

@@ -1,14 +1,14 @@
 --- !ruby/object:Gem::Specification
 name: bodhi-slam
 version: !ruby/object:Gem::Version
-  version: 0.7.3
+  version: 0.8.0
 platform: ruby
 authors:
 - willdavis
 autorequire: 
 bindir: bin
 cert_chain: []
-date: 2016-01-14 00:00:00.000000000 Z
+date: 2016-05-17 00:00:00.000000000 Z
 dependencies:
 - !ruby/object:Gem::Dependency
   name: faraday
@@ -66,6 +66,20 @@ dependencies:
     - - "~>"
       - !ruby/object:Gem::Version
         version: '2.9'
+- !ruby/object:Gem::Dependency
+  name: activemodel
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: '4.2'
+  type: :runtime
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: '4.2'
 - !ruby/object:Gem::Dependency
   name: json
   requirement: !ruby/object:Gem::Requirement
@@ -171,6 +185,8 @@ files:
 - lib/bodhi-slam/properties.rb
 - lib/bodhi-slam/queries.rb
 - lib/bodhi-slam/resource.rb
+- lib/bodhi-slam/simulation/normal_distribution.rb
+- lib/bodhi-slam/simulator.rb
 - lib/bodhi-slam/support.rb
 - lib/bodhi-slam/types.rb
 - lib/bodhi-slam/types/index.rb
@@ -209,7 +225,7 @@ required_rubygems_version: !ruby/object:Gem::Requirement
       version: '0'
 requirements: []
 rubyforge_project: 
-rubygems_version: 2.4.5
+rubygems_version: 2.5.1
 signing_key: 
 specification_version: 4
 summary: Ruby bindings for the Bodhi API & factories for random data generation