new_cfoundry 4.8.2

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

@@ -0,0 +1,170 @@
+module CFoundry
+  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/cfoundry/v2/model_magic/has_summary.rb

@@ -0,0 +1,49 @@
+module CFoundry::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/cfoundry/v2/model_magic/query_multi_value_helper.rb

@@ -0,0 +1,21 @@
+module CFoundry::V2
+  module ModelMagic
+    module QueryValueHelper
+      class QueryMultiValue
+        attr_accessor :query_values
+
+        def initialize(*query_hashes)
+          self.query_values = query_hashes.collect do |query_hash|
+            QueryValue.new query_hash
+          end
+        end
+
+        def collect_values(key)
+          query_values.collect do |value|
+            "#{key}#{value}"
+          end.join(';')
+        end
+      end
+    end
+  end
+end

data/lib/cfoundry/v2/model_magic/query_value_helper.rb

@@ -0,0 +1,33 @@
+module CFoundry::V2
+  module ModelMagic
+    module QueryValueHelper
+      class QueryValue
+        attr_accessor :comparator, :value
+        def initialize(params)
+          self.comparator = params[:comparator] || params[:comp] || ':'
+          self.value = params[:value]
+        end
+
+        def to_s
+          "#{comparator_string}#{value_string}"
+        end
+
+        def comparator_string
+          if comparator.downcase == 'in' || value.is_a?(Array)
+            " IN "
+          else
+            comparator
+          end
+        end
+
+        def value_string
+          if value.is_a? Array
+            value.join(",")
+          else
+            value
+          end
+        end
+      end
+    end
+  end
+end

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

@@ -0,0 +1,39 @@
+module CFoundry::V2
+  module ModelMagic::QueryableBy
+    def queryable_by(*names)
+      klass = self
+      singular = object_name
+      plural = plural_object_name
+
+      query = ::CFoundry::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/cfoundry/v2/model_magic/to_many.rb

@@ -0,0 +1,138 @@
+module CFoundry::V2::ModelMagic
+  module ToMany
+    def to_many(plural, opts = {})
+      to_many_relations[plural] = opts
+
+      singular = plural.to_s.sub(/s$/, "").to_sym
+
+      include ::CFoundry::V2::QUERIES[singular]
+
+      object = opts[:as] || singular
+
+      kls = object.to_s.camelcase
+
+      #
+      # def MODELs
+      #
+      define_method(plural) do |*args|
+        klass = CFoundry::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]
+
+        CFoundry::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]
+
+        CFoundry::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]
+
+        CFoundry::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

data/lib/cfoundry/v2/model_magic/to_one.rb

@@ -0,0 +1,81 @@
+module CFoundry::V2::ModelMagic
+  module ToOne
+    def to_one(name, opts = {})
+      to_one_relations[name] = opts
+
+      association_name = opts[:as] || name
+      default = opts[:default]
+
+      if has_default = opts.key?(:default)
+        defaults[:"#{name}_guid"] = default
+      end
+
+      #
+      # def MODEL
+      #
+      define_method(name) do
+        return @cache[name] if @cache.key?(name)
+        return @client.send(association_name) unless persisted?
+
+        @cache[name] =
+          if @manifest && @manifest[:entity].key?(name)
+            @client.send(:"make_#{association_name}", @manifest[:entity][name])
+          elsif url = send("#{name}_url")
+            @client.send(:"#{association_name}_from", url)
+          else
+            default
+          end
+      end
+
+      #
+      # def create_MODEL
+      #
+      define_method("create_#{name}") do |*args|
+        associated_instance = @client.send(:"#{association_name}")
+        args.first.each do |name, value|
+          associated_instance.send("#{name}=", value)
+        end if args.first.is_a? Hash
+
+        associated_instance.create!
+        self.send("#{name}=", associated_instance)
+      end
+
+      #
+      # def MODEL_url
+      #
+      define_method(:"#{name}_url") do
+        manifest[:entity][:"#{name}_url"]
+      end
+
+      #
+      # def MODEL=
+      #
+      define_method(:"#{name}=") do |assigned_value|
+        klass = self.class.objects[association_name]
+
+        unless has_default && assigned_value == default
+          CFoundry::Validator.validate_type(assigned_value, klass)
+        end
+
+        @manifest ||= {}
+        @manifest[:entity] ||= {}
+
+        old_guid = @manifest[:entity][:"#{name}_guid"]
+        association_guid = assigned_value ? assigned_value.guid : nil
+
+        if old_guid != (association_guid)
+          old_obj =
+            @cache[name] || klass.new(@client, old_guid, @manifest[:entity][name])
+
+          @changes[name] = [old_obj, assigned_value]
+        end
+
+        @cache[name] = assigned_value
+
+        @manifest[:entity][:"#{name}_guid"] = association_guid
+        @diff[:"#{name}_guid"] = association_guid
+        assigned_value
+      end
+    end
+  end
+end

data/lib/cfoundry/v2/model_magic.rb

