amp-front 0.1.0

data/features/amp_plugin_list.feature

@@ -0,0 +1,10 @@
+Feature: Plugin List Command
+  In order to check my plugins
+  A user can use the "plugin list" command
+  to inspect the Amp runtime environment
+
+  Scenario: Running plugin list with no parameters
+    Given the argument plugin
+    And the argument list
+    When I run dispatch
+    Then I should see "Amp::Plugins::Base"

data/features/step_definitions/amp-front_steps.rb

@@ -0,0 +1,23 @@
+Given /the argument (.*)/ do |arg|
+  @arguments ||= []
+  @arguments << arg
+end
+
+When /I run dispatch/ do
+  dispatch = Amp::Dispatch::Runner.new(@arguments || [])
+  @result = swizzling_stdout { dispatch.run! }
+end
+
+Then /I should see "(.*)"/ do |arg|
+  @result.should =~ /#{arg}/
+end
+
+def swizzling_stdout
+  new_stdout = StringIO.new
+  $stdout, old_stdout = new_stdout, $stdout
+  yield
+  new_stdout.string
+ensure
+  $stdout = old_stdout
+  new_stdout.string
+end

data/features/support/env.rb

@@ -0,0 +1,4 @@
+$LOAD_PATH.unshift(File.dirname(__FILE__) + '/../../lib')
+require 'amp-front'
+
+require 'spec/expectations'

data/lib/amp-front.rb

@@ -0,0 +1,30 @@
+module Amp
+  VERSION = '0.0.1'
+  VERSION_TITLE = 'Koyaanisqatsi'
+
+  $LOAD_PATH.unshift(File.expand_path(File.dirname(__FILE__)))
+
+  module Dispatch
+    autoload :Runner, 'amp-front/dispatch/runner.rb'
+  end
+
+  module Help
+    autoload :HelpUI,           'amp-front/help/help.rb'
+    autoload :HelpEntry,        'amp-front/help/help.rb'
+    autoload :HelpRegistry,     'amp-front/help/help.rb'
+    autoload :CommandHelpEntry, 'amp-front/help/help.rb'
+    autoload :FileHelpEntry,    'amp-front/help/help.rb'
+  end
+
+  module Plugins
+    autoload :Base,     'amp-front/plugins/base.rb'
+    autoload :Registry, 'amp-front/plugins/registry.rb'
+  end
+
+  autoload :Command, 'amp-front/dispatch/commands/base.rb'
+  autoload :ModuleExtensions, 'amp-front/support/module_extensions.rb'
+end
+
+autoload :ERB,     'erb'
+autoload :Maruku,  'amp-front/third_party/maruku.rb'
+autoload :Trollop, 'amp-front/third_party/trollop.rb'

data/lib/amp-front/dispatch/commands/base.rb

