sprout 0.3.35

data/lib/progress_bar.rb

@@ -0,0 +1,314 @@
+#
+# Ruby/ProgressBar - a text progress bar library
+#
+# Copyright (C) 2001-2005 Satoru Takabayashi <satoru@namazu.org>
+#     All rights reserved.
+#     This is free software with ABSOLUTELY NO WARRANTY.
+#
+# You can redistribute it and/or modify it under the terms
+# of Ruby's license.
+#
+
+class ProgressBar
+  VERSION = "0.9"
+  def self.new(title, total)
+    return ProgressBarManager.instance.add(title, total)
+  end
+end
+
+class ProgressBarImpl
+  
+  def initialize (title, total, out = STDERR)
+    @title = title
+    @total = total
+    @out = out
+    @terminal_width = 80
+    @bar_mark = "."
+    @current = 0
+    @previous = 0
+    @finished_p = false
+    @start_time = Time.now
+    @previous_time = @start_time
+    @title_width = 18
+    @format = "%-#{@title_width}s %3d%% %s %s"
+    @format_arguments = [:title, :percentage, :bar, :stat]
+    clear
+    show
+  end
+  attr_reader   :title
+  attr_reader   :current
+  attr_reader   :total
+  attr_accessor :start_time,
+                :title_width,
+                :bar_mark
+
+  private
+  def fmt_bar
+    bar_width = do_percentage * @terminal_width / 100
+    sprintf("|%s%s|", 
+            @bar_mark * bar_width, 
+            " " *  (@terminal_width - bar_width))
+  end
+
+  def fmt_percentage
+    do_percentage
+  end
+
+  def fmt_stat
+    if @finished_p then elapsed else eta end
+  end
+
+  def fmt_stat_for_file_transfer
+    if @finished_p then 
+      sprintf("%s %s %s", bytes, transfer_rate, elapsed)
+    else 
+      sprintf("%s %s %s", bytes, transfer_rate, eta)
+    end
+  end
+
+  def fmt_title
+    @title[0,(@title_width - 1)] + ":"
+  end
+
+  def convert_bytes (bytes)
+    if bytes < 1024
+      sprintf("%6dB", bytes)
+    elsif bytes < 1024 * 1000 # 1000kb
+      sprintf("%5.1fKB", bytes.to_f / 1024)
+    elsif bytes < 1024 * 1024 * 1000  # 1000mb
+      sprintf("%5.1fMB", bytes.to_f / 1024 / 1024)
+    else
+      sprintf("%5.1fGB", bytes.to_f / 1024 / 1024 / 1024)
+    end
+  end
+
+  def transfer_rate
+    bytes_per_second = @current.to_f / (Time.now - @start_time)
+    sprintf("%s/s", convert_bytes(bytes_per_second))
+  end
+
+  def bytes
+    convert_bytes(@current)
+  end
+
+  def format_time (t)
+    t = t.to_i
+    sec = t % 60
+    min  = (t / 60) % 60
+    hour = t / 3600
+    sprintf("%02d:%02d:%02d", hour, min, sec);
+  end
+
+  # ETA stands for Estimated Time of Arrival.
+  def eta
+    if @current == 0
+      "ETA:  --:--:--"
+    else
+      elapsed = Time.now - @start_time
+      eta = elapsed * @total / @current - elapsed;
+      sprintf("ETA:  %s", format_time(eta))
+    end
+  end
+
+  def elapsed
+    elapsed = Time.now - @start_time
+    sprintf("Time: %s", format_time(elapsed))
+  end
+  
+  def eol
+    if @finished_p then "\n" else "\r" end
+  end
+
+  def do_percentage
+    if @total.zero?
+      100
+    else
+      @current  * 100 / @total
+    end
+  end
+
+  def get_width
+    return 80
+    # FIXME: I don't know how portable it is.
+    default_width = 80
+    begin
+      tiocgwinsz = 0x5413
+      data = [0, 0, 0, 0].pack("SSSS")
+      if @out.ioctl(tiocgwinsz, data) >= 0 then
+        rows, cols, xpixels, ypixels = data.unpack("SSSS")
+        if cols >= 0 then cols else default_width end
+      else
+        default_width
+      end
+    rescue Exception
+      default_width
+    end
+  end
+
+  def show
+    arguments = @format_arguments.map {|method| 
+      method = sprintf("fmt_%s", method)
+      send(method)
+    }
+    line = sprintf(@format, *arguments)
+
+    width = get_width
+    if line.length == width - 1 
+      @out.print(line + eol)
+      @out.flush
+    elsif line.length >= width
+      @terminal_width = [@terminal_width - (line.length - width + 1), 0].max
+      if @terminal_width == 0 then @out.print(line + eol) else show end
+    else # line.length < width - 1
+      @terminal_width += width - line.length + 1
+      show
+    end
+    @previous_time = Time.now
+  end
+
+  def show_if_needed
+    if @total.zero?
+      cur_percentage = 100
+      prev_percentage = 0
+    else
+      cur_percentage  = (@current  * 100 / @total).to_i
+      prev_percentage = (@previous * 100 / @total).to_i
+    end
+
+    # Use "!=" instead of ">" to support negative changes
+    if cur_percentage != prev_percentage || 
+        Time.now - @previous_time >= 1 || @finished_p
+      show
+    end
+  end
+
+  public
+  def clear
+    @out.print "\r"
+    @out.print(" " * (get_width - 1))
+    @out.print "\r"
+  end
+
+  def finish
+    @current = @total
+    @finished_p = true
+    show
+  end
+
+  def finished?
+    @finished_p
+  end
+
+  def file_transfer_mode
+    @format_arguments = [:title, :percentage, :bar, :stat_for_file_transfer]
+  end
+
+  def format= (format)
+    @format = format
+  end
+
+  def format_arguments= (arguments)
+    @format_arguments = arguments
+  end
+
+  def halt
+    @finished_p = true
+    show
+  end
+
+  def inc (step = 1)
+    @current += step
+    @current = @total if @current > @total
+    show_if_needed
+    @previous = @current
+  end
+
+  def set (count)
+    if count < 0 || count > @total
+      @total = count
+    end
+    @current = count
+    show_if_needed
+    @previous = @current
+  end
+
+  def inspect
+    "#<ProgressBar:#{@current}/#{@total}>"
+  end
+end
+
+class ReversedProgressBar < ProgressBar
+  def do_percentage
+    100 - super
+  end
+end
+
+class ProgressBarOutputStream
+  attr_reader :title
+  
+  def initialize(mgr)
+    @mgr = mgr
+    @msg = ''
+  end
+  
+  def print(msg)
+    @msg = msg
+  end
+  
+  def flush
+    @mgr.flush
+  end
+  
+  def to_s
+    return @msg.clone.split("\n").join("").split("\r").join("")
+  end
+  
+end
+
+class ProgressBarManager
+  include Singleton
+  
+  def initialize
+    @outio = $stderr
+    @finished = {}
+    @bars = {}
+    @outs = {}
+  end
+  
+  def add(title, total1)
+    if(@bars[title])
+      raise Error.new
+    end
+    @outs[title] = ProgressBarOutputStream.new(self)
+    @bars[title] = ProgressBarImpl.new(title, total1, @outs[title])
+  end
+  
+  def print(title)
+    str = ''
+    str += @outs[title].to_s
+    str += "\r"
+    @outio.print "\r"
+    @outio.print str
+  end
+  
+  def flush
+    str = ""
+    
+    @bars.keys.each do |title|
+      print(title)
+    end
+    
+    finished = true
+    @bars.values.each do |bar|
+      if(bar.finished?)
+        print(bar.title)
+        @outio.print "\n"
+        @outs.delete(bar.title)
+        @bars.delete(bar.title)
+      else
+        finished = false
+      end
+    end
+  end
+  
+end

