ronin 1.1.0 → 1.2.0

data/lib/ronin/model/model.rb

@@ -17,7 +17,6 @@
 # along with Ronin.  If not, see <http://www.gnu.org/licenses/>.
 #
 
-require 'ronin/model/class_methods'
 require 'ronin/model/types'
 require 'ronin/support/inflector'
 
@@ -51,74 +50,114 @@ module Ronin
       base.send :include, DataMapper,
                           DataMapper::Migrations,
                           DataMapper::Serialize,
-                          Model::Types
-      base.send :extend, Model::ClassMethods
+                          Model::Types,
+                          InstanceMethods
+      base.send :extend, ClassMethods
     end
 
     #
-    # Formats the attributes of the model into human readable names
-    # and values.
+    # Class methods that are added when {Model} is included into a class.
     #
-    # @param [Hash] options
-    #   Additional options.
-    #
-    # @option options [Array<Symbol>] :exclude ([])
-    #   A list of attribute names to exclude.
-    #
-    # @yield [name, value]
-    #   If a block is given, it will be passed the name and humanized
-    #   value of each attribute.
-    #
-    # @yieldparam [String] name
-    #   The humanized name of the attribute.
-    #
-    # @yieldparam [String] value
-    #   The human readable value of the attribute.
-    #
-    # @return [Hash{String => String}]
-    #   A hash of the humanly readable names and values of the attributes.
-    #
-    # @api semipublic
-    #
-    def humanize_attributes(options={})
-      exclude = [:id, :type]
+    module ClassMethods
+      #
+      # The default name to use when defining relationships with the
+      # model.
+      #
+      # @return [Symbol]
+      #   The name to use in relationships.
+      #
+      # @since 1.0.0
+      #
+      # @api semipublic
+      #
+      def relationship_name
+        name = Support::Inflector.underscore(self.name.split('::').last)
+
+        return Support::Inflector.pluralize(name).to_sym
+      end
+
+      #
+      # Loads and initialize the resources.
+      #
+      # @api private
+      #
+      def load(records,query)
+        resources = super(records,query)
+        resources.each { |resource| resource.send :initialize }
 
-      if options[:exclude]
-        exclude += options[:exclude]
+        return resources
       end
+    end
 
-      formatter = lambda { |value|
-        if value.kind_of?(Array)
-          value.map(&formatter).join(', ')
-        elsif value.kind_of?(Symbol)
-          Support::Inflector.humanize(value)
-        else
-          value.to_s
+    #
+    # Instance methods that are added when {Model} is included into a class.
+    #
+    module InstanceMethods
+      #
+      # Formats the attributes of the model into human readable names
+      # and values.
+      #
+      # @param [Hash] options
+      #   Additional options.
+      #
+      # @option options [Array<Symbol>] :exclude ([])
+      #   A list of attribute names to exclude.
+      #
+      # @yield [name, value]
+      #   If a block is given, it will be passed the name and humanized
+      #   value of each attribute.
+      #
+      # @yieldparam [String] name
+      #   The humanized name of the attribute.
+      #
+      # @yieldparam [String] value
+      #   The human readable value of the attribute.
+      #
+      # @return [Hash{String => String}]
+      #   A hash of the humanly readable names and values of the attributes.
+      #
+      # @api semipublic
+      #
+      def humanize_attributes(options={})
+        exclude = [:id, :type]
+
+        if options[:exclude]
+          exclude += options[:exclude]
         end
-      }
 
-      formatted = {}
+        formatter = lambda { |value|
+          if value.kind_of?(Array)
+            value.map(&formatter).join(', ')
+          elsif value.kind_of?(Symbol)
+            Support::Inflector.humanize(value)
+          else
+            value.to_s
+          end
+        }
+
+        formatted = {}
 
-      self.attributes.each do |name,value|
-        next if (value.nil? || (value.respond_to?(:empty?) && value.empty?))
+        self.attributes.each do |name,value|
+          next if (value.nil? || (value.respond_to?(:empty?) && value.empty?))
 
-        unless (exclude.include?(name) || value.nil?)
-          name = name.to_s
+          unless (exclude.include?(name) || value.nil?)
+            name = name.to_s
 
-          unless name[-3..-1] == '_id'
-            name = Support::Inflector.humanize(name)
-            value = formatter.call(value)
+            unless name[-3..-1] == '_id'
+              name = Support::Inflector.humanize(name)
+              value = formatter.call(value)
 
-            if block_given?
-              yield name, value
-            end
+              if block_given?
+                yield name, value
+              end
 
-            formatted[name] = value
+              formatted[name] = value
+            end
           end
         end
-      end
 
-      return formatted
+        return formatted
+      end
     end
   end
 end

data/lib/ronin/os.rb

