bodhi-slam 0.6.1 → 0.7.1

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA1:
-  metadata.gz: 2740f7bb58fef86f5fcb168c16736c0c043f7825
-  data.tar.gz: 5211d0755728d31d4ffdf18ad60f755511b8eccc
+  metadata.gz: 142c61ba57d9623f1875dc7ad3ef1802a4c26c55
+  data.tar.gz: 4bc85952eebd17b260acab63647829f44773ec87
 SHA512:
-  metadata.gz: 7a650291911ad699c807cf808b4dde162146cf395ab18e2c47057400956743cc0f8091a7ced958b048ffc55b9e3b2e8aa88977e1142c64c12cb9d0549d2dead5
-  data.tar.gz: 089278eff165608ff8f4bc45858aa678f22cf32ce9eda6d68828a6595dd32496fe66a3a61c4898b6630738732ebbd31bb9ba8b726d0eb212e766a06879f5917c
+  metadata.gz: 6144923d080241629cf3c137b89094bc5402df06289ec93ebe01ceba94059af8f8dd8e4d3745a4759500f4da9a57f7a2a3a2119c90ca1a65572da89aabe7f869
+  data.tar.gz: 6a71e114c72b1b31bae451a26e1c797cdb70e175c5cb91432c3531fcf69c5ac185aa981ff1cf6b93b0027f8e976e00c9b2dd91689b008d5885438ce229d9e5ad

data/lib/bodhi-slam/associations.rb

@@ -0,0 +1,157 @@
+module Bodhi
+  module Associations
+    module ClassMethods
+      def associations; @associations; end
+
+      def has_one(association_name, options={})
+        options = Bodhi::Support.symbolize_keys(options)
+        define_association(:has_one, association_name, options)
+
+        # Define a new helper method to get the association
+        define_method(association_name) do
+          association = self.class.associations[association_name.to_sym]
+          query = Bodhi::Query.new(association[:class_name]).from(self.bodhi_context)
+
+          if association[:through]
+            through_query = Bodhi::Query.new(association[:through][:class_name]).from(self.bodhi_context)
+            through_query.where(association[:through][:foreign_key].to_sym => self.send(association[:primary_key]))
+            through_query.select(association[:through][:primary_key])
+
+            puts through_query.url
+
+            instance_id = through_query.first.send(association[:through][:primary_key])
+            query.where(association[:foreign_key].to_sym => instance_id)
+          else
+            instance_id = self.send(association[:primary_key])
+            query.where(association[:foreign_key].to_sym => instance_id)
+          end
+
+          query.and(association[:query])
+
+          puts query.url
+
+          query.first
+        end
+      end
+
+      def has_many(association_name, options={})
+        options = Bodhi::Support.symbolize_keys(options)
+        define_association(:has_many, association_name, options)
+
+        # Define a new helper method to get the association
+        define_method(association_name) do
+
+          # Get the value from the instance object's source_key. Default is :sys_id
+          association = self.class.associations[association_name.to_sym]
+          query = Bodhi::Query.new(association[:class_name]).from(self.bodhi_context)
+
+          if association[:through]
+            through_query = Bodhi::Query.new(association[:through][:class_name]).from(self.bodhi_context)
+            through_query.where(association[:through][:foreign_key].to_sym => self.send(association[:primary_key]))
+            through_query.select(association[:through][:primary_key])
+
+            puts through_query.url
+
+            method_chain = association[:through][:primary_key].split('.')
+            if method_chain.size == 1
+              instance_ids = through_query.all.map{ |item| item.send(association[:through][:primary_key]) }
+            else
+              instance_ids = through_query.all.map do |item|
+                method_chain.reduce(item){ |memo, method| memo.send(method) }
+              end
+            end
+
+            query.where(association[:foreign_key].to_sym => { "$in" => instance_ids })
+          else
+            instance_id = self.send(association[:primary_key])
+            if instance_id.is_a?(Array)
+              query.where(association[:foreign_key].to_sym => { "$in" => instance_id })
+            else
+              query.where(association[:foreign_key].to_sym => instance_id)
+            end
+          end
+
+          query.and(association[:query])
+          puts query.url
+          query.all
+        end
+      end
+
+      def belongs_to(association_name, options={})
+        options = Bodhi::Support.symbolize_keys(options)
+        define_association(:belongs_to, association_name, options)
+
+        # Define a new helper method to get the association
+        define_method(association_name) do
+
+          # Get the value from the instance object's source_key. Default is :sys_id
+          association = self.class.associations[association_name.to_sym]
+          instance_id = self.send(association[:primary_key])
+
+          # Define & call the query.  Returns a single Object or nil
+          query = Bodhi::Query.new(association[:class_name]).from(self.bodhi_context)
+          query.where(association[:foreign_key].to_sym => instance_id)
+          query.and(association[:query])
+
+          puts query.url
+          query.first
+        end
+      end
+
+      private
+      def define_association(type, name, options)
+        options.merge!(association_type: type)
+
+        if options[:class_name].nil?
+          options[:class_name] = Bodhi::Support.camelize(name.to_s)
+        end
+
+        if options[:through].is_a?(String)
+          case options[:association_type]
+          when :has_one
+            options[:through] = {
+              class_name: Bodhi::Support.camelize(options[:through]),
+              foreign_key: Bodhi::Support.underscore(self.name)+"_id",
+              primary_key: "sys_id"
+            }
+            options[:foreign_key] = Bodhi::Support.underscore(options[:through][:class_name])+"_id"
+          when :has_many
+            options[:through] = {
+              class_name: Bodhi::Support.camelize(options[:through]),
+              foreign_key: Bodhi::Support.underscore(self.name)+"_id",
+              primary_key: Bodhi::Support.underscore(options[:class_name])+"_id"
+            }
+            options[:foreign_key] = "sys_id"
+          end
+        end
+
+        case type
+        when :belongs_to
+          if options[:foreign_key].nil?
+            options[:foreign_key] = "sys_id"
+          end
+
+          if options[:primary_key].nil?
+            options[:primary_key] = Bodhi::Support.underscore(options[:class_name])+"_id"
+          end
+        else
+          if options[:foreign_key].nil?
+            options[:foreign_key] = Bodhi::Support.underscore(self.name)+"_id"
+          end
+
+          if options[:primary_key].nil?
+            options[:primary_key] = "sys_id"
+          end
+        end
+
+        options[:query].nil? ? options[:query] = Hash.new : options[:query]
+        @associations[name.to_sym] = options
+      end
+    end
+
+    def self.included(base)
+      base.extend(ClassMethods)
+      base.instance_variable_set(:@associations, Hash.new)
+    end
+  end
+end

