jfoundry 0.1.0.pre

data/lib/jfoundry/v2/model.rb

@@ -0,0 +1,209 @@
+require "multi_json"
+require "jfoundry/v2/model_magic"
+
+module JFoundry::V2
+  class Model
+    include ActiveModel::Validations
+
+    @@objects = {}
+
+    extend ModelMagic
+
+    class << self
+      def objects
+        @@objects
+      end
+
+      def inherited(klass)
+        @@objects[klass.object_name] = klass
+        super
+      end
+    end
+
+    attr_accessor :guid, :cache, :changes
+    attr_reader :created_at, :updated_at
+    attr_reader :diff
+
+    def initialize(guid, client, manifest = nil, partial = false)
+      @guid = guid
+      @client = client
+      @manifest = manifest
+      @partial = partial
+      @cache = {}
+      @diff = {}
+      @changes = {}
+    end
+
+    def created_at
+      timestamp = @manifest.try(:[], :metadata).try(:[], :created_at)
+      DateTime.parse(timestamp) if timestamp.present?
+    end
+
+    def updated_at
+      timestamp = @manifest.try(:[], :metadata).try(:[], :updated_at)
+      DateTime.parse(timestamp) if timestamp.present?
+    end
+
+    def manifest
+      @manifest ||= @client.base.send(object_name, @guid)
+    end
+
+    def partial?
+      @partial
+    end
+
+    def changed?
+      !@changes.empty?
+    end
+
+    def inspect
+      "\#<#{self.class.name} '#@guid'>"
+    end
+
+    def object_name
+      @object_name ||= self.class.object_name
+    end
+
+    def plural_object_name
+      @plural_object_name ||= self.class.plural_object_name
+    end
+
+    def invalidate!
+      @manifest = nil
+      @partial = false
+      @cache = {}
+      @diff = {}
+      @changes = {}
+    end
+
+    def create
+      create!
+      true
+    rescue JFoundry::APIError => e
+      if e.instance_of? JFoundry::APIError
+        errors.add(:base, :cc_client)
+      else
+        errors.add(attribute_for_error(e), e.message)
+      end
+      false
+    end
+
+    def attribute_for_error(error)
+      :base
+    end
+
+    # this does a bit of extra processing to allow for
+    # `delete!' followed by `create!'
+    def create!
+      payload = {}
+
+      @manifest ||= {}
+      @manifest[:entity] ||= {}
+
+      @manifest[:entity].each do |k, v|
+        if v.is_a?(Hash) && v.key?(:metadata)
+          # skip; there's a _guid attribute already
+        elsif v.is_a?(Array) && !v.empty? && v.all? { |x|
+          x.is_a?(Hash) && x.key?(:metadata)
+        }
+          singular = k.to_s.sub(/s$/, "")
+
+          payload[:"#{singular}_guids"] = v.collect do |x|
+            if x.is_a?(Hash) && x.key?(:metadata)
+              x[:metadata][:guid]
+            else
+              x
+            end
+          end
+        else
+          payload[k] = v
+        end
+      end
+
+      #puts "payload: ", payload
+      #puts "plural_object_name: ", plural_object_name
+      @manifest = @client.base.post("v2", plural_object_name,
+        :content => :json,
+        :accept => :json,
+        :payload => payload
+      )
+
+      @guid = @manifest[:metadata][:guid]
+
+      @diff.clear
+
+      true
+    end
+
+    def update!
+      @manifest = @client.base.put("v2", plural_object_name, guid,
+        :content => :json,
+        :accept => :json,
+        :payload => @diff
+      )
+
+      @diff.clear
+
+      true
+    end
+
+    def delete(options = {})
+      delete!(options)
+    rescue JFoundry::APIError => e
+      if e.instance_of? JFoundry::APIError
+        errors.add(:base, :cc_client)
+      else
+        errors.add(attribute_for_error(e), e.message)
+      end
+      false
+    end
+
+    def delete!(options = {})
+      @client.base.delete("v2", plural_object_name, guid, :params => options)
+
+      @deleted = true
+
+      @diff.clear
+
+      if @manifest
+        @manifest.delete :metadata
+      end
+
+      true
+    end
+
+    def to_param
+      persisted? ? @guid.to_s : nil
+    end
+
+    def to_key
+      persisted? ? [@guid] : nil
+    end
+
+    def persisted?
+      @guid && !@deleted
+    end
+
+    def exists?
+      invalidate!
+      manifest
+      true
+    rescue JFoundry::NotFound
+      false
+    end
+
+    def query_target(klass)
+      self
+    end
+
+    def eql?(other)
+      other.is_a?(self.class) && @guid == other.guid
+    end
+
+    alias :== :eql?
+
+    def hash
+      @guid.hash
+    end
+  end
+end

