metasploit-model 0.27.3 → 0.27.4

data/lib/metasploit/model/association.rb

@@ -1,53 +1,50 @@
-module Metasploit
-  module Model
-    # Allows registering the class name of assocations similar to ActiveRecord associations, so that ActiveModel
-    # associations can be reflected with the same API as ActiveRecord associations.
-    module Association
-      extend ActiveSupport::Autoload
-      extend ActiveSupport::Concern
+# Allows registering the class name of assocations similar to ActiveRecord associations, so that ActiveModel
+# associations can be reflected with the same API as ActiveRecord associations.
+module Metasploit::Model::Association
+  extend ActiveSupport::Autoload
+  extend ActiveSupport::Concern
 
-      autoload :Error
-      autoload :Tree
+  autoload :Error
+  autoload :Reflection
+  autoload :Tree
 
-      # Defines DSL for define associations on ActiveModels with {#association}, which can then be retrieved in bulk
-      # with {#association_by_name} or a single association's reflection by name with {#reflect_on_association}.
-      module ClassMethods
-        # Registers an association.
-        #
-        # @param name [to_sym] Name of the association
-        # @param options [Hash{Symbol => String}]
-        # @option options [String] :class_name Name of association's class.
-        # @return [Metasploit::Model::Association::Reflection] the reflection of the registered association.
-        # @raise [Metasploit::Model::Invalid] if name is blank.
-        # @raise [Metasploit::Model::Invalid] if :class_name is blank.
-        def association(name, options={})
-          association = Metasploit::Model::Association::Reflection.new(
-              :model => self,
-              :name => name.to_sym,
-              :class_name => options[:class_name]
-          )
-          association.valid!
+  # Defines DSL for define associations on ActiveModels with {#association}, which can then be retrieved in bulk
+  # with {#association_by_name} or a single association's reflection by name with {#reflect_on_association}.
+  module ClassMethods
+    # Registers an association.
+    #
+    # @param name [to_sym] Name of the association
+    # @param options [Hash{Symbol => String}]
+    # @option options [String] :class_name Name of association's class.
+    # @return [Metasploit::Model::Association::Reflection] the reflection of the registered association.
+    # @raise [Metasploit::Model::Invalid] if name is blank.
+    # @raise [Metasploit::Model::Invalid] if :class_name is blank.
+    def association(name, options={})
+      association = Metasploit::Model::Association::Reflection.new(
+          :model => self,
+          :name => name.to_sym,
+          :class_name => options[:class_name]
+      )
+      association.valid!
 
-          association_by_name[association.name] = association
-        end
+      association_by_name[association.name] = association
+    end
 
-        # Associations registered with {#association}.
-        #
-        # @return [Hash{Symbol => Metasploit::Model::Association::Reflection}] Maps
-        #   {Metasploit::Model::Association::Reflection#name} to {Metasploit::Model::Association::Reflection}.
-        def association_by_name
-          @association_by_name ||= {}
-        end
+    # Associations registered with {#association}.
+    #
+    # @return [Hash{Symbol => Metasploit::Model::Association::Reflection}] Maps
+    #   {Metasploit::Model::Association::Reflection#name} to {Metasploit::Model::Association::Reflection}.
+    def association_by_name
+      @association_by_name ||= {}
+    end
 
-        # Returns reflection for association with the given name.
-        #
-        # @param name [#to_sym] name of the association whose reflection to retrieve.
-        # @return [nil] if no association with the given `name`.
-        # @return [Metasploit::Model::Association::Reflection] if association with the given `name`.
-        def reflect_on_association(name)
-          association_by_name[name.to_sym]
-        end
-      end
+    # Returns reflection for association with the given name.
+    #
+    # @param name [#to_sym] name of the association whose reflection to retrieve.
+    # @return [nil] if no association with the given `name`.
+    # @return [Metasploit::Model::Association::Reflection] if association with the given `name`.
+    def reflect_on_association(name)
+      association_by_name[name.to_sym]
     end
   end
-end
+end

data/lib/metasploit/model/association/error.rb

@@ -1,40 +1,36 @@
-module Metasploit
-  module Model
-    module Association
-      # Error raised by {Metasploit::Model::Association::ClassMethods#reflect_on_association!}.
-      class Error < Metasploit::Model::Error
-        #
-        # Attributes
-        #
+module Metasploit::Model::Association
+  # Error raised by {Metasploit::Model::Association::ClassMethods#reflect_on_association!}.
+  class Error < Metasploit::Model::Error
+    #
+    # Attributes
+    #
 
