metasploit-model 0.24.1.pre.semantic.pre.versioning.pre.2.pre.0

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

@@ -0,0 +1,9 @@
+module Metasploit
+  module Model
+    module Spec
+      # Error raised by Metasploit::Model::Spec methods.
+      class Error < StandardError
+      end
+    end
+  end
+end

data/lib/metasploit/model/spec/i18n_exception_handler.rb

@@ -0,0 +1,19 @@
+# Raises all I18n errors as exceptions so that missing translations (or other errors) with en.yml are caught by the
+# specs.
+#
+# @example Use in spec_helper.rb to find missing translations
+#   RSpec.configure do |config|
+#     config.before(:suite) do
+#       # catch missing translations
+#       I18n.exception_handler = Metasploit::Model::Spec::I18nExceptionHandler.new
+#     end
+#  end
+class Metasploit::Model::Spec::I18nExceptionHandler < I18n::ExceptionHandler
+  # Raises `exception`.
+  #
+  # @return [void]
+  # @raise [Exception]
+  def call(exception, locale, key, options)
+    raise exception.to_exception
+  end
+end

data/lib/metasploit/model/spec/pathname_collision.rb

@@ -0,0 +1,28 @@
+module Metasploit
+  module Model
+    module Spec
+      # Error raised if a Pathname already exists on disk when one of the real_paths for metasploit-models factories
+      # is generated or derived, which would indicate that a prior spec did not clean up properly.
+      class PathnameCollision < Metasploit::Model::Spec::Error
+        # Checks if there is a pathname collision.
+        #
+        # @param (see #initialize)
+        # @return [void]
+        # @raise [Metasploit::Model::Spec::PathnameCollision] if `pathname.exist?` is `true`.
+        def self.check!(pathname)
+          if pathname.exist?
+            raise new(pathname)
+          end
+        end
+
+        # @param pathname [Pathname] Pathname that already exists on disk
+        def initialize(pathname)
+          super(
+              "#{pathname} already exists.  " \
+              "Metasploit::Model::Spec.remove_temporary_pathname was not called after the previous spec."
+          )
+        end
+      end
+    end
+  end
+end

data/lib/metasploit/model/spec/template/write.rb

@@ -0,0 +1,42 @@
+# Extend to add a class method to create a new template and write it only if valid.
+#
+# @example extend and write
+#   class MyTemplate
+#     extend Metasploit::Model::Spec::Template::Write
+#
+#     def write
+#       ...
+#     end
+#   end
+#
+#   success = MyTemplate.write(attributes)
+module Metasploit::Model::Spec::Template::Write
+  # Writes template for `attributes` to disk if the created template is valid.
+  #
+  # @return [true] if template was valid and was written.
+  # @return [false] if template was invalid and was not written.
+  # @see #write!
+  def write(attributes={})
+    template = new(attributes)
+
+    written = template.valid?
+
+    if written
+      template.write
+    end
+
+    written
+  end
+
+  # Writes templates for `attributes` to disk if created template is valid; otherwise, raises an exception.
+  #
+  # @return [void]
+  # @raise [Metasploit::Model::Invalid] if template is invalid
+  # @see write
+  def write!(attributes={})
+    template = new(attributes)
+
+    template.valid!
+    template.write
+  end
+end

data/lib/metasploit/model/spec/temporary_pathname.rb