data/lib/jfoundry/v2/model_magic/attribute.rb

@@ -0,0 +1,49 @@
+module JFoundry::V2::ModelMagic
+  module Attribute
+    def attribute(name, type, opts = {})
+      attributes[name] = opts
+      json_name = opts[:at] || name
+
+      default = opts[:default]
+
+      if has_default = opts.key?(:default)
+        defaults[name] = default
+      end
+
+      #
+      # def ATTRIBUTE
+      #
+      define_method(name) do
+        return @cache[name] if @cache.key?(name)
+        return nil unless persisted?
+
+        @cache[name] =
+          if manifest[:entity].key?(json_name)
+            manifest[:entity][json_name]
+          else
+            default
+          end
+      end
+
+      #
+      # def ATTRIBUTE=
+      #
+      define_method(:"#{name}=") do |val|
+        unless has_default && val == default
+          JFoundry::Validator.validate_type(val, type)
+        end
+
+        @cache[name] = val
+
+        @manifest ||= {}
+        @manifest[:entity] ||= {}
+
+        old = @manifest[:entity][json_name]
+        @changes[name] = [old, val] if old != val
+        @manifest[:entity][json_name] = val
+
+        @diff[json_name] = val
+      end
+    end
+  end
+end

data/lib/jfoundry/v2/model_magic/client_extensions.rb

@@ -0,0 +1,170 @@
+module JFoundry
+  module V2
+    module ModelMagic
+      module ClientExtensions
+        def add_client_methods(klass)
+          singular = klass.object_name
+          plural = klass.plural_object_name
+
+          define_base_client_methods do
+            #
+            # def client.MODEL
+            #
+            define_method(singular) do |guid, *args|
+              get("v2", plural, guid,
+                :accept => :json,
+                :params => ModelMagic.params_from(args)
+              )
+            end
+
+            #
+            # def client.MODELs
+            #
+            define_method(plural) do |*args|
+              all_pages(
+                get("v2", plural,
+                  :accept => :json,
+                  :params => ModelMagic.params_from(args)
+                )
+              )
+            end
+
+            #
+            # def client.MODELs_first_page
+            #
+            define_method(:"#{plural}_first_page") do |*args|
+              get("v2", plural,
+                :accept => :json,
+                :params => ModelMagic.params_from(args)
+              )
+            end
+
+            #
+            # def client.MODELs_for_each
+            #
+            define_method(:"#{plural}_for_each") do |*args, &block|
+              for_each(get("v2", plural,
+                  :accept => :json,
+                  :params => ModelMagic.params_from(args)
+                ),
+                &block
+              )
+            end
+          end
+
+
+          define_client_methods do
+            #
+            # def client.MODEL
+            #
+            define_method(singular) do |*args|
+              guid, partial, _ = args
+
+              x = klass.new(guid, self, nil, partial)
+
+              # when creating an object, automatically set the org/space
+              unless guid
+                if klass.scoped_organization && current_organization
+                  x.send(:"#{klass.scoped_organization}=", current_organization)
+                end
+
+                if klass.scoped_space && current_space
+                  x.send(:"#{klass.scoped_space}=", current_space)
+                end
+              end
+
+              x
+            end
+
+            #
+            # def client.MODELs
+            #
+            define_method(plural) do |*args|
+              # use current org/space
+              if klass.scoped_space && current_space
+                current_space.send(plural, *args)
+              elsif klass.scoped_organization && current_organization
+                current_organization.send(plural, *args)
+              else
+                @base.send(plural, *args).collect do |json|
+                  send(:"make_#{singular}", json)
+                end
+              end
+            end
+
+            #
+            # def client.MODELs_first_page
+            #
+            define_method(:"#{plural}_first_page") do |*args|
+              response = @base.send(:"#{plural}_first_page", *args)
+              results = response[:resources].collect do |json|
+                send(:"make_#{singular}", json)
+              end
+              {
+                  :next_page => !!response[:next_url],
+                  :results => results
+              }
+            end
+
+            #
+            # def client.MODELs_for_each
+            #
+            define_method(:"#{plural}_for_each") do |*args, &block|
+              @base.send(:"#{plural}_for_each", *args) do |json|
+                result = send(:"make_#{singular}", json)
+                block.call(result)
+              end
+            end
+
+            #
+            # def client.MODEL_from
+            #
+            define_method(:"#{singular}_from") do |path, *args|
+              send(
+                :"make_#{singular}",
+                @base.get(
+                  path,
+                  :accept => :json,
+                  :params => ModelMagic.params_from(args)))
+            end
+
+            #
+            # def client.MODELs_from
+            #
+            define_method(:"#{plural}_from") do |path, *args|
+              objs = @base.all_pages(
+                @base.get(
+                  path,
+                  :accept => :json,
+                  :params => ModelMagic.params_from(args)))
+
+              objs.collect do |json|
+                send(:"make_#{singular}", json)
+              end
+            end
+
+            #
+            # def client.make_MODEL
+            #
+            define_method(:"make_#{singular}") do |json|
+              klass.new(
+                json[:metadata][:guid],
+                self,
+                json)
+            end
+          end
+        end
+
+        private
+
+        def define_client_methods(&blk)
+          ClientMethods.module_eval(&blk)
+        end
+
+        def define_base_client_methods(&blk)
+          BaseClientMethods.module_eval(&blk)
+        end
+      end
+    end
+  end
+end