-        # @!attribute [r] model
-        #   ActiveModel on which the association with {#name} was not found.
-        #
-        #   @return [Class]
-        attr_reader :model
+    # @!attribute [r] model
+    #   ActiveModel on which the association with {#name} was not found.
+    #
+    #   @return [Class]
+    attr_reader :model
 
-        # @!attribute [r] name
-        #   Name of association that was not registered on {#model}.
-        #
-        #   @return [Symbol]
-        attr_reader :name
+    # @!attribute [r] name
+    #   Name of association that was not registered on {#model}.
+    #
+    #   @return [Symbol]
+    attr_reader :name
 
-        #
-        # Methods
-        #
+    #
+    # Methods
+    #
 
-        # @param attributes [Hash{Symbol => Object}]
-        # @option attributes [Class] :model ActiveModel that is missing association with :name.
-        # @option attributes [Symbol] :name name of the association that is missing.
-        # @raise [KeyError] if :model is not given
-        # @raise [KeyError] if :name is not given
-        def initialize(attributes={})
-          @model = attributes.fetch(:model)
-          @name = attributes.fetch(:name)
+    # @param attributes [Hash{Symbol => Object}]
+    # @option attributes [Class] :model ActiveModel that is missing association with :name.
+    # @option attributes [Symbol] :name name of the association that is missing.
+    # @raise [KeyError] if :model is not given
+    # @raise [KeyError] if :name is not given
+    def initialize(attributes={})
+      @model = attributes.fetch(:model)
+      @name = attributes.fetch(:name)
 
-          super("#{model} does not have #{name} association.")
-        end
-      end
+      super("#{model} does not have #{name} association.")
     end
   end
-end
+end

data/lib/metasploit/model/association/tree.rb

