nova 0.0.2

data/lib/nova/common/event_handler/event.rb

@@ -0,0 +1,147 @@
+module Nova
+  module Common
+    module EventHandler
+
+      # This represents an event that can be run.  It may also represent
+      # an event that will be run, and is being used to match the events
+      # in the set.
+      # Basically, an event is defined when +:on+ is called on a Star,
+      # and an {Event} is created.
+      # It is added to an event list, which is a set.  Later, when that
+      # class is instantized, and an event is ran, an {Event} is created
+      # and the set is searched for a match to that {Event}.
+      class Event
+
+        include Comparable
+
+        # The name of the event.
+        #
+        # @return [Symbol]
+        attr_reader :name
+
+        # The options defined at compile time for the event.
+        #
+        # @return [Hash]
+        attr_reader :options
+
+        # The block defined for the event.  Should be able to accept one
+        # parameter, or less.
+        #
+        # @return [Proc]
+        attr_reader :block
+
+        # The type of {Event} this is.  By default, this value is
+        # +:definition+, but when using this event to find another event,
+        # its value should be +:search+.
+        #
+        # @return [Symbol]
+        attr_accessor :type
+
+        # Initialize the event.
+        #
+        # @param name [Symbol] the name of the event to respond to.
+        # @param options [Hash] the options of the event.
+        # @param block [Proc] the defining block of the event.
+        # @option options [Symbol] :on the platform the event
+        #   is written for.  If this doesn't match the current
+        #   platform, the event is never run.  Must be in the
+        #   results of {Remote::Fake::Platforms#platform} (or
+        #   remote's definition of platform).  Can also be +:for+.
+        # @option options [Symbol, Array<Symbol>] :requires
+        #   what options the event requires when being run.  The
+        #   value will be matched against the keys of the hash
+        #   passed, and if the hash doesn't contain all of the
+        #   values, the event doesn't match.  Can also be
+        #   +:require+.
+        # @option options [Hash] :defaults the default values to be
+        #   used when running the event.  Merged into the given
+        #   options such that the given options overwrite the
+        #   defaults.
+        def initialize(name, options, block = nil)
+          @name = name
+          @options = options
+          @block = block
+          @type = :definition
+        end
+
+        # Compares this event to another event.  If the argument isn't
+        # an {Event}, it is compared to the name of the event.  If it
+        # is, the event's names and options are compared.
+        #
+        # @param other [Event, Object] the event to compare to.
+        # @return [Numeric] the comparison result.
+        def <=>(other)
+          return @name == other unless Event === other
+
+          (@name <=> other.name) + (@options <=> other.options)
+        end
+
+        # Runs the event, calling the block with the given options.
+        #
+        # @param context [Object] the context to run it in.
+        # @param options [Hash] the options.
+        # @return [Object, nil]
+        def run(context, options = {})
+          #@block.call(options)
+
+          if @options[:defaults]
+            options = @options[:defaults].merge(options)
+          end
+
+          context.instance_exec(options, &@block)
+        end
+
+        # Whether or not this event is a search event.
+        #
+        # @return [Boolean]
+        def search?
+          type == :search
+        end
+
+        # Whether or not this event matches another event, to see if it
+        # can be ran using this event definition.
+        #
+        # @param star [Class, #platform]
+        # @param event [Symbol]
+        # @return [Boolean]
+        def match?(star, event)
+          event.name == name &&
+          check_platform_requirement(star) && check_options_requirements(event.options)
+        end
+
+        private
+
+        # Checks the +:for+ option to see if it matches the current
+        # platform.  If it's +nil+, or a false value, this returns true.
+        # If it's anything else, it'll try to compare it to the
+        # current platform, as returned by {Platforms#platform}.
+        #
+        # @api private
+        # @return [Boolean]
+        def check_platform_requirement(star)
+          if options[:for] || options[:on]
+            star.platform.include?(options[:for] || options[:on])
+          else
+            true
+          end
+        end
+
+        # Checks the given runtime options for required options.  If no
+        # required options exist, returns true.  Otherwise, checks the
+        # keys of the runtime options to see if they contain all of the
+        # required options.
+        #
+        # @api private
+        # @return [Boolean]
+        def check_options_requirements(runtime_options)
+          required_options = options[:requires] || options[:require]
+          return true unless required_options
+
+          ([required_options].flatten - runtime_options.keys).size == 0
+        end
+
+
+      end
+    end
+  end
+end