@@ -0,0 +1,59 @@
+module Metasploit
+  module Model
+    module Spec
+      # @example Temporary pathname creation and removal
+      #
+      #   # spec/spec_helper.rb
+      #   RSpec.config do |config|
+      #     config.before(:suite) do
+      #       Metasploit::Model::Spec.temporary_pathname = MyApp.root.join('spec', 'tmp')
+      #       # Clean up any left over files from a previously aborted suite
+      #       Metasploit::Model::Spec.remove_temporary_pathname
+      #     end
+      #
+      #     config.after(:each) do
+      #       Metasploit::Model::Spec.remove_temporary_pathname
+      #     end
+      #   end
+      module TemporaryPathname
+        # Removes {#temporary_pathname} from disk if it's been set and exists on disk.
+        #
+        # @return [void]
+        def remove_temporary_pathname
+          begin
+            removal_pathname = temporary_pathname
+          rescue Metasploit::Model::Spec::Error
+            removal_pathname = nil
+          end
+
+          if removal_pathname and removal_pathname.exist?
+            removal_pathname.rmtree
+          end
+        end
+
+        # Pathname to hold temporary files for metasploit-model factories and sequence.  The directory must be be
+        # safely writable and removable for specs that need to use the file system.
+        #
+        # @return [Pathname]
+        # @raise [Metasploit::Model::Spec::Error] if {#temporary_pathname} is not set prior to calling this method.
+        def temporary_pathname
+          unless instance_variable_defined?(:@temporary_pathname)
+            raise Metasploit::Model::Spec::Error, 'Metasploit::Model::Spec.temporary_pathname not set prior to use'
+          end
+
+          @temporary_pathname
+        end
+
+        # Sets the pathname to use for temporary directories and files used in metasploit_data_models factories and
+        # sequences.
+        #
+        # @param pathname [Pathname] path to a directory.  It does not need to exist, but need to be in a writable parent
+        #   directory so it can be removed by {#remove_temporary_pathname}.
+        # @return [Pathname] `pathname`
+        def temporary_pathname=(pathname)
+          @temporary_pathname = pathname
+        end
+      end
+    end
+  end
+end

data/lib/metasploit/model/translation.rb

@@ -0,0 +1,31 @@
+# ActiveRecord::Translation is a dirty bastard and overrides `ActiveModel::Translation#lookup_ancestors`, so that it
+# will only count superclasses, and not all ancestors.  Metasploit::Model needs the original behavior so that its
+# {Metasploit::Model::Module} modules can supply translations to both `ActiveRecord::Base` descendants in `Mdm` and
+# `ActiveModel` descendants in `Metasploit::Framework`
+#
+# @see https://github.com/rails/rails/issues/11409
+module Metasploit::Model::Translation
+  extend ActiveSupport::Concern
+
+  # Adds {#lookup_ancestors} and {#i18n_scope} so that {Metasploit::Model} modules can participate in translation
+  # lookups.
+  module ClassMethods
+    # When localizing a string, it goes through the lookup returned by this method, which is used in
+    # ActiveModel::Name#human, # ActiveModel::Errors#full_messages and ActiveModel::Translation#human_attribute_name.
+    #
+    # @return [Array<Module>] Array of `Class#ancestors` that respond to `module_name`.
+    def lookup_ancestors
+      self.ancestors.select { |ancestor|
+        ancestor.respond_to?(:model_name)
+      }
+    end
+
+    # Classes that include a metasploit-model are trying to share code between ActiveRecord and ActiveModel, so the scope
+    # should be neither 'activerecord' nor 'activemodel'.
+    #
+    # @return [String] `'metasploit.model'`
+    def i18n_scope
+      'metasploit.model'
+    end
+  end
+end

data/lib/metasploit/model/version.rb

@@ -0,0 +1,33 @@
+module Metasploit
+  module Model
+    # Holds components of {VERSION} as defined by {http://semver.org/spec/v2.0.0.html semantic versioning v2.0.0}.
+    module Version
+      # The major version number.
+      MAJOR = 0
+      # The minor version number, scoped to the {MAJOR} version number.
+      MINOR = 24
+      # The patch number, scoped to the {MINOR} version number.
+      PATCH = 1
+      # The prerelease name of the given {MAJOR}.{MINOR}.{PATCH} version number. Will not be defined on master.
+      PRERELEASE = 'semantic-versioning-2-0'
+
+      # The full version string, including the {MAJOR}, {MINOR}, {PATCH}, and optionally, the {PRERELEASE} in the
+      # {http://semver.org/spec/v2.0.0.html semantic versioning v2.0.0} format.
+      #
+      # @return [String] '{MAJOR}.{MINOR}.{PATCH}' on master.  '{MAJOR}.{MINOR}.{PATCH}-{PRERELEASE}' on any branch
+      #   other than master.
+      def self.full
+        version = "#{MAJOR}.#{MINOR}.#{PATCH}"
+
+        if defined? PRERELEASE
+          version = "#{version}-#{PRERELEASE}"
+        end
+
+        version
+      end
+    end
+
+    # @see Version.full
+    VERSION = Version.full
+  end
+end