@@ -23,6 +23,8 @@ require 'ronin/os_guess'
 require 'ronin/ip_address'
 require 'ronin/extensions/meta'
 
+require 'dm-is-predefined'
+
 module Ronin
   #
   # Represents an Operating System and pre-defines other common ones
@@ -34,6 +36,8 @@ module Ronin
     include Model
     include Model::HasName
 
+    is :predefined
+
     # Primary key
     property :id, Serial
 
@@ -127,14 +131,25 @@ module Ronin
     #
     # @api private
     #
-    def OS.predefine(name,os_name)
-      os_name = os_name.to_s
+    def OS.predefine(name,attributes)
+      unless attributes[:name]
+        raise(ArgumentError,"must specify the :name attribute")
+      end
+
+      super(name,attributes)
+
+      # if no version was predefined, allow the predefined helper-methods
+      # to accept a version argument
+      unless attributes[:version]
+        os_name = attributes[:name]
+
+        meta_def(name) do |*arguments|
+          attributes = predefined_attributes[name]
+          version = if arguments.first
+                      arguments.first.to_s
+                    end
 
-      meta_def(name) do |*arguments|
-        if (version = arguments.first)
-          OS.first_or_create(:name => os_name, :version => version.to_s)
-        else
-          OS.new(:name => os_name)
+          OS.first_or_create(attributes.merge(:version => version))
         end
       end
 
@@ -142,28 +157,28 @@ module Ronin
     end
 
     # The Linux OS
-    predefine :linux, 'Linux'
+    predefine :linux, :name => 'Linux'
 
     # The FreeBSD OS
-    predefine :freebsd, 'FreeBSD'
+    predefine :freebsd, :name => 'FreeBSD'
 
     # The OpenBSD OS
-    predefine :openbsd, 'OpenBSD'
+    predefine :openbsd, :name => 'OpenBSD'
 
     # The NetBSD OS
-    predefine :netbsd, 'NetBSD'
+    predefine :netbsd, :name => 'NetBSD'
 
     # OSX
-    predefine :osx, 'OSX'
+    predefine :osx, :name => 'OSX'
 
     # The Solaris OS
-    predefine :solaris, 'Solaris'
+    predefine :solaris, :name => 'Solaris'
 
     # The Windows OS
-    predefine :windows, 'Windows'
+    predefine :windows, :name => 'Windows'
 
     # The family UNIX OSes
-    predefine :unix, 'UNIX'
+    predefine :unix, :name => 'UNIX'
 
   end
 end

data/lib/ronin/repository.rb

@@ -723,7 +723,7 @@ module Ronin
         end
 
         if (license = metadata['license'])
-          self.license = License.predefined_resource_with(:name => license)
+          self.license = License.first_or_predefined(:name => license)
         end
 
         if (uri = metadata['uri'])

data/lib/ronin/ronin.rb

@@ -17,26 +17,11 @@
 # along with Ronin.  If not, see <http://www.gnu.org/licenses/>.
 #
 
-require 'ronin/class_methods'
 require 'ronin/auto_load'
 
 module Ronin
   include AutoLoad
 
-  #
-  # Includes {ClassMethods} when {Ronin} is included.
-  #
-  # @param [Class, Module] base
-  #   The class or module that {Ronin} is being included into.
-  #
-  # @since 1.0.0
-  #
-  # @api private
-  #
-  def self.included(base)
-    base.send :extend, ClassMethods
-  end
-
   #
   # Convenience method for loading Ronin {Script}s.
   #

data/lib/ronin/script/script.rb

@@ -17,8 +17,6 @@
 # along with Ronin.  If not, see <http://www.gnu.org/licenses/>.
 #
 
-require 'ronin/script/instance_methods'
-require 'ronin/script/class_methods'
 require 'ronin/script/path'
 require 'ronin/model/model'
 require 'ronin/model/has_name'
@@ -90,6 +88,263 @@ module Ronin
       Path.has 1, base.relationship_name, base, :child_key => [:script_path_id]
     end
 