@@ -0,0 +1,158 @@
+##################################################################
+#                  Licensing Information                         #
+#                                                                #
+#  The following code is licensed, as standalone code, under     #
+#  the Ruby License, unless otherwise directed within the code.  #
+#                                                                #
+#  For information on the license of this code when distributed  #
+#  with and used in conjunction with the other modules in the    #
+#  Amp project, please see the root-level LICENSE file.          #
+#                                                                #
+#  © Michael J. Edgar and Ari Brown, 2009-2010                   #
+#                                                                #
+##################################################################
+require File.expand_path(File.join(File.dirname(__FILE__), 'validations.rb'))
+
+module Amp
+  module Command
+    # Creates a new command class and sets its name appropriately. Yields
+    # it, so it can be customized by the caller, adding options, an on_call
+    # block, and so on.
+    def self.create(name)
+      @current_base_module ||= Amp::Command
+      name = name.capitalize
+      new_class = Class.new(Base)
+      new_class.name = name
+      yield new_class
+      @current_base_module.const_set(name, new_class)
+      Amp::Help::CommandHelpEntry.new(name.downcase, new_class)
+      new_class
+    end
+    
+    # Runs the provided block with a base module of the given name. So
+    # instead of creating Amp::Command::NewCommand, this allows you to
+    # namespace created code as Amp::Command::MyModule::NewCommand, isolating
+    # it from other plugins.
+    def self.namespace(namespace)
+      old_namespace = @current_base_module ||= Amp::Command
+      namespace = namespace.capitalize
+
+      unless old_namespace.const_defined?(namespace)
+        new_namespace = Module.new
+        old_namespace.const_set(namespace, new_namespace)
+      end
+      @current_base_module = const_get(namespace)
+      yield
+    ensure
+      @current_base_module = old_namespace
+    end
+    
+    # See if the specified module list matches a defined constant
+    def self.lookup_const(modules)
+      current = Amp::Command
+      modules.each do |module_name|
+        if module_name =~ /^[A-Za-z0-9_]+$/ && current.const_defined?(module_name)
+          current = current.const_get(module_name)
+        else
+          return current
+        end
+      end
+      return current
+    end
+
+    # return the argument if 'new' would succeed
+    def self.creatable(command)
+      command.is_a?(Class) ? command : nil
+    end
+    
+    # Looks up the command with the given name.
+    def self.for_name(name)
+      modules = name.split.map {|name| name.capitalize}
+      creatable(lookup_const(modules))
+    end
+    
+    # The base class frmo which all comamnds inherit.
+    class Base
+      include Validations
+
+      class << self
+        attr_accessor :name, :options, :desc
+      end
+      self.name = 'Base'
+      
+      # These are the runtime options selected when the command is called.
+      attr_accessor :options, :arguments
+
+      # This tracks all subclasses (and subclasses of subclasses, etc). Plus, this
+      # method is inherited, so Wool::Plugins::Git.all_subclasses will have all
+      # subclasses of Wool::Plugins::Git!
+      def self.all_commands
+        @all_commands ||= [self]
+      end
+
+      # When a Plugin subclass is subclassed, store the subclass and inform the
+      # next superclass up the inheritance hierarchy.
+      def self.inherited(klass)
+        klass.name ||= 'anonymous ' + self.name
+        self.all_commands << klass
+        next_klass = self.superclass
+        while next_klass != Amp::Command::Base.superclass
+          next_klass.send(:inherited, klass)
+          next_klass = next_klass.superclass
+        end
+      end
+
+      # Specifies the block to run, or returns the block.
+      def self.on_call(&block)
+        @on_call = block if block_given?
+        @on_call
+      end
+      
+      def self.desc(*args)
+        self.desc = args[0] if args.size == 1 && args[0].is_a?(String)
+        @desc ||= ""
+      end
+      
+      def self.options
+        @options ||= []
+      end
+      
+      def self.opt(*args)
+        self.options << args
+      end
+      
+      # Runs the command with the provided options and arguments.
+      def call(options, arguments)
+        self.options = options
+        self.arguments = arguments
+        instance_eval(&self.class.on_call)
+      end
+      
+      # Collects the options specific to this command and returns them.
+      def collect_options(arguments)
+        args = arguments.dup
+        base_options = self.class.options  # Trollop::options uses instance_eval
+        @parser, hash = Trollop::options(args) do
+          base_options.each do |option|
+            opt *option
+          end
+        end
+        [hash, args]
+      end
+      
+      def education
+        if @parser
+          output = StringIO.new
+          @parser.educate(output)
+          output.string
+        else
+          ''
+        end
+      end
+    end
+  end
+end
+
+Dir[File.expand_path(File.dirname(__FILE__)) + '/builtin/**/*.rb'].each do |file|
+  require file
+end

data/lib/amp-front/dispatch/commands/builtin/help.rb

@@ -0,0 +1,23 @@
+##################################################################
+#                  Licensing Information                         #
+#                                                                #
+#  The following code is licensed, as standalone code, under     #
+#  the Ruby License, unless otherwise directed within the code.  #
+#                                                                #
+#  For information on the license of this code when distributed  #
+#  with and used in conjunction with the other modules in the    #
+#  Amp project, please see the root-level LICENSE file.          #
+#                                                                #
+#  © Michael J. Edgar and Ari Brown, 2009-2010                   #
+#                                                                #
+##################################################################
+Amp::Command.create('help') do |c|
+  c.desc "Prints the help for the program."
+  
+  c.on_call do
+    output = ""
+    
+    cmd_name = arguments.empty? ? "__default__" : arguments.first
+    Amp::Help::HelpUI.print_entry(cmd_name, options)
+  end
+end

data/lib/amp-front/dispatch/commands/builtin/plugin.rb

@@ -0,0 +1,24 @@
+##################################################################
+#                  Licensing Information                         #
+#                                                                #
+#  The following code is licensed, as standalone code, under     #
+#  the Ruby License, unless otherwise directed within the code.  #
+#                                                                #
+#  For information on the license of this code when distributed  #
+#  with and used in conjunction with the other modules in the    #
+#  Amp project, please see the root-level LICENSE file.          #
+#                                                                #
+#  © Michael J. Edgar and Ari Brown, 2009-2010                   #
+#                                                                #
+##################################################################
+Amp::Command.namespace 'plugin' do
+  Amp::Command.create('list') do |c|
+    c.desc "Lists all the plugins known to Amp."
+  
+    c.on_call do
+      Amp::Plugins::Base.all_plugins.each do |plugin|
+        puts plugin.name
+      end
+    end
+  end
+end

data/lib/amp-front/dispatch/commands/validations.rb