data/lib/project.rb

@@ -0,0 +1,10 @@
+
+module PatternPark
+  
+  class Project < Sprout
+    
+    def type
+      return 'project'
+    end
+  end
+end

data/lib/project_model.rb

@@ -0,0 +1,59 @@
+
+module PatternPark
+  class ProjectModel
+    include Singleton
+  
+    attr_accessor :project_name,
+                  :src_dir,
+                  :lib_dir,
+                  :bin_dir,
+                  :test_dir,
+                  :asset_dir,
+                  :skin_dir,
+                  :model_dir,
+                  :view_dir,
+                  :controller_dir,
+                  :language
+  
+    def initialize
+      @project_name   = 'Project'
+      @src_dir        = 'src'
+      @lib_dir        = 'lib'
+      @bin_dir        = 'bin'
+      @test_dir       = 'test'
+      @asset_dir      = 'assets'
+      @skin_dir       = File.join(@asset_dir, 'img', 'skins')
+
+      @language       = 'as2'
+
+      @model_dir      = nil
+      @view_dir       = nil
+      @controller_dir = nil
+    end
+    
+    def project_path
+      return Sprout.project_path
+    end
+    
+    def model_dir
+      if(@model_dir.nil?)
+        @model_dir = File.join(src_dir, project_name.downcase, 'models')
+      end
+      return @model_dir
+    end
+    
+    def view_dir
+      if(@view_dir.nil?)
+        @view_dir = File.join(src_dir, project_name.downcase, 'views')
+      end
+      return @view_dir
+    end
+    
+    def controller_dir
+      if(@controller_dir.nil?)
+        @controller_dir = File.join(src_dir, project_name.downcase, 'controllers')
+      end
+      return @controller_dir
+    end
+  end
+end

data/lib/remote_file_loader.rb

