sprout 0.7.246 → 1.0.0.pre

data/lib/sprout/executable/boolean.rb

@@ -0,0 +1,35 @@
+module Sprout
+
+  module Executable
+
+    # Concrete param object for :boolean values
+    class Boolean < Param
+      attr_accessor :show_on_false
+
+      def initialize
+        super
+        @delimiter               = ' '
+        @option_parser_type_name = 'BOOL'
+        @show_on_false           = false
+        @value                   = false
+        @hidden_value            = true
+      end
+
+      def value=(value)
+        value = (value == "true" || value === true) ? true : false 
+        super value
+      end
+      
+      def visible?
+        @visible ||= value
+        if(show_on_false)
+          return true unless value
+        else
+          return @visible
+        end
+      end
+
+    end
+  end
+end
+

data/lib/sprout/executable/collection_param.rb

@@ -0,0 +1,53 @@
+module Sprout
+
+  module Executable
+    # Included by any parameters that represent
+    # a collection of values, rather than a single
+    # value.
+    # 
+    # Should only be included by classes that 
+    # extend Sprout::Executable::Param.
+    #
+    module CollectionParam
+
+      def initialize
+        super
+        @value = []
+        @delimiter = "+="
+        @option_parser_type_name = 'a,b,c'
+      end
+
+      # Assign the value and raise if 
+      def value=(val)
+        if(val.is_a?(String) || !val.is_a?(Enumerable))
+          message = "The #{name} property is an Enumerable. It looks like you may have used the assignment operator (=) with (#{value.inspect}) where the append operator (<<) was expected."
+          raise Sprout::Errors::ExecutableError.new(message)
+        end
+        @value = val
+      end
+
+      # Hide the collection param if no items
+      # have been added to it.
+      def visible?
+        (!value.nil? && value.size > 0)
+      end
+
+      # Returns a shell formatted string of the collection
+      def to_shell
+        prepare if !prepared?
+        validate
+        return '' if !visible?
+        return @to_shell_proc.call(self) unless @to_shell_proc.nil?
+        return value.join(' ') if hidden_name?
+        return to_shell_value.collect { |val|
+          "#{shell_name}#{delimiter}#{val}"
+        }.join(' ')
+      end
+
+      def to_shell_value
+        value
+      end
+    end
+  end
+end
+

data/lib/sprout/executable/file_param.rb

@@ -0,0 +1,53 @@
+module Sprout
+
+  module Executable
+
+    ##
+    # Concrete param object for :file values
+    #
+    # This class is actually referenced in Excecutables with:
+    #
+    #   add_param :some_name, File
+    #
+    # @see Sprout::Executable::ParameterFactory
+    #
+    class FileParam < Param 
+
+      def initialize
+        super
+        @option_parser_type_name = 'FILE'
+      end
+
+      def shell_value
+        clean_path value
+      end
+
+      def prepare_prerequisites
+        if file_task_name
+          self.value ||= belongs_to.rake_task_name
+          return
+        end
+
+        if prerequisite?(value)
+          file value
+          belongs_to.prerequisites << value
+        end
+      end
+
+      def validate
+        super
+
+        if(!file_task_name && !value.nil? && !File.exists?(value))
+          raise Sprout::Errors::InvalidArgumentError.new "No such file or directory - #{value}"
+        end
+      end
+
+      private
+
+      def prerequisite?(file)
+        file && !file_is_output?(file)
+      end
+    end
+  end
+end
+

data/lib/sprout/executable/files.rb

@@ -0,0 +1,26 @@
+module Sprout
+
+  module Executable
+
+    ##
+    # Concrete param object for collections of files
+    class Files < Executable::Param
+      include CollectionParam
+
+      def to_shell_value
+        value.collect do |path|
+          clean_path path
+        end
+      end
+
+      def prepare_prerequisites
+        value.each do |f|
+          file f
+          belongs_to.prerequisites << f
+        end
+      end
+
+    end
+  end
+end
+

data/lib/sprout/executable/number.rb

@@ -0,0 +1,10 @@
+
+module Sprout
+
+  module Executable
+
+    # Concrete param object for numberic values
+    class Number < Param; end
+  end
+end
+

data/lib/sprout/executable/param.rb