data/lib/metasploit/model/visitation.rb

@@ -0,0 +1,9 @@
+module Metasploit
+  module Model
+    # Namespace for `metasploit-model`'s implementation of the {http://en.wikipedia.org/wiki/Visitor_pattern visitor
+    # pattern}.
+    module Visitation
+
+    end
+  end
+end

data/lib/metasploit/model/visitation/visit.rb

@@ -0,0 +1,103 @@
+module Metasploit
+  module Model
+    module Visitation
+      # {ClassMethods#visit DSL} to declare {Metasploit::Model::Visitation::Visitor visitors} for a given `Module#name`
+      # (or any Class that has an ancestor in `Class#ancestors` with that `Module#name`) and then use then to {#visit}
+      # instances of those class and/or modules.
+      module Visit
+        extend ActiveSupport::Concern
+
+        # Adds {#visit} DSL to class to declare {Metasploit::Model::Visitation::Visitor visitors}.
+        module ClassMethods
+          # Defines how to visit a node with one or more `Module#names` in its `Module#ancestors`.
+          #
+          # @param module_names [Array<String>] Names of class/module to be visited with block.
+          # @yield [node] Block instance_exec'd on instance of the class {#visit} was called.
+          # @yieldparam node [Object]
+          # @return [Array<Metasploit::Model::Visitation::Visitor>] visitors created.
+          # @raise [ArgumentError] if `module_names` is empty
+          # @raise [Metasploit::Model::Invalid] unless `block` is given.
+          def visit(*module_names, &block)
+            if module_names.empty?
+              raise ArgumentError,
+                    "At least one Modul#name must be passed to #{__method__} so the visitor(s) knows which Modules " \
+                    "it/they can visit."
+            end
+
+            module_names.collect do |module_name|
+              visitor = Metasploit::Model::Visitation::Visitor.new(
+                  :module_name => module_name,
+                  :parent => self,
+                  &block
+              )
+              visitor.valid!
+
+              visitor_by_module_name[visitor.module_name] = visitor
+            end
+          end
+
+          # {Metasploit::Model::Visitation::Visitor Visitor} for `klass` or one of its `Class#ancestors`.
+          #
+          # @return [Metasploit::Model::Visitation::Visitor]
+          # @raise [TypeError] if there is not visitor for `klass` or one of its ancestors.
+          def visitor(klass)
+            visitor = visitor_by_module[klass]
+
+            unless visitor
+              klass.ancestors.each do |mod|
+                visitor = visitor_by_module[mod]
+
+                unless visitor
+                  visitor = visitor_by_module_name[mod.name]
+                end
+
+                if visitor
+                  visitor_by_module[klass] = visitor
+
+                  break
+                end
+              end
+            end
+
+            unless visitor
+              raise TypeError,
+                    "No visitor that handles #{klass} or " \
+                    "any of its ancestors (#{klass.ancestors.map(&:name).to_sentence})"
+            end
+
+            visitor
+          end
+
+          # Allows {Metasploit::Model::Visitation::Visitor visitors} to be looked up by Module instead of `Module#name`.
+          #
+          # @return [Hash{Class => Metasploit::Model::Visitation::Visitor}]
+          def visitor_by_module
+            @visitor_by_module ||= {}
+          end
+
+          # Maps `Module#name` passed to {ClassMethods#visit} through :module_name to the
+          # {Metasploit::Model::Visitation::Visitor} with the `Module#name` as
+          # {Metasploit::Model::Visitation::Visitor#module_name}.
+          #
+          # @return [Hash{String => Metasploit::Model::Visitation::Visitor}]
+          def visitor_by_module_name
+            @visitor_by_module_name ||= {}
+          end
+        end
+
+        #
+        # Instance Methods
+        #
+
+        # Visits `node`
+        #
+        # @return (see Metasploit::Model::Visitation::Visitor#visit)
+        def visit(node)
+          visitor = self.class.visitor(node.class)
+
+          visitor.visit(self, node)
+        end
+      end
+    end
+  end
+end

data/lib/tasks/yard.rake