data/lib/bodhi-slam/factory.rb

@@ -76,8 +76,17 @@ module Bodhi
     #   Resource.factory.add_generator("name", type: "String")
     #   Resource.factory.add_generator("test", type: "Integer", multi: true, required: true)
     def add_generator(name, options)
+      if options.is_a?(Proc)
+        @generators[name.to_sym] = options
+      else
+        @generators[name.to_sym] = build_default_generator(options)
+      end
+    end
+
+    private
+    def build_default_generator(options)
       options = options.reduce({}) do |memo, (k, v)| 
-        memo.merge({ k.to_s.gsub(/([A-Z]+)([A-Z][a-z])/,'\1_\2').gsub(/([a-z\d])([A-Z])/,'\1_\2').tr("-", "_").downcase.to_sym => v})
+        memo.merge({ Bodhi::Support.underscore(k.to_s).to_sym => v})
       end
 
       case options[:type]
@@ -129,9 +138,9 @@ module Bodhi
 
       when "DateTime"
         if options[:multi]
-          generator = lambda { [*0..5].sample.times.collect{ Time.at(rand * Time.now.to_i).iso8601 } }
+          generator = lambda { [*0..5].sample.times.collect{ Time.at(rand * Time.now.to_i) } }
         else
-          generator = lambda { Time.at(rand * Time.now.to_i).iso8601 }
+          generator = lambda { Time.at(rand * Time.now.to_i) }
         end
 
       when "Integer"
@@ -230,8 +239,6 @@ module Bodhi
           end
         end
       end
-
-      @generators[name.to_sym] = generator
     end
 
   end

data/lib/bodhi-slam/properties.rb

@@ -62,6 +62,8 @@ module Bodhi
             attributes[property] = value.attributes.delete_if { |k, v| v.nil? }
           elsif value.is_a?(Array) && value.first.respond_to?(:attributes)
             attributes[property] = value.map(&:attributes).collect{ |item| item.delete_if { |k, v| v.nil? } }
+          elsif value.is_a?(Time)
+            attributes[property] = value.iso8601
           else
             attributes[property] = value
           end

data/lib/bodhi-slam/queries.rb