@@ -1,130 +1,124 @@
-module Metasploit
-  module Model
-    module Association
-      # Functions for turning a compact tree of compact as passed to
-      # {Metasploit::Model::Search::Association::ClassMethods#search_associations} into an expanded
-      # {Metasploit::Model::Search::Association::ClassMethods#search_association_tree}.
-      module Tree
-        # Expands a `compact` association into an expanded association tree.
-        #
-        # @param compact [Array, Hash{Symbol => Array,Hash,Symbol}, Symbol] a compact association as passed to
-        #   {Metasploit::Model::Search::Association::ClassMethods#search_associations}.
-        # @return [Hash{Symbol => Hash,nil}]
-        def self.expand(compact)
-          case compact
-            when Array
-              compact.reduce({}) { |hash, association|
-                hash.merge(expand(association))
-              }
-            when Hash
-              child_by_parent = compact
-
-              child_by_parent.each_with_object({}) { |(parent, child), hash|
-                hash[parent] = expand(child)
-              }
-            when Symbol
-              association = compact
-
-              {association => nil}
-          end
-        end
-
-        # @note Unlike `Hash#deep_merge`, `second_expanded`'s values aren't favored over `first`'s values.  Instead whichever
-        #   side is present is used and if both `first` and `second_expanded` are present, then their `Hash#key`s' values are
-        #   recursively merged.
-        #
-        # Merges two expanded association trees.
-        #
-        # @param first_expanded [nil, Hash{Symbol => nil,Hash}] An expanded association tree as from {expand}
-        # @param second_expanded [nil, Hash{Symbol => nil,Hash}] An expanded association tree as from {expand}
-        # @return [nil, Hash{Symbol => nil,Hash}] a new expanded association tree.
-        def self.merge(first_expanded, second_expanded)
-          if first_expanded.nil? && second_expanded.nil?
-            nil
-          elsif !first_expanded.nil? && second_expanded.nil?
-            first_expanded
-          elsif first_expanded.nil? && !second_expanded.nil?
-            second_expanded
-          else
-            first_keys = first_expanded.keys
-            key_set = Set.new(first_keys)
-
-            second_keys = second_expanded.keys
-            key_set.merge(second_keys)
-
-            key_set.each_with_object({}) do |key, merged|
-              first_child = first_expanded[key]
-              second_child = second_expanded[key]
-
-              merged[key] = merge(first_child, second_child)
-            end
-          end
-        end
-
-        # Calculates association operators for the `expanded` association tree.
-        #
-        # @param expanded [Hash{Symbol => Hash,nil}, nil] An expanded association tree.
-        # @param options [Hash{Symbol => Class}]
-        # @option options [Class, #reflect_on_association] :class The `Class` on which the top-level key associations in
-        #   `expanded` are declared.
-        # @return [Array<Metasploit::Model::Search::Operator::Association>]
-        def self.operators(expanded, options={})
-          expanded ||= {}
-
-          options.assert_valid_keys(:class)
-          klass = options.fetch(:class)
-
-          expanded.flat_map { |parent_association, child_tree|
-            reflection = reflect_on_association_on_class(parent_association, klass)
-            association_class = reflection.klass
-
-            association_search_with_operators = association_class.search_with_operator_by_name.each_value
-
-            child_tree_operators = operators(
-                child_tree,
-                class: reflection.klass
-            )
+# Functions for turning a compact tree of compact as passed to
+# {Metasploit::Model::Search::Association::ClassMethods#search_associations} into an expanded
+# {Metasploit::Model::Search::Association::ClassMethods#search_association_tree}.
+module Metasploit::Model::Association::Tree
+  # Expands a `compact` association into an expanded association tree.
+  #
+  # @param compact [Array, Hash{Symbol => Array,Hash,Symbol}, Symbol] a compact association as passed to
+  #   {Metasploit::Model::Search::Association::ClassMethods#search_associations}.
+  # @return [Hash{Symbol => Hash,nil}]
+  def self.expand(compact)
+    case compact
+      when Array
+        compact.reduce({}) { |hash, association|
+          hash.merge(expand(association))
+        }
+      when Hash
+        child_by_parent = compact
+
+        child_by_parent.each_with_object({}) { |(parent, child), hash|
+          hash[parent] = expand(child)
+        }
+      when Symbol
+        association = compact
+
+        {association => nil}
+    end
+  end
 
-            [association_search_with_operators, child_tree_operators].flat_map { |enumerator|
-              enumerator.map { |source_operator|
-                Metasploit::Model::Search::Operator::Association.new(
-                    association: parent_association,
-                    klass: klass,
-                    source_operator: source_operator
-                )
-              }
-            }
-          }
-        end
-
-        private
-
-        # Return the association reflection for `association` on `klass`.
-        #
-        # @param association [Symbol] name of an association on `klass`.
-        # @param klass [#reflect_on_association] `Class` on which `association` is declared.
-        # @return [#klass] Association reflection that can give the `#klass` pointed to by the association.
-        # @raise [Metasploit::Model::Association::Error] if `association` is not declared on `klass`.
-        # @raise [NameError] if `klass` does not respond to `reflect_on_association`.
-        def self.reflect_on_association_on_class(association, klass)
-          begin
-            reflection = klass.reflect_on_association(association)
-          rescue NameError
-            raise NameError,
-                  "#{self} does not respond to reflect_on_association.  " \
-                      "It can be added to ActiveModels by including Metasploit::Model::Association into the class."
-          end
+  # @note Unlike `Hash#deep_merge`, `second_expanded`'s values aren't favored over `first`'s values.  Instead whichever
+  #   side is present is used and if both `first` and `second_expanded` are present, then their `Hash#key`s' values are
+  #   recursively merged.
+  #
+  # Merges two expanded association trees.
+  #
+  # @param first_expanded [nil, Hash{Symbol => nil,Hash}] An expanded association tree as from {expand}
+  # @param second_expanded [nil, Hash{Symbol => nil,Hash}] An expanded association tree as from {expand}
+  # @return [nil, Hash{Symbol => nil,Hash}] a new expanded association tree.
+  def self.merge(first_expanded, second_expanded)
+    if first_expanded.nil? && second_expanded.nil?
+      nil
+    elsif !first_expanded.nil? && second_expanded.nil?
+      first_expanded
+    elsif first_expanded.nil? && !second_expanded.nil?
+      second_expanded
+    else
+      first_keys = first_expanded.keys
+      key_set = Set.new(first_keys)
+
+      second_keys = second_expanded.keys
+      key_set.merge(second_keys)
+
+      key_set.each_with_object({}) do |key, merged|
+        first_child = first_expanded[key]
+        second_child = second_expanded[key]
+
+        merged[key] = merge(first_child, second_child)
+      end
+    end
+  end
 
