sprout 0.7.246 → 1.0.0.pre

data/lib/sprout/executable/paths.rb

@@ -0,0 +1,21 @@
+module Sprout
+
+  module Executable
+
+    ##
+    # Concrete param object for collections of paths
+    class Paths < Files 
+
+      def prepare_prerequisites
+        value.each do |path|
+          files = FileList[path + file_expression]
+          files.each do |f|
+            file f
+            belongs_to.prerequisites << f
+          end
+        end
+      end
+    end
+  end
+end
+

data/lib/sprout/executable/string_param.rb

@@ -0,0 +1,15 @@
+module Sprout
+
+  module Executable
+
+    # Concrete param object for :string values
+    class StringParam < Executable::Param
+
+      def shell_value
+        value.gsub(/ /, '\ ')
+      end
+
+    end
+  end
+end
+

data/lib/sprout/executable/strings.rb

@@ -0,0 +1,11 @@
+module Sprout
+
+  module Executable
+
+    # Concrete param object for collections of strings
+    class Strings < Executable::Param
+      include CollectionParam
+    end
+  end
+end
+

data/lib/sprout/executable/url.rb

@@ -0,0 +1,10 @@
+module Sprout
+
+  module Executable
+
+    # Concrete param object for collections of files
+    class Url < StringParam
+    end
+  end
+end
+

data/lib/sprout/executable/urls.rb

@@ -0,0 +1,10 @@
+module Sprout
+
+  module Executable
+
+    # Concrete param object for collections of files
+    class Urls < Strings
+    end
+  end
+end
+

data/lib/sprout/file_target.rb

@@ -0,0 +1,76 @@
+
+module Sprout
+
+  # This is a class that is generally used by the Sprout::Specification::add_file_target method.
+  #
+  # File targets are files that are embedded into (or referred to by) a RubyGem in such a way 
+  # that Sprouts can use them as a library or executable.
+  #
+  # A given FileTarget may be configured to work on a specific platform, or it may be
+  # universal.
+  #
+  class FileTarget
+
+    attr_accessor :load_path
+    attr_accessor :pkg_name
+    attr_accessor :pkg_version
+    attr_accessor :platform
+
+    attr_reader :executables
+    attr_reader :libraries
+
+    def initialize
+      @executables = []
+      @libraries   = []
+      @load_path   = '.'
+      @platform    = :universal
+      yield self if block_given?
+    end
+
+    ##
+    # Add a library to the RubyGem package.
+    # 
+    # @name Symbol that will be used to retrieve this library later.
+    # @path File, Path or Array of files that will be associated with this
+    # library and copied to the target lib.
+    #
+    # If the path is a directory, all files forward of that directory
+    # will be copied into the RubyGem.
+    # 
+    def add_library name, path
+      if path.is_a?(Array)
+        path = path.collect { |p| expand_executable_path(p) }
+      else
+        path = expand_executable_path path
+      end
+      libraries << OpenStruct.new( :name => name, :path => path, :file_target => self )
+    end
+
+    ##
+    # Add an executable to the RubyGem package.
+    #
+    # @name Symbol that will be used to retrieve this executable later.
+    # @target The relative path to the executable that will be associated
+    # with this name.
+    #
+    def add_executable name, path
+      path = expand_executable_path path
+      executables << OpenStruct.new( :name => name, :path => path, :file_target => self )
+    end
+
+    def to_s
+      "[FileTarget type=#{type} platform=#{platform}]"
+    end
+
+    def validate
+      raise Sprout::Errors::UsageError.new "FileTarget.pkg_name is required" if pkg_name.nil?
+      raise Sprout::Errors::UsageError.new "FileTarget.pkg_version is required" if pkg_version.nil?
+    end
+
+    def expand_executable_path path
+      File.join load_path, path
+    end
+
+  end
+end
+

data/lib/sprout/generator/base.rb