data/lib/nova/common/features.rb

@@ -0,0 +1,93 @@
+require 'forwardable'
+
+require 'nova/common/features/feature'
+
+module Nova
+  module Common
+
+    # The features that the star has.  These are optional
+    # behaviors that are defined on the stars, but if they are
+    # implemented they should follow around the same behaviours of
+    # other features implemented on other stars with the same name.
+    module Features
+
+      # Class methods.
+      module ClassMethods
+
+        # The list of features the star supports.
+        #
+        # @return [Hash] the features.
+        def features
+          @features ||= {}
+        end
+
+        # Whether or not this star supports a feature.
+        #
+        # @return [Boolean]
+        def supports?(feature_name)
+          features.key? feature_name
+        end
+
+        # Define a feature, with the given name and block.
+        #
+        # @param name [Symbol] the name of the feature.
+        # @param options [Hash] the options for the feature.
+        # @yield to create the feature.
+        # @return [Feature] the feature that was defined.
+        def feature(name, options = {}, &block)
+          new_feature = Feature.new(name, options)
+          new_feature.instance_exec &block
+          features[name] = new_feature
+        end
+
+      end
+
+      # Instance methods.
+      module InstanceMethods
+
+        extend Forwardable
+
+        # A hash of features.  Any features are bound to this class,
+        # after their first access.  If a feature is accessed without
+        # existing, a fake feature is created and bound to self.
+        # All features are cached in the hash after being bound.
+        #
+        # @see Features::ClassMethods#features
+        # @return [Hash]
+        def features
+          @_features ||= Hash.new do |hash, key|
+            class_feature = self.class.features[key]
+
+            if class_feature
+              hash[key] = class_feature.bind(self)
+            else
+              hash[key] = Feature.new(key, {}).bind(self).fake!
+            end
+          end
+        end
+
+        # Returns a feature that matches the given name.  If it
+        # doesn't exist, a fake one is created, and bound to self.
+        #
+        # @param name [Symbol] the name of the feature.
+        # @return [Feature]
+        def feature(name)
+          features[name]
+        end
+
+        def_delegators "self.class", :supports?
+      end
+
+      # Called when {Features} is included.  Extends what included
+      # it by {ClassMethods}, and includes {InstanceMethods}.
+      #
+      # @param receiver [Object]
+      # @return [void]
+      # @api private
+      def self.included(receiver)
+        receiver.extend         ClassMethods
+        receiver.send :include, InstanceMethods
+      end
+    end
+  end
+end

data/lib/nova/common/features/feature.rb

@@ -0,0 +1,65 @@
+module Nova
+  module Common
+    module Features
+
+      # The information about the feature that was defined.
+      class Feature
+
+        # The name of the feature.
+        #
+        # @return [Symbol]
+        attr_accessor :name
+
+        # The options of the feature.
+        #
+        # @return [Hash]
+        attr_accessor :options
+
+        def initialize(name, options)
+          @name = name
+          @options = options
+          @bind = Object.new
+          @fake = false
+        end
+
+        include EventHandler
+
+        # Enables the feature and runs the :enable event, if it
+        # exists.
+        #
+        # @return [nil, Object]
+        def enable!
+          run(:enable)
+        end
+
+        # Disables the feature and runs the :disable event, if it
+        # exists.
+        #
+        # @return [nil, Object]
+        def disable!
+          run(:disable)
+        end
+
+        # Whether or not this feature is fake.  By fake, it means that
+        # it was not created with the defining class as a feature; it
+        # does not have any events at all, and its only purpose is to
+        # mock the behavior of a real, defined feature.
+        #
+        # @return [Boolean]
+        def fake?
+          @fake
+        end
+
+        # Marks this feature as fake.  This is not reversable.
+        #
+        # @see #fake?
+        # @return [self]
+        def fake!
+          @fake = true
+          self
+        end
+
+      end
+    end
+  end
+end