-          unless reflection
-            raise Metasploit::Model::Association::Error.new(
-                      model: klass,
-                      name: association
-                  )
-          end
+  # Calculates association operators for the `expanded` association tree.
+  #
+  # @param expanded [Hash{Symbol => Hash,nil}, nil] An expanded association tree.
+  # @param options [Hash{Symbol => Class}]
+  # @option options [Class, #reflect_on_association] :class The `Class` on which the top-level key associations in
+  #   `expanded` are declared.
+  # @return [Array<Metasploit::Model::Search::Operator::Association>]
+  def self.operators(expanded, options={})
+    expanded ||= {}
+
+    options.assert_valid_keys(:class)
+    klass = options.fetch(:class)
+
+    expanded.flat_map { |parent_association, child_tree|
+      reflection = reflect_on_association_on_class(parent_association, klass)
+      association_class = reflection.klass
+
+      association_search_with_operators = association_class.search_with_operator_by_name.each_value
+
+      child_tree_operators = operators(
+          child_tree,
+          class: reflection.klass
+      )
+
+      [association_search_with_operators, child_tree_operators].flat_map { |enumerator|
+        enumerator.map { |source_operator|
+          Metasploit::Model::Search::Operator::Association.new(
+              association: parent_association,
+              klass: klass,
+              source_operator: source_operator
+          )
+        }
+      }
+    }
+  end
 
-          reflection
-        end
-      end
+  private
+
+  # Return the association reflection for `association` on `klass`.
+  #
+  # @param association [Symbol] name of an association on `klass`.
+  # @param klass [#reflect_on_association] `Class` on which `association` is declared.
+  # @return [#klass] Association reflection that can give the `#klass` pointed to by the association.
+  # @raise [Metasploit::Model::Association::Error] if `association` is not declared on `klass`.
+  # @raise [NameError] if `klass` does not respond to `reflect_on_association`.
+  def self.reflect_on_association_on_class(association, klass)
+    begin
+      reflection = klass.reflect_on_association(association)
+    rescue NameError
+      raise NameError,
+            "#{self} does not respond to reflect_on_association.  " \
+                      "It can be added to ActiveModels by including Metasploit::Model::Association into the class."
     end
+
+    unless reflection
+      raise Metasploit::Model::Association::Error.new(
+                model: klass,
+                name: association
+            )
+    end
+
+    reflection
   end
-end
+end

data/lib/metasploit/model/author.rb

@@ -1,60 +1,54 @@
-require 'metasploit/model/translation'
+# Code shared between `Mdm::Author` and `Metasploit::Framework::Author`.
+module Metasploit::Model::Author
+  extend ActiveModel::Naming
+  extend ActiveSupport::Concern
 
-module Metasploit
-  module Model
-    # Code shared between `Mdm::Author` and `Metasploit::Framework::Author`.
-    module Author
-      extend ActiveModel::Naming
-      extend ActiveSupport::Concern
+  include Metasploit::Model::Translation
 
-      include Metasploit::Model::Translation
+  included do
+    include ActiveModel::MassAssignmentSecurity
+    include ActiveModel::Validations
+    include Metasploit::Model::Search
 
-      included do
-        include ActiveModel::MassAssignmentSecurity
-        include ActiveModel::Validations
-        include Metasploit::Model::Search
+    #
+    # Mass Assignment Security
+    #
 
-        #
-        # Mass Assignment Security
-        #
+    attr_accessible :name
 
-        attr_accessible :name
+    #
+    # Search Attributes
+    #
 
-        #
-        # Search Attributes
-        #
+    search_attribute :name, :type => :string
 
-        search_attribute :name, :type => :string
+    #
+    # Validations
+    #
 
-        #
-        # Validations
-        #
-
-        validates :name, :presence => true
-      end
-
-      #
-      # Associations
-      #
-
-      # @!attribute [r] email_addresses
-      #   Email addresses used by this author across all {#module_instances}.
-      #
-      #   @return [Array<Metasploit::Model::EmailAddress>]
-
-      # @!attribute [r] module_instances
-      #   Modules written by this author.
-      #
-      #   @return [Array<Metasploit::Model::Module::Instance>]
-
-      #
-      # Attributes
-      #
-
-      # @!attribute [rw] name
-      #   Full name (First + Last name) or handle of author.
-      #
-      #   @return [String]
-    end
+    validates :name, :presence => true
   end
-end
+
+  #
+  # Associations
+  #
+
+  # @!attribute [r] email_addresses
+  #   Email addresses used by this author across all {#module_instances}.
+  #
+  #   @return [Array<Metasploit::Model::EmailAddress>]
+
+  # @!attribute [r] module_instances
+  #   Modules written by this author.
+  #
+  #   @return [Array<Metasploit::Model::Module::Instance>]
+
+  #
+  # Attributes
+  #
+
+  # @!attribute [rw] name
+  #   Full name (First + Last name) or handle of author.
+  #
+  #   @return [String]
+end