+    #
+    # @since 1.1.0
+    #
+    module ClassMethods
+      #
+      # Loads the {Script} of the same class.
+      #
+      # @param [String] path
+      #   The path to load the script from.
+      #
+      # @return [Script]
+      #   The loaded script.
+      #
+      # @example
+      #   Exploits::HTTP.load_from('mod_php_exploit.rb')
+      #   # => #<Ronin::Exploits::HTTP: ...>
+      #
+      # @since 1.1.0
+      #
+      def load_from(path)
+        load_object(path)
+      end
+
+      #
+      # Loads all objects with the matching attributes.
+      #
+      # @param [Hash] attributes
+      #   Attributes to search for.
+      #
+      # @since 1.1.0
+      #
+      # @api public
+      #
+      def load_all(attributes={})
+        resources = all(attributes)
+        resources.each { |resource| resource.load_script! }
+
+        return resources
+      end
+
+      #
+      # Loads the first object with matching attributes.
+      #
+      # @param [Hash] attributes
+      #   Attributes to search for.
+      #
+      # @return [Cacheable]
+      #   The loaded cached objects.
+      #
+      # @since 1.1.0
+      #
+      # @api public
+      #
+      def load_first(attributes={})
+        if (resource = first(attributes))
+          resource.load_script!
+        end
+
+        return resource
+      end
+    end
+
+    #
+    # Instance methods for an {Script}.
+    #
+    # @since 1.1.0
+    #
+    module InstanceMethods
+      #
+      # Initializes the Ronin Script.
+      #
+      # @param [Array] arguments
+      #   Arguments for initializing the Script.
+      #
+      # @since 1.1.0
+      #
+      # @api semipublic
+      #
+      def initialize(*arguments,&block)
+        @script_loaded = false
+        @cache_prepared = false
+
+        if arguments.first.kind_of?(Hash)
+          initialize_params(arguments.first)
+        end
+
+        super(*arguments,&block)
+      end
+
+      #
+      # The script type.
+      #
+      # @return [String]
+      #   The name of the script class.
+      #
+      # @since 1.1.0
+      #
+      # @api semipublic
+      #
+      def script_type
+        @script_type ||= self.class.base_model.name.split('::').last
+      end
+
+      #
+      # Determines if the original code, from the cache file, has been
+      # loaded into the object.
+      #
+      # @return [Boolean]
+      #   Specifies whether the original code has been loaded into the
+      #   object.
+      #
+      # @since 1.1.0
+      #
+      # @api private
+      #
+      def script_loaded?
+        @script_loaded == true
+      end
+
+      #
+      # Loads the code from the cached file for the object, and instance
+      # evaluates it into the object.
+      #
+      # @return [Boolean]
+      #   Indicates the original code was successfully loaded.
+      #
+      # @since 1.1.0
+      #
+      # @api private
+      #
+      def load_script!
+        if (cached? && !script_loaded?)
+          block = self.class.load_object_block(self.script_path.path)
+
+          @script_loaded = true
+          instance_eval(&block) if block
+          return true
+        end
+
+        return false
+      end
+
+      #
+      # @return [Boolean]
+      #   Specifies whether the object has been prepared to be cached,
+      #
+      # @since 1.1.0
+      #
+      # @api private
+      #
+      def prepared_for_cache?
+        @cache_prepared == true
+      end
+
+      #
+      # Indicates whether the object has been cached.
+      #
+      # @return [Boolean]
+      #   Specifies whether the object has been previously cached.
+      #
+      # @since 1.1.0
+      #
+      # @api private
+      #
+      def cached?
+        (saved? && self.script_path)
+      end
+
+      #
+      # Default method which invokes the script.
+      #
+      # @param [Array] arguments
+      #   Optional arguments.
+      #
+      # @since 1.1.0
+      #
+      def run(*arguments)
+      end
+
+      #
+      # Converts the script to a String.
+      #
+      # @return [String]
+      #   The name and version of the script.
+      #
+      # @since 1.1.0
+      #
+      # @api public
+      #
+      def to_s
+        if (self.name && self.version)
+          "#{self.name} #{self.version}"
+        elsif self.name
+          super
+        elsif self.version
+          self.version.to_s
+        end
+      end
+
+      #
+      # Inspects both the properties and parameters of the Ronin Script.
+      #
+      # @return [String]
+      #   The inspected Ronin Script.
+      #
+      # @since 1.1.0
+      #
+      # @api public
+      #
+      def inspect
+        body = []
+
+        self.attributes.each do |name,value|
+          body << "#{name}: #{value.inspect}"
+        end
+
+        param_pairs = []
+
+        self.params.each do |name,param|
+          param_pairs << "#{name}: #{param.value.inspect}"
+        end
+
+        body << "params: {#{param_pairs.join(', ')}}"
+
+        return "#<#{self.class}: #{body.join(', ')}>"
+      end
+
+      protected
+
+      #
+      # Will call the given block only once, in order to prepare the
+      # object for caching.
+      #
+      # @yield []
+      #   The block will be ran inside the object when the object is to be
+      #   prepared for caching.
+      #
+      # @return [Boolean]
+      #   Specifies whether the object was successfully prepared for
+      #   caching.
+      #
+      # @since 1.1.0
+      #
+      # @api public
+      #
+      def cache
+        if (block_given? && !(cached? || prepared_for_cache?))
+          @cache_prepared = true
+
+          yield
+          return true
+        end
+
+        return false
+      end
+    end
+
     # 
     # Loads a script from a file.
     #