sprout 0.7.246 → 1.0.0.pre

data/lib/sprout/rdoc_parser.rb

@@ -0,0 +1,91 @@
+require 'rdoc/rdoc'
+
+module Sprout
+
+  class RDocParser
+
+    def parse content
+    end
+
+    def parse_from_caller_string caller_string
+      class_name, file_name, line_number = parse_caller_string caller_string
+      rdoc_description_for class_name, file_name, line_number
+    end
+
+    private
+
+    ##
+    # NOTE: Don't forget that this string *sometimes* contains a colon on Windows...
+    def parse_caller_string caller_string
+      sections = caller_string.split(' ')
+      parts = sections.first.split(':')
+      file_name   = parts.shift
+      line_number = parts.shift
+      class_name  = class_name_from_caller_string caller_string
+      #puts ">> class_name: #{class_name} file_name: #{file_name} line_number: #{line_number}"
+      [class_name, file_name, line_number]
+    end
+
+    def class_name_from_caller_string caller_string
+      parts   = caller_string.split(' ')
+      long    = parts.pop
+      matched = long.match /<class:([\w:]+)>/
+      matched[1] unless matched.nil?
+    end
+
+    def rdoc_description_for class_name, file_name, line_number
+      rendered = rendered_rdoc file_name
+    end
+
+    def rendered_rdoc file
+      @rendered_rdoc ||= render_rdoc file
+    end
+
+    def render_rdoc file
+      rdoc = RDoc::RDoc.new
+      puts "==================================="
+      puts ">> generating rdoc for: #{file}"
+
+      rdoc.document [ file, "--format=xml", "--output=temp" ]
+      {}
+    end
+
+    def render_rdoc_from_files
+      # This works to some extent...
+      #rdoc test/fixtures/examples/echo_inputs.rb --fmt=xml --op=tmp --all -q
+      # But the following does not do the same thing:
+      #response = rdoc.document [ file, '--fmt=xml', '--op=tmp', '--all', '-q' ]
+      
+      options           = RDoc::Options.new
+      options.files     = FileList[ file ]
+      options.formatter = 'markup'
+      options.op_dir    = './tmp'
+      options.verbosity = 0
+
+      rdoc.options      = options
+
+      #rdoc.stats        = RDoc::Stats.new 1, options.verbosity
+      #response = rdoc.document []
+      
+      response = rdoc.parse_files [ file ]
+      render_rdoc_toplevel response
+    end
+
+    def render_rdoc_toplevel toplevel
+      puts ">> toplevel: #{toplevel}"
+      toplevel.each do |file|
+        puts ">> file: #{file.name}"
+        puts ">> pretty: #{file.pretty_print}"
+      end
+
+      toplevel
+    end
+
+    def render_rdoc_bak file
+      rdoc = RDoc::RDoc.new
+      rdoc.options = RDoc::Options.new
+      rdoc.parse_files [file]
+    end
+  end
+end
+

data/lib/sprout/remote_file_loader.rb

@@ -1,70 +1,92 @@
+require 'digest/md5'
 
 module Sprout
-  class RemoteFileLoaderError < StandardError #:nodoc:
-  end
 
-  class RemoteFileLoader #:nodoc:
+  ##
+  # This class is used to load remote files from the network.
+  class RemoteFileLoader
+
+    class << self
     
-    def get_remote_file(uri, force=false, md5=nil)
-      response = fetch(uri.to_s)
-      if(force || response_is_valid?(response, md5))
-        return response
+      def load uri, md5=nil, filename=nil, force=false
+        response = fetch uri.to_s, filename
+        if(force || response_is_valid?(response, md5))
+          return response
+        end
+        nil
       end