@@ -0,0 +1,233 @@
+module Sprout
+
+  module Generator
+    include RubyFeature
+
+    class << self
+
+      def register generator_class, templates_path=nil
+        generator_paths << { :class => generator_class, :templates => templates_path } unless templates_path.nil?
+        super(generator_class)
+      end
+
+      def template_folder_for clazz
+        # Search the potential matches in reverse order
+        # because subclasses have registered AFTER their
+        # superclasses and superclasses match the ===
+        # check...
+        generator_paths.reverse.each do |options|
+          if options[:class] === clazz
+            return options[:templates]
+          end
+        end
+        nil
+      end
+
+      ##
+      # Returns a new collection of paths to search within for generator declarations
+      # and more importantly, folders named, 'templates'.
+      #
+      # The collection of search_paths will be a subset of the following
+      # that will include only those directories that exist:
+      #
+      #     ./config/generators
+      #     ./vendor/generators
+      #     ~/Library/Sprouts/1.0/generators                    # OS X only
+      #     ~/.sprouts/1.0/generators                           # Unix only
+      #     [USER_HOME]/Application Data/Sprouts/cache/1.0/generators # Windows only
+      #     ENV['SPROUT_GENERATORS']                                  # Only if defined
+      #     [Generator Declaration __FILE__]/templates
+      #
+      # When the generators attempt to resolve templates, each of the preceding
+      # folders will be scanned for a child directory named 'templates'. Within
+      # that directory, the requested template name will be scanned and the first
+      # found template file will be used. This process will be repeated for each
+      # template file that is requested. 
+      #
+      # The idea is that you may wish to override some template files that a 
+      # generator creates, but leave others unchanged.
+      #
+      def search_paths
+        # NOTE: Do not cache this list, specific generators
+        # will modify it with their own lookups
+        create_search_paths.select { |path| File.directory?(path) }
+      end
+
+      private
+
+      def create_search_paths
+        paths = [
+                  File.join('config', 'generators'),
+                  File.join('vendor', 'generators'),
+                  Sprout.generator_cache
+                ]
+        paths << ENV['SPROUT_GENERATORS'] unless ENV['SPROUT_GENERATORS'].nil?
+        paths
+      end
+
+      ##
+      # I know this seems weird - but we can't instantiate the classes
+      # during registration because they register before they've been fully
+      # interpreted...
+      def update_registered_entities
+        registered_entities.collect! do |gen|
+          (gen.is_a?(Class)) ? gen.new : gen
+        end
+      end
+
+      def configure_instance generator
+        generator
+      end
+
+      def generator_paths
+        @generator_paths ||= []
+      end
+
+    end
+
+    class Base
+      include Sprout::Executable
+
+      def self.inherited base
+        # NOTE: We can NOT instantiate the class here,
+        # because only it's first line has been interpreted, if we 
+        # instantiate here, none of the code declared in the class body will
+        # be associated with this instance.
+        #
+        # Go ahead and register the class and update instances afterwards.
+        Sprout::Generator.register base, template_from_caller(caller.first)
+      end
+
+      ##
+      # The directory where files will be created.
+      add_param :path, Path, { :default => Dir.pwd }
+
+      ##
+      # Insteast of creating, destroy the files.
+      add_param :destroy, Boolean
+
+      ##
+      # Force the creation of files without prompting.
+      add_param :force, Boolean
+
+      ##
+      # Run the generator in Quiet mode - do not write
+      # status to standard output.
+      add_param :quiet, Boolean
+
+      ##
+      # A collection of paths to look in for named templates.
+      add_param :templates, Paths
+
+      ##
+      # The primary input for the application or component.
+      add_param :input, String, { :hidden_name => true, :required => true }
+
+
+      ##
+      # Set the default name for generators.
+      set :name, :application
+
+      ##
+      # The symbol name for which this generator is most 
+      # appropriate. 
+      #
+      # This value defaults to :application so, if you're working on an
+      # application generator, you can leave it as the default.
+      #
+      # For all other generator types, you'll want to select the most
+      # general project type that this generator may be useful in.
+      #
+      # Following are some example values:
+      #
+      #     :as3, :flex3, :flex4, :air2
+      #
+      # or core libraries:
+      #
+      #     :asunit4, :flexunit4
+      #
+      # or even other libraries:
+      #
+      #     :puremvc, :robotlegs, :swizz
+      #
+      attr_accessor :name
+      attr_accessor :logger
+      attr_accessor :pkg_name
+      attr_accessor :pkg_version
+
+      ##
+      # Record the actions and trigger them
+      def execute
+        return prepare_command.unexecute if destroy
+        prepare_command.execute
+      end
+
+      ##
+      # Rollback the generator
+      def unexecute
+        prepare_command.unexecute
+      end
+
+      def say message
+        logger.puts message.gsub("#{path}", '.') unless quiet
+      end
+
+      ##
+      # TODO: Add support for arbitrary templating languages.
+      # For now, just support ERB...
+      #
+      # TODO: This is also a possible spot where those of you that don't want
+      # to snuggle might put pretty-print code or some such
+      # modifiers...
+      def resolve_template content
+        require 'erb'
+        ERB.new(content, nil, '>').result(binding)
+      end
+
+      ##
+      # Returns a collection of templates that were provided on the 
+      # command line, followed by templates that are created by a 
+      # concrete generator, followed by the 
+      # Sprout::Generator.search_paths + 'templates' folders.
+      #
+      def template_paths
+        templates << Sprout::Generator::template_folder_for(self)
+        templates.concat default_search_paths
+      end
+
+      protected
+
+      def default_search_paths
+        Sprout::Generator.search_paths.collect { |path| File.join(path, 'templates') }
+      end
+
+      def prepare_command
+        @logger ||= $stdout
+        @command = Command.new self
+        manifest
+        @command
+      end
+
+      def directory name, &block
+        @command.directory name, &block
+      end
+
+      def file name, template=nil
+        @command.file name, template
+      end
+
+      def template name, template=nil
+        @command.template name, template
+      end
+
+      private
+
+      def self.template_from_caller caller_string
+        file = Sprout.file_from_caller caller_string
+        File.join(File.dirname(file), 'templates')
+      end
+
+    end
+  end
+end
+