data/lib/nova/common/metadata.rb

@@ -0,0 +1,65 @@
+require 'nova/common/metadata/data'
+
+module Nova
+  module Common
+
+    # Manages the metadata, such as required options, ruby versions,
+    # required platforms/versions, etc.
+    module Metadata
+
+      # Class methods.
+      module ClassMethods
+
+        # @overload metadata(&block)
+        #   Runs the metadata block in a metadata instance, and then
+        #   sets the metadata information for this star.
+        #
+        #   @yield [Data]
+        #   @return [Data]
+        # @overload metadata
+        #   Returns the metadata for this star.
+        #
+        #   @return [Data]
+        def metadata(&block)
+          if block_given?
+            data = Data.new
+            data.instance_exec data, &block
+            @metadata = data
+          else
+            @metadata ||= Data.new
+          end
+        end
+
+      end
+
+      # Instance methods.
+      module InstanceMethods
+
+        # Handles validation for the metadata.
+        def initialize(*)
+          @meta = self.class.metadata
+          @meta.validate! remote
+        end
+
+        # Sets the options, validating them.
+        def options=(options)
+          @meta.validate_options! options
+          @options = options
+        end
+
+      end
+
+      # Called when {Metadata} is included.  Extends what included
+      # it by {ClassMethods}, and includes {InstanceMethods}.
+      #
+      # @param receiver [Object]
+      # @return [void]
+      # @api private
+      def self.included(receiver)
+        receiver.extend         ClassMethods
+        receiver.send :include, InstanceMethods
+      end
+    end
+
+  end
+end

data/lib/nova/common/metadata/data.rb