@@ -0,0 +1,186 @@
+require 'open-uri'
+
+module PatternPark
+  class RemoteFileLoader
+    include Archive::Tar
+    
+    def get_remote_file(uri, target)
+      if(Sprout.update || !File.exists?(target))
+        begin
+          response = fetch(uri.to_s)
+        rescue SocketError => e
+          puts "[ERROR] Unable to connect to #{uri}"
+          return
+        end
+        FileUtils.makedirs(File.dirname(target))
+
+        if(Sprout.update && File.exists?(target))
+          File.delete(target)
+        end
+
+        File.open(target, 'wb') do |f|
+          f.write(response)
+        end
+      end
+    end
+    
+    def fetch(location)
+      uri = URI.parse(location)
+
+      # Download the file now to the downloads dir
+      # If the file is an archive (zip, gz, tar, tar.gz, dmg), extract to
+      # AsProject/remote_files/@name/@location
+      # Check the location again...
+      progress = nil
+      response = nil
+      head = nil
+      name = uri.path.split("/").pop
+
+      raise UsageError.new("The RemoteFileTask failed for #{name}. WE can only handle HTTP requests at this time, it seems you were trying: #{location}") if uri.scheme != 'http'
+      
+
+      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)
+            progress.file_transfer_mode
+            progress.set(0)
+          end
+        },
+        :progress_proc => lambda {|s|
+          progress.set s if progress
+        }) {|f|
+          response = f.read
+          progress.finish
+        }
+        
+        return response
+    end
+    
+    def unpack_downloaded_file(file_name, dir)
+      if(!File.exists?(dir))
+        if(is_zip?(file_name))
+          unpack_zip(file_name, dir)
+        elsif(is_targz?(file_name))
+          unpack_targz(file_name, dir)
+        elsif(is_dmg?(file_name))
+          unpack_dmg(file_name, dir)
+        elsif(is_swc?(file_name))
+          # just copy the swc...
+        elsif(is_rb?(file_name))
+          return
+        elsif(!is_exe?(file_name))
+          raise UsageError.new("RemoteFileTask does not know how to unpack files of type: #{file_name}")
+        end
+      end
+    end
+    
+    def unpack_zip(zip_file, dir)
+      # Avoid the rubyzip Segmentation Fault bug
+      # at least on os x...
+      if(RUBY_PLATFORM =~ /darwin/)
+          # Unzipping on OS X
+          FileUtils.makedirs(dir)
+          %x(cd #{dir};unzip #{zip_file})
+      else
+        retries = 0
+        begin
+          retries += 1
+          Zip::ZipFile::open(zip_file) do |zf|
+              zf.each do |e|
+                  fpath = File.join(dir, e.name)
+                  FileUtils.mkdir_p(File.dirname(fpath))
+                  zf.extract(e, fpath)
+              end
+          end
+        rescue StandardError => e
+          if(retries < 3)
+            puts ">> [ZIP ERROR ENCOUNTERED] trying again with: #{dir}"
+            FileUtils.rm_rf(dir)
+            FileUtils.makedirs(dir)
+            retry
+          end
+          raise e
+        end
+      end
+    end
+    
+    def unpack_targz(tgz_file, dir)
+      tar = Zlib::GzipReader.new(File.open(tgz_file, 'rb'))
+      Minitar.unpack(tar, dir)
+    end
+    
+    # This is actually not unpacking the FlashPlayer
+    # Binary file as expected...
+    # OSX is treated the player binary as if it is
+    # a regular text file, but if it is copied manually,
+    # the command works fine!?
+    def unpack_dmg(dmg_file, dir)
+      # 1) Mount the dmg in place
+      # 2) Recursively Copy it's contents to asproject_home
+      # 3) Unmount the dmg
+      if(mounted_path.nil?)
+        raise StandardError.new('DMG file downloaded, but the RemoteFileTask needs a mounted_path in order to mount it')
+      end
+
+      if(!File.exists?(full_mounted_path))
+        system("hdiutil mount #{dmg_file}")
+      end
+      
+      begin
+        mounted_target = File.join(full_mounted_path, extracted_file)
+  
+        # Copy the DMG contents using system copy rather than ruby utils
+        # Because OS X does something special with .app files that the
+        # Ruby FileUtils and File classes break...
+        Log.puts '=================='
+        from = mounted_target
+#        from = File.join(full_mounted_path, extracted_file)
+        to = File.join(@user.downloads, @name.to_s, extracted_file)
+        Log.puts 'from: ' + from
+        Log.puts 'to: ' + to
+        FileUtils.makedirs(File.dirname(to))
+        
+        if(File.exists?(from))
+          `ditto '#{from}' '#{to}'`
+        end
+      rescue
+        if(File.exists?(full_mounted_path))
+          system("hdiutil unmount -force \"#{full_mounted_path}\"")
+        end
+      end
+    end
+    
+    def is_exe?(file)
+      return (file.split('.').pop == 'exe')
+    end
+    
+    def is_zip?(file)
+      return (file.split('.').pop == 'zip')
+    end
+    
+    def is_targz?(file)
+      parts = file.split('.')
+      return (parts.pop == 'gz' && parts.pop == 'tar')
+    end
+    
+    def is_gzip?(file)
+      return (file.split('.').pop == 'gz')
+    end
+    
+    def is_swc?(file)
+      return (file.split('.').pop == 'swc')
+    end
+    
+    def is_rb?(file)
+      return (file.split('.').pop == 'rb')
+    end
+    
+    def is_dmg?(file)
+      return (file.split('.').pop == 'dmg')
+    end
+  end
+end