@@ -0,0 +1,222 @@
+
+module Sprout
+
+  module Executable
+
+    ##
+    # The abstract base class for all Executable parameters.
+    #
+    class Param
+      DEFAULT_DELIMITER               = '='
+      DEFAULT_OPTION_PARSER_TYPE_NAME = 'STRING'
+
+      # These values should usually be pulled
+      # from the 'belongs_to' executable:
+      DEFAULT_PREFIX                  = '--'
+      DEFAULT_SHORT_PREFIX            = '-'
+
+      attr_accessor :belongs_to
+      attr_accessor :description
+      attr_accessor :hidden_name
+      attr_accessor :hidden_value
+      attr_accessor :file_task_name
+      attr_accessor :name
+      attr_accessor :prefix
+      attr_accessor :reader
+      attr_accessor :required
+      attr_accessor :to_shell_proc
+      attr_accessor :type
+      attr_accessor :validator
+      attr_accessor :value
+      attr_accessor :visible
+      attr_accessor :writer
+
+      ##
+      # Executable::Params join their name/value pair with an
+      # equals sign by default, this can be modified 
+      # To a space or whatever you wish.
+      attr_accessor :delimiter
+
+      ##
+      # Set the file_expression (blob) to append to each path
+      # in order to build the prerequisites FileList.
+      #
+      # Defaults to the parent Executable.default_file_expression
+      #
+      # NOTE: We should add support for file_expressionS
+      # since these are really just blobs that are sent
+      # to the FileList[expr] and that interface accepts
+      # an array.
+      attr_writer :file_expression
+
+      ##
+      # Return the name with a single leading dash
+      # and underscores replaced with dashes
+      attr_writer :shell_name
+
+      def initialize
+        @description             = 'Default Description'
+        @hidden_value            = false
+        @hidden_name             = false
+        @delimiter               = DEFAULT_DELIMITER
+        @option_parser_type_name = DEFAULT_OPTION_PARSER_TYPE_NAME
+      end
+
+      ##
+      # By default, Executable::Params only appear in the shell
+      # output when they are not nil
+      def visible?
+        !value.nil?
+      end
+      
+      ##
+      # Raise an exception if a required parameter is nil.
+      def required?
+        (required == true)
+      end
+      
+      ##
+      # Ensure this parameter is in a valid state, raise an appropriate
+      # exception if it is not.
+      def validate
+        if(required? && value.nil?)
+          raise Sprout::Errors::MissingArgumentError.new("#{name} is required and must not be nil")
+        end
+      end
+
+      ##
+      # Set the default value of the parameter.
+      def default=(value)
+        self.value = value
+        @default = value
+      end
+
+      def default
+        @default
+      end
+      
+      ##
+      # Prepare the parameter for execution or delegation, depending
+      # on what context we're in.
+      def prepare
+        prepare_prerequisites
+        @prepared = true
+      end
+
+      ##
+      # Returns true if this parameter has already been prepared.
+      def prepared?
+        @prepared
+      end
+      
+      ##
+      # Should the param name be hidden from the shell?
+      # Used for params like 'input' on mxmlc
+      def hidden_name?
+        @hidden_name
+      end
+      
+      ##
+      # Should the param value be hidden from the shell?
+      # Usually used for Boolean toggles like '-debug'
+      def hidden_value?
+        @hidden_value
+      end
+      
+      ##
+      # Leading character for each parameter
+      # Can sometimes be an empty string,
+      # other times it's a double dash '--'
+      # but usually it's just a single dash '-'
+      def prefix
+        @prefix ||= (belongs_to.nil?) ? DEFAULT_PREFIX : belongs_to.default_prefix
+      end
+
+      def short_prefix
+        @short_prefix ||= (belongs_to.nil?) ? DEFAULT_SHORT_PREFIX : belongs_to.default_short_prefix
+      end
+
+      def option_parser_declaration
+        declaration = [ prefix, option_parser_name ]
+        # TODO: Need to figure out how to support hidden name inputs...
+        #if(hidden_name?)
+          #declaration = [option_parser_type_output]
+        #
+        if(!hidden_value?)
+          declaration << delimiter << option_parser_type_output
+        end
+        declaration.join('')
+      end
+
+      def option_parser_short_name
+        [ short_prefix, short_name ].join('')
+      end
+      
+      def short_name
+        @short_name ||= name.to_s.split('').shift
+      end
+
+      def shell_value
+        value.to_s
+      end
+
+      def file_expression
+        @file_expression ||= belongs_to.default_file_expression
+      end
+
+      def shell_name
+        @shell_name ||= prefix + name.to_s.split('_').join('-')
+      end
+
+      def to_shell
+        prepare if !prepared?
+        validate
+        return '' if !visible?
+        return @to_shell_proc.call(self) unless @to_shell_proc.nil?
+        return shell_value if hidden_name?
+        return shell_name if hidden_value?
+        return [shell_name, delimiter, shell_value].join
+      end
+      
+      # Create a string that can be turned into a file
+      # that rdoc can parse to describe the customized
+      # or generated task using param name, type and
+      # description
+      def to_rdoc
+        result = ''
+        parts = description.split("\n") unless description.nil?
+        result << "# #{parts.join("\n# ")}\n" unless description.nil?
+        result << "def #{name}=(#{type})\n  @#{name} = #{type}\nend\n\n"
+        return result
+      end
+
+      protected
+
+      def option_parser_name
+        name.to_s.gsub('_', '-')
+      end
+
+      def option_parser_type_name
+        @option_parser_type_name
+      end
+
+      def option_parser_type_output
+        type = hidden_value? ? '' : option_parser_type_name
+        required? ? type : "[#{type}]"
+      end
+
+      def prepare_prerequisites
+      end
+
+      def clean_path path
+        Sprout::System.create.clean_path path
+      end
+
+      def file_is_output? file
+        belongs_to.respond_to?(:output) && belongs_to.output.to_s == file
+      end
+
+    end
+  end
+end
+

data/lib/sprout/executable/parameter_factory.rb

@@ -0,0 +1,28 @@
+
+module Sprout::Executable
+
+  ##
+  # A factory to create concrete Executable::Param
+  # entities from a set of known types.
+  #
+  # If an unrecognized Class reference is provided
+  # we will instantiate it and ensure that it 
+  # responds to the public members of the 
+  # Executable::Param interface.
+  class ParameterFactory
+
+    class << self
+
+      def create type
+        # Didn't want to clobber the stdlib references
+        # to these two important data types...
+        # But wanted to keep the add_param interface
+        # clean and simple.
+        return StringParam.new if type == String
+        return FileParam.new if type == File
+        type.new
+      end
+    end
+  end
+end
+

data/lib/sprout/executable/path.rb

@@ -0,0 +1,21 @@
+module Sprout
+
+  module Executable
+
+    ##
+    # Concrete param object for :path values
+    class Path < Executable::Param
+
+      def prepare_prerequisites
+        if(value && !file_is_output?(value))
+          files = FileList[value + file_expression]
+          files.each do |f|
+            file f
+            belongs_to.prerequisites << f
+          end
+        end
+      end
+    end
+  end
+end
+