@@ -0,0 +1,171 @@
+module Nova
+  module Common
+    module Metadata
+
+      # The data from the definition of the metadata in the star.
+      # This is what the block is run in an instance of.
+      class Data
+
+        # The data contained in this class.
+        #
+        # @return [Hash<Symbol, Object>]
+        attr_reader :data
+
+        # Initialize the data class.
+        def initialize
+          @data = {
+            :rubys => [],
+            :platforms => [],
+            :stars => [],
+            :required_options => [],
+            :version => Gem::Version.new("0.0.0") }
+        end
+
+        # @!method requires_platform(name, *versions)
+        #   The platform version requirement.  Each call to this
+        #   method adds a platform that can be used, and the
+        #   versions that are required for that platform. +:all+
+        #   represents all platforms.
+        #
+        #   @see Gem::Requirement
+        #   @param name [Symbol] the name of the platform.
+        #   @param versions [String] the versions of that platform
+        #     this star is compatible with.
+        #   @return [void]
+        # @!method requires_ruby(name, *versions)
+        #   The ruby version requirement.  Each call to this method
+        #   adds a platform that can be used, and the versions that
+        #   are required for that platform.  +:all+ represents all
+        #   platforms.
+        #
+        #   @see Gem::Requirement
+        #   @param name [Symbol] the name of the platform, such as
+        #     +:jruby+ or +:mri+.
+        #   @param versions [String] the versions of that platform
+        #     that this star is compatible with.
+        # @!method requires_star(name, *versions)
+        #   Requires stars.  Uses the given name as the star name.
+        #
+        #   @see Gem::Requirement
+        #   @param name [Symbol] the name of the star.
+        #   @param versions [String] the versions of that star that
+        #     are compatible with this star.
+        #
+        # @!parse alias_method :require_ruby, :requires_ruby
+        # @!parse alias_method :requires_rubys, :requires_ruby
+        # @!parse alias_method :require_rubys, :requires_ruby
+        # @!parse alias_method :require_platform, :requires_platform
+        # @!parse alias_method :requires_platforms, :requires_platform
+        # @!parse alias_method :require_platforms, :requires_platform
+        # @!parse alias_method :require_star, :requires_star
+        # @!parse alias_method :requires_stars, :requires_star
+        # @!parse alias_method :require_stars, :requires_star
+        [:ruby, :platform, :star].each do |type|
+          define_method(:"requires_#{type}") do |p, *versions|
+            data[:"#{type}s"].push(:name => p, :version =>
+              Gem::Requirement.new(*[versions].flatten))
+          end
+
+          alias_method :"require_#{type}", :"requires_#{type}"
+          alias_method :"requires_#{type}s", :"requires_#{type}"
+          alias_method :"require_#{type}s", :"requires_#{type}"
+        end
+
+        # The options that are required by this star.
+        #
+        # @param options [Symbol] the option that is required.
+        # @return [void]
+        def requires_option(*options)
+          data[:required_options].push(*[options].flatten)
+        end
+
+        alias_method :requires_options, :requires_option
+        alias_method :require_option, :requires_option
+        alias_method :require_options, :requires_options
+
+        # Sets the version of the current star.
+        #
+        # @see Gem::Version
+        # @param version [String] the version of the star.
+        # @return [void]
+        def version=(version)
+          data[:version] = Gem::Version.new(version)
+        end
+
+        # Validates the current platform, to make sure that the
+        # running ruby version and the platform name and version
+        # match those required by this star.
+        #
+        # @return [void]
+        def validate!(remote)
+          check_against :ruby do |ruby|
+            if [:all, :any].include? ruby[:name]
+              ruby[:version].satisfied_by?(
+                Gem::Version.new(RUBY_VERSION))
+            else
+              ruby[:name] == RUBY_ENGINE.downcase.intern &&
+                ruby[:version] == ruby_version
+            end
+          end
+
+          version = Gem::Version.new remote.platform.version || "0.0.0"
+
+          check_against :platform do |platform|
+            remote.platforms.include?(platform[:name]) &&
+              platform[:version] == version
+          end
+        end
+
+        # Validates the given options, making sure that the options
+        # contain the required options for the star.
+        #
+        # @return [void]
+        def validate_options!(options)
+          keys = options.keys
+
+          unless (data[:required_options] - keys).empty?
+            raise InvalidOptionsError, "Missing options " +
+              "#{(data[:required_options] - keys).join(', ')}"
+          end
+        end
+
+        private
+
+        # Checks the given type against the block.  Injects the
+        # type's array with false, and calls the block, trying to
+        # see if any element in the type's array makes the block
+        # return true.  If none of them do, it raises an error,
+        # unless there's no element in the type's array.
+        #
+        # @param what [Symbol] the type.  Normally +:ruby+ or
+        #   +:platform+.
+        # @yield [Hash] the object to check.
+        # @raise [NoPlatformError] if none of the yields give true.
+        # @return [void]
+        def check_against(what, &block)
+          result = data[:"#{what}s"].inject(false) do |v, obj|
+            v || block.call(obj)
+          end
+
+          unless result || data[:"#{what}s"].empty?
+            raise NoPlatformError, "Could not match any version " +
+            "of #{what}s."
+          end
+        end
+
+        # Returns the most relevant ruby version there is.
+        #
+        # @return [Gem::Version]
+        def ruby_version
+          Gem::Version.new case RUBY_ENGINE
+          when "jruby"
+            JRUBY_VERSION
+          else
+            RUBY_VERSION
+          end
+        end
+
+      end
+    end
+  end
+end