@@ -0,0 +1,30 @@
+# @note All options not specific to any given rake task should go in the .yardopts file so they are available to both
+#   the below rake tasks and when invoking `yard` from the command line
+
+if defined? YARD
+  namespace :yard do
+    YARD::Rake::YardocTask.new(:doc) do |t|
+      # --no-stats here as 'stats' task called after will print fuller stats
+      t.options = ['--no-stats']
+
+      t.after = Proc.new {
+        Rake::Task['yard:stats'].execute
+      }
+    end
+
+    desc "Shows stats for YARD Documentation including listing undocumented modules, classes, constants, and methods"
+    task :stats => :environment do
+      stats = YARD::CLI::Stats.new
+      stats.run('--compact', '--list-undoc')
+    end
+  end
+
+  # @todo Figure out how to just clone description from yard:doc
+  desc "Generate YARD documentation"
+  # allow calling namespace to as a task that goes to default task for namespace
+  task :yard => ['yard:doc']
+
+  task :default => :yard
+else
+  puts 'YARD not defined, so yard tasks cannot be setup.'
+end

data/metasploit-model.gemspec

@@ -0,0 +1,39 @@
+# coding: utf-8
+lib = File.expand_path('../lib', __FILE__)
+$LOAD_PATH.unshift(lib) unless $LOAD_PATH.include?(lib)
+require 'metasploit/model/version'
+
+Gem::Specification.new do |spec|
+  spec.name          = 'metasploit-model'
+  spec.version       = Metasploit::Model::VERSION
+  spec.authors       = ['Luke Imhoff']
+  spec.email         = ['luke_imhoff@rapid7.com']
+  spec.description   = %q{Common code, such as validators and mixins, that are shared between ActiveModels in metasploit-framework and ActiveRecords in metasploit_data_models.}
+  spec.summary       = %q{Metasploit Model Mixins and Validators}
+
+  spec.files         = `git ls-files`.split($/)
+  spec.executables   = spec.files.grep(%r{^bin/}) { |f| File.basename(f) }
+  spec.test_files    = spec.files.grep(%r{^(test|spec|features)/})
+  spec.require_paths = ['lib']
+
+  spec.add_development_dependency 'bundler', '~> 1.3'
+  spec.add_development_dependency 'rake'
+
+  # documentation
+  spec.add_development_dependency 'yard'
+
+  # Dependency loading
+  spec.add_runtime_dependency 'activesupport'
+
+  if RUBY_PLATFORM =~ /java/
+    # markdown formatting for yard
+    spec.add_development_dependency 'kramdown'
+
+    spec.platform = Gem::Platform::JAVA
+  else
+    # markdown formatting for yard
+    spec.add_development_dependency 'redcarpet'
+
+    spec.platform = Gem::Platform::RUBY
+  end
+end

data/script/rails

@@ -0,0 +1,9 @@
+#!/usr/bin/env ruby
+# This command will automatically be run when you run "rails" with Rails 3 gems installed from the root of your application.
+
+ENGINE_ROOT = File.expand_path('../..', __FILE__)
+ENGINE_PATH = File.expand_path('../../lib/metasploit/model/engine', __FILE__)
+
+
+require 'rails/all'
+require 'rails/engine/commands'

data/spec/app/models/metasploit/model/association/reflection_spec.rb

@@ -0,0 +1,48 @@
+require 'spec_helper'
+
+describe Metasploit::Model::Association::Reflection do
+  context 'validations' do
+    it { should validate_presence_of :model }
+    it { should validate_presence_of :name }
+    it { should validate_presence_of :class_name }
+  end
+
+  context '#klass' do
+    subject(:klass) do
+      reflection.klass
+    end
+
+
+    let(:class_name) do
+      FactoryGirl.generate :metasploit_model_association_reflection_class_name
+    end
+
+    let(:class_name_class) do
+      Class.new
+    end
+
+    let(:model) do
+      Class.new
+    end
+
+    let(:name) do
+      FactoryGirl.generate :metasploit_model_association_reflection_name
+    end
+
+    let(:reflection) do
+      described_class.new(
+          :model => model,
+          :name => name,
+          :class_name => class_name
+      )
+    end
+
+    before(:each) do
+      stub_const(class_name, class_name_class)
+    end
+
+    it 'should return Class with Class#name #class_name' do
+      klass.should == class_name_class
+    end
+  end
+end