data/lib/jfoundry/v2/model_magic/has_summary.rb

@@ -0,0 +1,49 @@
+module JFoundry::V2::ModelMagic
+  module HasSummary
+    def has_summary(actions = {})
+      #
+      # def summary
+      #
+      define_method(:summary) do
+        @client.base.get("v2", plural_object_name, @guid, "summary", :accept => :json)
+      end
+
+      #
+      # def summarize!
+      #
+      define_method(:summarize!) do |*args|
+        body, _ = args
+
+        body ||= summary
+
+        body.each do |key, val|
+          if act = actions[key]
+            instance_exec(val, &act)
+
+          elsif self.class.attributes[key]
+            self.send(:"#{key}=", val)
+
+          elsif self.class.to_many_relations[key]
+            singular = key.to_s.sub(/s$/, "").to_sym
+
+            vals = val.collect do |sub|
+              obj = @client.send(singular, sub[:guid], true)
+              obj.summarize! sub
+              obj
+            end
+
+            self.send(:"#{key}=", vals)
+
+          elsif self.class.to_one_relations[key]
+            obj = @client.send(key, val[:guid], true)
+            obj.summarize! val
+
+            self.send(:"#{key}=", obj)
+          end
+        end
+
+        nil
+      end
+    end
+  end
+end

data/lib/jfoundry/v2/model_magic/queryable_by.rb

@@ -0,0 +1,39 @@
+module JFoundry::V2
+  module ModelMagic::QueryableBy
+    def queryable_by(*names)
+      klass = self
+      singular = object_name
+      plural = plural_object_name
+
+      query = ::JFoundry::V2::QUERIES[singular]
+
+      query.module_eval do
+        names.each do |name|
+          #
+          # def MODEL_by_ATTRIBUTE
+          #
+          define_method(:"#{singular}_by_#{name}") do |*args|
+            send(:"#{plural}_by_#{name}", *args).first
+          end
+
+          #
+          # def MODELs_by_ATTRIBUTE
+          #
+          define_method(:"#{plural}_by_#{name}") do |val, *args|
+            options, _ = args
+            options ||= {}
+            options[:query] = [name, val]
+
+            query_target(klass).send(plural, options)
+          end
+        end
+      end
+
+      const_set(:Queries, query)
+
+      ClientMethods.module_eval do
+        include query
+      end
+    end
+  end
+end