-    end
-    
-    def response_is_valid?(response, expected_md5sum=nil)
-      if(expected_md5sum)
-        md5 = Digest::MD5.new
-        md5 << response
-        
-        if(expected_md5sum != md5.hexdigest)
-          puts "The MD5 Sum of the downloaded file (#{md5.hexdigest}) does not match what was expected (#{expected_md5sum})."
-          puts "Would you like to install anyway? [Yn]"
-          response = $stdin.gets.chomp!
-          if(response.downcase == 'y')
-            return true
-          else
-            raise RemoteFileLoaderError.new('MD5 Checksum failed')
+
+      private
+      
+      def response_is_valid? response, expected_md5sum
+        if(expected_md5sum)
+          md5 = Digest::MD5.new
+          md5 << response
+          
+          if(expected_md5sum != md5.hexdigest)
+            return prompt_for_md5_failure md5, expected_md5sum
           end
         end
+        return true
       end
-      return true
-    end
-    
-    def fetch(uri)
-      uri = URI.parse(uri)
-      progress = nil
-      response = nil
-      name = uri.path.split("/").pop
       
-      begin
-        open(uri.to_s, :content_length_proc => lambda {|t|
-          if t && t > 0
-            progress = ProgressBar.new(name, t)
-            progress.file_transfer_mode
-            progress.set(0)
-          else
-            progress = ProgressBar.new(name, 0)
+      def fetch uri, name=nil
+        begin
+          return open_uri uri, name
+        rescue SocketError => sock_err
+          raise Sprout::Errors::RemoteFileLoaderError.new("[ERROR] #{sock_err.to_s}")
+        rescue OpenURI::HTTPError => http_err
+          raise Sprout::Errors::RemoteFileLoaderError.new("[ERROR] Failed to load file from: '#{uri.to_s}'\n[REMOTE ERROR] #{http_err.io.read.strip}")
+        rescue Errno::ECONNREFUSED => econ_err
+          raise Errno::ECONNREFUSED.new("[ERROR] Connection refused at: '#{uri.to_s}'")
+        end
+      end
+
+      private
+
+      def open_uri uri, name=nil
+        uri = URI.parse(uri)
+        progress = nil
+        response = nil
+        name ||= uri.path.split("/").pop
+        
+        # Why was this here? Shouldn't the 'open' command work for other
+        # protocols like https?
+        #
+        #message = "The RemoteFileTask failed for #{name}. We can only handle HTTP requests at this time, it seems you were trying: '#{uri.scheme}'"
+        #raise Sprout::Errors::RemoteFileLoaderError.new(message) if uri.scheme != 'http' || uri.scheme != 'https'
+
+        # This is the strangest implementation I've seen in Ruby yet.
+        # Double lambda arguments with a block to top it off?! Gawsh.
+        open(uri.to_s, 
+          :content_length_proc => lambda {|length|
+            length ||= 0
+            progress = Sprout::ProgressBar.new(name, length)
             progress.file_transfer_mode
             progress.set(0)
-          end
-        },
-        :progress_proc => lambda {|s|
-          progress.set s if progress
+          },
+          :progress_proc => lambda {|length|
+            progress.set length if progress
         }) do |f|
           response = f.read
           progress.finish
         end
-      rescue SocketError => sock_err
-        raise RemoteFileLoaderError.new("[ERROR] #{sock_err.to_s}")
-      rescue OpenURI::HTTPError => http_err
-        raise RemoteFileLoaderError.new("[ERROR] Failed to load file from: '#{uri.to_s}'\n[REMOTE ERROR] #{http_err.io.read.strip}")
-      rescue Errno::ECONNREFUSED => econ_err
-        raise Errno::ECONNREFUSED.new("[ERROR] Connection refused at: '#{uri.to_s}'")
+
+        response
+      end
+
+      def prompt_for_md5_failure md5, expected_md5sum
+        puts "The MD5 Sum of the downloaded file (#{md5.hexdigest}) does not match what was expected (#{expected_md5sum})."
+        puts "Would you like to install anyway? [Yn]"
+        response = $stdin.gets.chomp!
+        if(response.downcase == 'y')
+          return true
+        else
+          raise Sprout::Errors::RemoteFileLoaderError.new('MD5 Checksum failed')
+        end
       end
 
-      return response
     end
-    
   end
 end
+

data/lib/sprout/remote_file_target.rb

@@ -1,178 +1,70 @@
 
 module Sprout
-  class RemoteFileTargetError < StandardError #:nodoc:
-  end
-
-  class RemoteFileTarget # :nodoc:
-
-
-    attr_accessor :gem_name
-    attr_accessor :gem_version
-
-    attr_writer   :archive_path
-    
-    # The string environment variable name to check before downloading anything.
-    attr_accessor :environment
-    
-    # The user path where this gem will download and install files
-    # This value is set by the Sprout::Builder that creates this RemoteFileTarget
-    attr_accessor :install_path
-
-    # Optional md5 hash, usually set in the sprout.spec for each RemoteFileTarget
-    # If this value is set, the downloaded archive will be hashed, the hashes will
-    # be compared and if they differ, the installation process will break.
-    attr_accessor :md5
-
-    # Used for dmg archives. Absolute path to the mounted dmg (essentially its name)
-    attr_accessor :mount_path
 
-    # Which platform will this RemoteFileTarget support.
-    # Supported options are:
-    #  * universal
-    #  * macosx
-    #  * win32
-    #  * linux
-    attr_accessor :platform
+  class RemoteFileTarget < FileTarget
 
-    # URL where Sprouts can go to download the RemoteFileTarget archive
-    attr_accessor :url
-    
-    # If the archive type cannot be assumed from the returned file name,
-    # it must be provided as one of the following:
-    #   :exe
-    #   :zip
-    #   :targz
-    #   :gzip
-    #   :swc
-    #   :rb
-    #   :dmg
-    # @see ArchiveUnpacker
     attr_accessor :archive_type
+    attr_accessor :url
+    attr_accessor :md5
 
-    # Filename for the downloaded file. Introduced to fix railsy URL issues.
-    attr_accessor :filename
-
-    # Relative path within the archive to the executable or binary of interest
-    def archive_path
-      @archive_path ||= ''
+    def validate
+      super
+      raise Sprout::Errors::ValidationError.new "RemoteFileTarget.url is a required field" if url.nil?
+      raise Sprout::Errors::ValidationError.new "RemoteFileTarget.md5 is a required field" if md5.nil?
+      raise Sprout::Errors::ValidationError.new "RemoteFileTarget.archive_type is a required field" if archive_type.nil?
     end
 
-    # Resolve this RemoteFileTarget now. This method is called by the Sprout::Builder
-    # and will download, install and unpack the described archive, unless it is
-    # already installed
-    def resolve(update=false)
-      # Wanted to raise, but it seems we support RemoteFileTargets that are actually self-installed binaries...
-      # like SWFMill on Linux. @see the BuilderTest.test_build_no_install for more info.
-      # raise RemoteFileTargetError.new('Cannot retrieve a RemoteFileTarget without a url') if url.nil?
-      return if url.nil?
-      
-      if(filename)
-        self.downloaded_path = File.join(File.dirname(downloaded_path), filename)
-      end
-
-      should_download = ( url && !File.exists?(installed_path) && !File.exists?(downloaded_path) )
+    def resolve
+      validate
+      load_unpack_or_ignore_archive
+      self
+    end
 
-      if(should_download)
-        content = download(url, update)
-        FileUtils.makedirs(File.dirname(downloaded_path))
-        FileUtils.touch(downloaded_path)
-        File.open(downloaded_path, 'rb+') do |file|
-          file.write(content)
-        end
-      end
+    protected
 
-      if(!File.exists?(installed_path) && !File.exists?(File.join(installed_path, archive_path)) )
-        archive_root = File.join(install_path, 'archive')
-        install(downloaded_path, archive_root, update, archive_type)
-      end
-    end
-    
-    # Return the basename of the executable that this RemoteFileTarget refers to
-    def executable
-      return File.basename(archive_path)
-    end
-    
-    # The root path to the unpacked archive files. This is the base path that will be added to any
-    # +archive_path+ relative paths
-    def installed_path
-      @installed_path ||= inferred_installed_path
-      return @installed_path
-    end
-    
-    def downloaded_path=(path)
-      @downloaded_path = path
-    end
-    
-    # Parent directory where archives are downloaded
-    # can be something like: ~/Library/Sprouts/cache/0.7/sprout-somesprout-tool.x.x.x/
-    def downloaded_path
-      @downloaded_path ||= File.join(install_path, file_name(url))
-      return @downloaded_path
-    end
-    
-    # Base file name represented by the provided +url+
-    # Will strip off any ? arguments and trailing slashes. May not play nice with Rails URLS,
-    # We expect archive file name suffixes like, zip, gzip, tar.gz, dmg, etc.
-    def file_name(url=nil)
-      return @filename if(@filename)
-
-      url ||= self.url
-      url = url.split('?').shift
-      
-      parts = url.split('/')
-      if(parts.last == '/')
-        parts.pop
-      end
-      
-      file = parts.pop
-      
-      if(!archive_type.nil? && file.match(/\.#{archive_type.to_s}$/).nil?)
-        file << ".#{archive_type.to_s}"
-      end
-      
-      return file
+    def expand_executable_path path
+      # TODO: This is failing b/c it gets called before
+      # we can set pkg_name and pkg_version - so join 
+      # raises null pointer error.
+      File.join unpacked_file, path
     end
-    
+
     private
-    
-    def inferred_installed_path
-      return environment_path || File.join(install_path, 'archive')
+
+    def downloaded_file
+      @downloaded_file ||= File.join(Sprout.cache, pkg_name, "#{md5}.#{archive_type}")
     end
-    
-    def environment_path
-      path_for_environmental_name(inferred_env_name_with_version) || path_for_environmental_name(inferred_env_name) || path_for_environmental_name(environment)
+
+    def unpacked_file
+      @unpacked_file ||= File.join(Sprout.cache, pkg_name, pkg_version)
     end
 
-    def path_for_environmental_name(name)
-      if(name && ENV[name])
-        if(!File.exist?(ENV[name]))
-          raise UsageError.new("Found Environmental variable at: #{name} but no files found at: #{ENV[name]}")
+    def load_unpack_or_ignore_archive
+      if(!File.exists?(unpacked_file))
+        if(!File.exists?(downloaded_file))
+          write_archive download_archive
         end
-        ENV[name]
+        unpack_archive
       end
     end
 
-    def inferred_env_name_with_version
-      return nil if (gem_version.nil? || gem_name.nil?)
-      version = gem_version.to_s.gsub('.', '_')
-      "#{inferred_env_name}_#{version}"
+    def download_archive
+      Sprout::RemoteFileLoader.load(url, md5, pkg_name)
     end
 
-    def inferred_env_name
-      return nil if gem_name.nil?
-      return gem_name.gsub('-', '_').upcase
+    def write_archive bytes
+      FileUtils.mkdir_p File.dirname(downloaded_file)
+      File.open downloaded_file, 'w+' do |f|
+        f.write bytes
+      end
     end
 
-    def download(url, update=false)
-      loader = RemoteFileLoader.new
-      loader.get_remote_file(url, update, md5)
-    end
-    
-    def install(from, to, force, archive_type=nil)
-      unpacker = ArchiveUnpacker.new
-      #puts "Unpacking from: #{from} to: #{to} force: #{force} type: #{archive_type}"
-      unpacker.unpack_archive(from, to, force, archive_type)
+    def unpack_archive
+      FileUtils.mkdir_p unpacked_file
+      unpacker = Sprout::ArchiveUnpacker.new
+      unpacker.unpack downloaded_file, unpacked_file, archive_type
     end
-    
+
   end
 end
+