@@ -0,0 +1,171 @@
+##################################################################
+#                  Licensing Information                         #
+#                                                                #
+#  The following code is licensed, as standalone code, under     #
+#  the Ruby License, unless otherwise directed within the code.  #
+#                                                                #
+#  For information on the license of this code when distributed  #
+#  with and used in conjunction with the other modules in the    #
+#  Amp project, please see the root-level LICENSE file.          #
+#                                                                #
+#  © Michael J. Edgar and Ari Brown, 2009-2010                   #
+#                                                                #
+##################################################################
+
+module Amp
+  module Command
+    module Validations
+      def self.included(base)
+        base.extend(ClassMethods)
+      end
+      module ClassMethods
+        def before_blocks
+          @before_blocks ||= []
+        end
+      
+        def after_blocks
+          @after_blocks ||= []
+        end
+      
+        # Specifies one or more "before" callbacks that are run before
+        # the command executes. If any of them return non-truthy, then
+        # execution halts.
+        #
+        # @param block [Proc] a block to run
+        def before(&block)
+          before_blocks << block
+        end
+      
+        # Specifies one or more "after" callbacks that are run before
+        # the command executes. If any of them return non-truthy, then
+        # execution halts.
+        #
+        # @param block [Proc] a block to run
+        def after(&block)
+          after_blocks << block
+        end
+      
+        # Validates that the given block runs and returns true.
+        # TODO(adgar): Document how :if, :unless work
+        def validates_block(options={}, &block)
+          before do |opts, args|
+            if options[:if] || options[:unless]
+              checker = options[:if] || options[:unless]
+              result = if checker.is_a?(Proc)
+                         checker.call(opts, args)
+                       else
+                         new.send(checker, opts, args)
+                       end
+              result = !result if options[:unless]
+              next true unless result
+            end
+            block.call(opts, args)
+          end
+        end
+      
+        # Validates each the given options by running their values through the
+        # block.
+        def validates_each(*syms, &block)
+          options = syms.last.is_a?(Hash) ? syms.pop : {}
+          validates_block(options) do |opts, args|
+            syms.all? {|sym| block.call(opts, sym, opts[sym])}
+          end
+        end
+      
+        # Validates that the given options were provided by the user.
+        def validates_presence_of(*syms)
+          validates_each(*syms) {|opts, attr, value| opts["#{attr}_given".to_sym]}
+        end
+      
+        # Validates that the value of the given symbols is in the provided object.
+        # Takes an options hash that must contain the :in key:
+        #
+        #    validates_inclusion_of :age, :favorite_number, :in => 13..18
+        #
+        # Also supports :if/:unless like the rails counterparts.
+        def validates_inclusion_of(*syms)
+          unless syms.last.is_a?(Hash)
+            raise ArgumentError.new('validates_inclusion_of takes an options hash')
+          end
+          options = syms.last
+          validates_each(*syms) {|opts, attr, value| options[:in].include?(value)}
+        end
+      
+        VALID_LENGTH_KEYS = [:in, :within, :maximum, :minimum, :is]
+        def extract_length_key(options)
+          key_used = VALID_LENGTH_KEYS.find {|key| options.include?(key)}
+          if key_used.nil?
+            raise ArgumentError.new("One of #{VALID_LENGTH_KEYS.inspect} must be " +
+                                    "provided to validates_length_of")
+          end
+          key_used
+        end
+      
+        # Validates the length of the string provided as an argument matches the
+        # provided constraints on length.
+        #
+        # @param [Symbol] attr the attribute to validate
+        # @param [Hash] options A set of options that specifies the constraint.
+        #   Must have one of the following: :in, :within, :maximum, :minimum, :is.
+        def validates_length_of(attr, options={})
+          key_used = extract_length_key options
+          validates_block(options) do |opts, args|
+            value = opts[attr].size
+            numeric_comparison(value, key_used, options[key_used])
+          end
+        end
+        alias_method :validates_size_of, :validates_length_of
+      
+        # Validates the number of arguments provided with the :in, :within, :maximum,
+        # :minimum, and :is relationships. To validate that a user provided at least
+        # 2 arguments in a copy command:
+        #
+        #    command "copy" do
+        #      validates_argument_count :minimum => 2
+        #    end
+        #
+        def validates_argument_count(options={})
+          key_used = extract_length_key options
+          validates_block(options) do |opts, args|
+            value = args.size
+            numeric_comparison(value, key_used, options[key_used])
+          end
+        end
+      
+        # Compares a value to a given constraint and returns whether it matches it
+        # or not.
+        #
+        # @param [Integer] value a numeric value
+        # @param [Symbol] key_used the key used for comparison. Either :within,
+        #   :in, :maximum, :minimum, and :is.
+        # @param [Integer, #include?] constraint a value to compare against
+        # @return [Boolean]
+        def numeric_comparison(value, key_used, constraint)
+          if key_used == :in || key_used == :within
+            constraint.include?(value)
+          elsif key_used == :is
+            constraint == value
+          elsif key_used == :minimum
+            constraint <= value
+          elsif key_used == :maximum
+            constraint >= value
+          end
+        end
+      end
+
+      # Is this a valid set of options and arguments for this command?
+      def valid?(opts, args)
+        self.class.before_blocks.all? {|block| block.call(opts, args)}
+      end
+      alias_method :run_before, :valid?
+    
+      def invalid?(opts, args)
+        !valid?(opts, args)
+      end
+
+      def run_after(opts, args)
+        self.class.after_blocks.all? {|block| block.call(opts, args)}
+      end
+    end
+  end
+end