data/lib/jfoundry/v2/model_magic/to_many.rb

@@ -0,0 +1,138 @@
+module JFoundry::V2::ModelMagic
+  module ToMany
+    def to_many(plural, opts = {})
+      to_many_relations[plural] = opts
+
+      singular = plural.to_s.sub(/s$/, "").to_sym
+
+      include ::JFoundry::V2::QUERIES[singular]
+
+      object = opts[:as] || singular
+
+      kls = object.to_s.camelcase
+
+      #
+      # def MODELs
+      #
+      define_method(plural) do |*args|
+        klass = JFoundry::V2.const_get(kls)
+
+        opts, _ = args
+        opts ||= {}
+
+        if opts.empty? && cache = @cache[plural]
+          return cache
+        end
+
+        if @manifest && @manifest[:entity].key?(plural) && opts.empty?
+          objs = @manifest[:entity][plural]
+
+          if query = opts[:query]
+            find_by, find_val = query
+            objs = objs.select { |o| o[:entity][find_by] == find_val }
+          end
+
+          res =
+            objs.collect do |json|
+              @client.send(:"make_#{object}", json)
+            end
+        else
+          res =
+            @client.send(
+              :"#{klass.plural_object_name}_from",
+              "/v2/#{plural_object_name}/#@guid/#{plural}",
+              opts)
+        end
+
+        if opts.empty?
+          @cache[plural] = res
+        end
+
+        res
+      end
+
+      #
+      # def MODELs_url
+      #
+      define_method(:"#{plural}_url") do
+        manifest[:entity][:"#{plural}_url"]
+      end
+
+      #
+      # def add_MODEL
+      #
+      define_method(:"add_#{singular}") do |x|
+        klass = self.class.objects[object]
+
+        JFoundry::Validator.validate_type(x, klass)
+
+        if cache = @cache[plural]
+          cache << x unless cache.include?(x)
+        end
+
+        @client.base.put("v2", plural_object_name, @guid, plural, x.guid, :accept => :json)
+      end
+
+      #
+      # def create_MODEL
+      #
+      define_method("create_#{singular}") do |*args|
+        associated_instance = @client.send(:"#{singular}")
+        args.first.each do |name, value|
+          associated_instance.send("#{name}=", value)
+        end if args.first.is_a? Hash
+
+        associated_instance.create!
+        self.send(:"add_#{singular}", associated_instance)
+        associated_instance
+      end
+
+      #
+      # def remove_MODEL
+      #
+      define_method(:"remove_#{singular}") do |x|
+        klass = self.class.objects[object]
+
+        JFoundry::Validator.validate_type(x, klass)
+
+        if cache = @cache[plural]
+          cache.delete(x)
+        end
+
+        @client.base.delete("v2", plural_object_name, @guid, plural, x.guid, :accept => :json)
+      end
+
+      #
+      # def MODELs=
+      #
+      define_method(:"#{plural}=") do |xs|
+        klass = self.class.objects[object]
+
+        JFoundry::Validator.validate_type(xs, [klass])
+
+        @manifest ||= {}
+        @manifest[:entity] ||= {}
+
+        old = @manifest[:entity][:"#{singular}_guids"]
+        if old != xs.collect(&:guid)
+          old_objs =
+            @cache[plural] ||
+              if all = @manifest[:entity][plural]
+                all.collect do |m|
+                  klass.new(@client, m[:metadata][:guid], m)
+                end
+              elsif old
+                old.collect { |id| klass.new(@client, id) }
+              end
+
+          @changes[plural] = [old_objs, xs]
+        end
+
+        @cache[plural] = xs
+
+        @manifest[:entity][:"#{singular}_guids"] =
+          @diff[:"#{singular}_guids"] = xs.collect(&:guid)
+      end
+    end
+  end
+end