@@ -0,0 +1,134 @@
+require "cfoundry/validator"
+require "cfoundry/v2/model_magic/client_extensions"
+require "cfoundry/v2/model_magic/has_summary"
+require "cfoundry/v2/model_magic/attribute"
+require "cfoundry/v2/model_magic/to_one"
+require "cfoundry/v2/model_magic/to_many"
+require "cfoundry/v2/model_magic/queryable_by"
+require "cfoundry/v2/model_magic/query_value_helper"
+require "cfoundry/v2/model_magic/query_multi_value_helper"
+
+module CFoundry::V2
+  # object name -> module containing query methods
+  #
+  # e.g. app -> { app_by_name, app_by_space_guid, ... }
+  QUERIES = Hash.new do |h, k|
+    h[k] = Module.new
+  end
+
+  module BaseClientMethods
+  end
+
+  module ClientMethods
+  end
+
+  module ModelMagic
+    include ModelMagic::ClientExtensions
+    include ModelMagic::HasSummary
+    include ModelMagic::Attribute
+    include ModelMagic::ToOne
+    include ModelMagic::ToMany
+    include ModelMagic::QueryableBy
+    include ModelMagic::QueryValueHelper
+
+    attr_reader :scoped_organization, :scoped_space
+
+    def object_name
+      @object_name ||=
+        name.split("::").last.gsub(
+          /([a-z])([A-Z])/,
+          '\1_\2').downcase.to_sym
+    end
+
+    def plural_object_name
+      :"#{object_name}s"
+    end
+
+    def defaults
+      @defaults ||= {}
+    end
+
+    def attributes
+      @attributes ||= {}
+    end
+
+    def to_one_relations
+      @to_one_relations ||= {}
+    end
+
+    def to_many_relations
+      @to_many_relations ||= {}
+    end
+
+    def inherited(klass)
+      add_client_methods(klass)
+      has_summary
+    end
+
+    def scoped_to_organization(relation = :organization)
+      @scoped_organization = relation
+    end
+
+    def scoped_to_space(relation = :space)
+      @scoped_space = relation
+    end
+
+    # To query a single attribute using equality,
+    # you can use :query => ["attribute", "value"]
+    #
+    # To query multiple attributes, you can specify
+    # a hash of attributes to values, where the values
+    # can be:
+    #   A single value with equality
+    #     :query => {attr1: 'value1', attr2: 'value2'}
+    #   Multiple values for an attribute
+    #     :query => {attr1: ['value1', 'value2']}
+    #   Complex comparisons i.e ('<', '>', '<=', '>=')
+    #     :query => {attr1: QueryValue.new(comparator: '>', value: 'VALUE')}
+    #
+    # QueryValue can be found in CFoundry::V2::ModelMagic::QueryValueHelper
+    # You can include this module in your class to access QueryValue directly
+    # priting is handled by #to_s
+    def self.params_from(args)
+      options, _ = args
+      options ||= {}
+      options[:depth] ||= 1
+
+      params = {}
+      options.each do |k, v|
+        case k
+        when :depth
+          params[:"inline-relations-depth"] = v
+        when :query
+          if v.is_a? Array
+            params[:q] = v.join(":")
+          else
+            params[:q] = query_from_hash(v)
+          end
+        when :user_provided
+          params[:"return_user_provided_service_instances"] = v
+        else
+          params[k] = v
+        end
+      end
+
+      params
+    end
+
+    def self.query_from_hash(query_params)
+      query_params.collect do |key, value|
+        case value
+          when Array
+            qv = QueryValue.new(:comp => 'IN', :value => value)
+            "#{key}#{qv}"
+          when QueryValue
+            "#{key}#{value}"
+          when QueryMultiValue
+            value.collect_values(key)
+          else
+            "#{key}:#{value}"
+        end
+      end.join(";")
+    end
+  end
+end

data/lib/cfoundry/v2/organization.rb

@@ -0,0 +1,44 @@
+require 'cfoundry/v2/model'
+require "cfoundry/v2/helper"
+
+module CFoundry::V2
+  class Organization < Model
+    extend Helper
+
+    attribute :name, :string
+    attribute :billing_enabled, :boolean
+    attribute :status, :string
+
+    to_many   :spaces
+    to_many   :domains
+    to_many   :users
+    to_many   :managers, :as => :user
+    to_many   :billing_managers, :as => :user
+    to_many   :auditors, :as => :user
+
+    to_many_support   :spaces
+    to_many_support   :domains
+    to_many_support   :users
+    to_many_support   :managers
+    to_many_support   :billing_managers
+    to_many_support   :auditors
+
+    to_one    :quota_definition
+
+    queryable_by :name, :space_guid, :user_guid, :manager_guid,
+      :billing_manager_guid, :auditor_guid
+
+    def delete_user_from_all_roles(user)
+      remove_user(user)
+      remove_manager(user)
+      remove_billing_manager(user)
+      remove_auditor(user)
+
+      spaces.each do |space|
+        space.remove_developer(user)
+        space.remove_auditor(user)
+        space.remove_manager(user)
+      end
+    end
+  end
+end