data/lib/sprout/generator/command.rb

@@ -0,0 +1,67 @@
+
+module Sprout::Generator
+    class Command
+      attr_accessor :logger
+      attr_accessor :working_dir
+
+      attr_reader :generator
+
+      def initialize generator
+        @generator             = generator
+        @working_dir           = DirectoryManifest.new
+        @working_dir.generator = generator
+        @working_dir.path      = generator.path
+      end
+
+      def directory path, &block
+        raise Sprout::Errors::GeneratorError.new "Cannot create directory with nil path" if path.nil?
+        manifest           = DirectoryManifest.new
+        manifest.generator = generator
+        manifest.path      = File.join(@working_dir.path, path)
+        @working_dir.children << manifest
+        parent = @working_dir
+        @working_dir = manifest
+        yield if block_given?
+        @working_dir = parent
+      end
+
+      def template path, template=nil
+        raise Sprout::Errors::GeneratorError.new "Cannot create file with nil path" if path.nil?
+        manifest           = TemplateManifest.new
+        manifest.generator = generator
+        manifest.path      = File.join( working_dir.path, path )
+        manifest.template  = template
+        manifest.templates = generator.template_paths
+        working_dir.children << manifest
+      end
+
+      def file path, template=nil
+        raise Sprout::Errors::GeneratorError.new "Cannot create file with nil path" if path.nil?
+        manifest           = FileManifest.new
+        manifest.generator = generator
+        manifest.path      = File.join( working_dir.path, path )
+        manifest.template  = template
+        manifest.templates = generator.template_paths
+        working_dir.children << manifest
+      end
+
+      def execute
+        begin
+          working_dir.children.each do |child|
+            child.create
+          end
+        rescue StandardError => e
+          generator.say "[#{e.class}] #{e.message}"
+          working_dir.children.each do |child|
+            child.destroy
+          end
+          raise e
+        end
+      end
+
+      def unexecute
+        working_dir.destroy
+      end
+    end
+end
+