@@ -5,7 +5,7 @@ module Bodhi
     def initialize(klass, controller="resources")
       @controller = controller
       @klass = Object.const_get(klass.to_s)
-      @criteria = []
+      @criteria = {}
       @fields = []
       @paging = {}
       @sorting = {}
@@ -13,7 +13,7 @@ module Bodhi
 
     def clear!
       @context = nil
-      @criteria.clear
+      @criteria = {}
       @fields.clear
       @paging.clear
       @sorting.clear
@@ -31,14 +31,8 @@ module Bodhi
       end
       params = []
 
-      unless criteria.empty?
-        if criteria.size > 1
-          where_string = "{$and:[#{criteria.join(',')}]}"
-        else
-          where_string = criteria.join
-        end
-
-        params << "where=#{where_string}"
+      unless criteria.keys.empty?
+        params << "where=#{criteria.to_json}"
       end
 
       unless fields.empty?
@@ -150,12 +144,14 @@ module Bodhi
     end
 
     def where(query)
-      unless query.is_a? String
-        raise ArgumentError.new("Expected String but received #{query.class}")
+      if query.is_a?(String)
+        json = JSON.parse(query)
+        query = Bodhi::Support.symbolize_keys(json)
+      else
+        query = Bodhi::Support.symbolize_keys(query)
       end
 
-      @criteria << query
-      @criteria.uniq!
+      @criteria.merge!(query)
       self
     end
     alias :and :where

data/lib/bodhi-slam/resource.rb

@@ -339,7 +339,7 @@ module Bodhi
 
     def self.included(base)
       base.extend(ClassMethods)
-      base.include(InstanceMethods, Bodhi::Validations, Bodhi::Properties, Bodhi::Indexes, Bodhi::Factories)
+      base.include(InstanceMethods, Bodhi::Properties, Bodhi::Associations, Bodhi::Validations, Bodhi::Indexes, Bodhi::Factories)
       base.instance_variable_set(:@embedded, false)
     end
   end

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

@@ -28,20 +28,7 @@ module Bodhi
         when "Link"
           klass = Hash
         when "DateTime"
-          single_comparator = lambda do |item|
-            begin
-              DateTime.iso8601(item)
-            rescue
-              false
-            end
-          end
-          array_comparator = lambda do |items|
-            begin
-              items.collect{ |item| DateTime.iso8601(item) }
-            rescue
-              false
-            end
-          end
+          klass = Time
         when "Object"
           klass = Hash
           single_message = "must be a JSON object"

data/lib/bodhi-slam.rb

@@ -13,6 +13,7 @@ require 'bodhi-slam/context'
 
 require 'bodhi-slam/properties'
 require 'bodhi-slam/indexes'
+require 'bodhi-slam/associations'
 
 require 'bodhi-slam/batches'
 require 'bodhi-slam/enumerations'
@@ -49,9 +50,9 @@ class BodhiSlam
     enumerations = Bodhi::Enumeration.find_all(context)
 
     if options[:include].is_a? Array
-      types = Bodhi::Type.where("{name: { $in: #{options[:include].map(&:to_s)} }}").from(context).all
+      types = Bodhi::Type.where(name: { "$in" => options[:include].map(&:to_s) }).from(context).all
     elsif options[:except].is_a? Array
-      types = Bodhi::Type.where("{name: { $nin: #{options[:except].map(&:to_s)} }}").from(context).all
+      types = Bodhi::Type.where(name: { "$nin" => options[:except].map(&:to_s) }).from(context).all
     else
       types = Bodhi::Type.find_all(context)
     end

metadata

@@ -1,14 +1,14 @@
 --- !ruby/object:Gem::Specification
 name: bodhi-slam
 version: !ruby/object:Gem::Version
-  version: 0.6.1
+  version: 0.7.1
 platform: ruby
 authors:
 - willdavis
 autorequire: 
 bindir: bin
 cert_chain: []
-date: 2015-12-16 00:00:00.000000000 Z
+date: 2016-01-08 00:00:00.000000000 Z
 dependencies:
 - !ruby/object:Gem::Dependency
   name: faraday
@@ -143,6 +143,7 @@ extensions: []
 extra_rdoc_files: []
 files:
 - lib/bodhi-slam.rb
+- lib/bodhi-slam/associations.rb
 - lib/bodhi-slam/batches.rb
 - lib/bodhi-slam/batches/resource.rb
 - lib/bodhi-slam/context.rb