sdoc_all 0.1.0 → 0.2.0.1

data/lib/sdoc_all/plugins.rb

@@ -1,32 +1,57 @@
 class SdocAll
   class Plugins < Base
-    def self.each(plugins_path, &block)
-      Dir[plugins_path + '*'].each(&block)
+    def initialize(config)
+      config ||= {}
+      config = {:path => config} unless config.is_a?(Hash)
+
+      config[:path] ||= sources_path
+
+      @config = {
+        :update => config.delete(:update) != false,
+        :path => Pathname.new(config.delete(:path)).expand_path,
+        :only => config_only_option(config),
+        :exclude => config_exclude_option(config),
+      }
+
+      unless @config[:path].directory?
+        raise ConfigError.new("path #{@config[:path]} is not a directory")
+      end
+
+      raise_unknown_options_if_not_blank!(config)
     end
 
-    def self.update_sources(options = {})
-      each(options[:plugins_path]) do |plugin|
-        Dir.chdir(plugin) do
-          system('git fetch origin && git reset --hard HEAD')
+    def add_tasks(options = {})
+      plugins = @config[:path].children.map do |path|
+        path if path.directory?
+      end.compact
+
+      plugins.delete_if{ |plugin| !config[:only].include?(plugin.basename.to_s.downcase) } if config[:only]
+      plugins.delete_if{ |plugin| config[:exclude].include?(plugin.basename.to_s.downcase) }
+
+      if config[:update] && options[:update]
+        plugins.each do |plugin|
+          if (plugin + '.git').directory?
+            Dir.chdir(plugin) do
+              Base.system('git fetch origin && git reset --hard origin')
+            end
+          end
         end
       end
-    end
 
-    def self.add_rdoc_tasks(options = {})
-      each(options[:plugins_path]) do |plugin|
+      plugins.each do |plugin|
+        paths = Rake::FileList.new
         Dir.chdir(plugin) do
-          pathes = Rake::FileList.new
-          pathes.include('lib/**/*.rb')
-          pathes.include('README*')
-          pathes.include('CHANGELOG*')
-          plugin_name = File.basename(plugin)
-          add_rdoc_task(
-            :name_parts => [plugin_name],
-            :src_path => plugin,
-            :doc_path => "plugins/#{plugin_name}",
-            :pathes => pathes.resolve
-          )
+          paths.include('lib/**/*.rb')
+          paths.include('README*')
+          paths.include('CHANGELOG*')
+          paths.resolve
         end
+        Base.add_task(
+          :src_path => plugin,
+          :doc_path => "plugins.#{plugin.basename}",
+          :paths => paths.to_a,
+          :title => "plugins: #{plugin.basename}"
+        )
       end
     end
   end

data/lib/sdoc_all/rails.rb

@@ -1,51 +1,69 @@
 class SdocAll
   class Rails < Base
-    def self.each
-      Gem.source_index.search(Gem::Dependency.new('rails', :all)).each do |spec|
-        yield spec.full_name, spec.version.to_s
+    def initialize(config)
+      config ||= {}
+      config = {:version => config} unless config.is_a?(Hash)
+
+      if config[:version]
+        unless self.class.versions.include?(config[:version])
+          raise ConfigError.new("you don't have rails #{config[:version]} installed")
+        end
+      else
+        if self.class.versions.empty?
+          raise ConfigError.new("you don't have any rails versions installed")
+        end
       end
+
+      @config = {
+        :version => config.delete(:version) || self.class.versions.last,
+      }
+
+      raise_unknown_options_if_not_blank!(config)
     end
 
-    def self.update_sources(options = {})
-      to_clear = Dir['rails-*']
-      each do |rails, version|
-        to_clear.delete(rails)
-        remove_if_present(rails) if options[:force]
-        unless File.directory?(rails)
-          with_env 'VERSION', version do
-            system('rails', rails, '--freeze')
-          end
+    def add_tasks(options = {})
+      version = @config[:version]
+      path = sources_path + version
+
+      unless path.directory?
+        Base.remove_if_present(sources_path)
+        sources_path
+        Base.with_env 'VERSION', version do
+          Base.system('rails', path, '--freeze')
         end
       end
-      to_clear.each do |rails|
-        remove_if_present(rails)
-      end
-    end
 
-    def self.add_rdoc_tasks(options = {})
-      each do |rails, version|
-        if File.directory?(rails)
-          Dir.chdir(rails) do
-            pathes = Rake::FileList.new
-            File.open('vendor/rails/railties/lib/tasks/documentation.rake') do |f|
-              true until f.readline['Rake::RDocTask.new("rails")']
-              until (line = f.readline.strip) == '}'
-                if line['rdoc.rdoc_files.include']
-                  pathes.include(line[/'(.*)'/, 1])
-                elsif line['rdoc.rdoc_files.exclude']
-                  pathes.exclude(line[/'(.*)'/, 1])
-                end
-              end
+      paths = Rake::FileList.new
+      Dir.chdir(path) do
+        File.open('vendor/rails/railties/lib/tasks/documentation.rake') do |f|
+          true until f.readline['Rake::RDocTask.new("rails")']
+          until (line = f.readline.strip) == '}'
+            if line['rdoc.rdoc_files.include']
+              paths.include(line[/'(.*)'/, 1])
+            elsif line['rdoc.rdoc_files.exclude']
+              paths.exclude(line[/'(.*)'/, 1])
             end
-            add_rdoc_task(
-              :name_parts => [version],
-              :src_path => rails,
-              :doc_path => rails,
-              :pathes => pathes.resolve
-            )
           end
         end
+        paths.resolve
+      end
+      Base.add_task(
+        :src_path => path,
+        :doc_path => "rails-#{version}",
+        :paths => paths.to_a,
+        :title => "rails-#{version}"
+      )
+    end
+
+    module ClassMethods
+      def versions
+        [].tap do |versions|
+          Gem.source_index.search(Gem::Dependency.new('rails', :all)).each do |spec|
+            versions << spec.version
+          end
+        end.sort.map(&:to_s)
       end
     end
+    extend ClassMethods
   end
 end

data/lib/sdoc_all/ruby.rb

@@ -2,58 +2,107 @@ require 'net/ftp'
 
 class SdocAll
   class Ruby < Base
-    def self.tars
-      Dir['ruby-*.tar.bz2']
+    def initialize(config)
+      config ||= {}
+      config = {:version => config} unless config.is_a?(Hash)
+
+      @config = {
+        :update => config.delete(:update) != false,
+        :version => config.delete(:version),
+      }
+
+      version = @config[:version]
+      unless version.present?
+        raise ConfigError.new("specify version of ruby (place archive to 'sources' directory or it will be download from ftp://ftp.ruby-lang.org/)")
+      end
+      self.class.find_or_download_matching_archive(version)
+
+      raise_unknown_options_if_not_blank!(config)
     end
 
-    def self.rubys
-      Dir['ruby-*'].select{ |path| File.directory?(path) }
+    def add_tasks(options = {})
+      archive = self.class.find_or_download_matching_archive(config[:version], :update => config[:update] && options[:update])
+      version = archive.full_version
+      path = sources_path + version
+
+      unless path.directory?
+        Base.remove_if_present(sources_path)
+        case archive.extension
+        when 'tar.bz2'
+          Base.system('tar', '-xjf', archive.path, '-C', sources_path)
+        when 'tar.gz'
+          Base.system('tar', '-xzf', archive.path, '-C', sources_path)
+        when 'zip'
+          Base.system('unzip', '-q', archive.path, '-d', sources_path)
+        end
+        File.rename(sources_path + "ruby-#{version}", path)
+      end
+
+      Base.add_task(
+        :src_path => path,
+        :doc_path => "ruby-#{version}",
+        :title => "ruby-#{version}"
+      )
     end
 
-    def self.update_sources(options = {})
-      to_clear = tars
-      Net::FTP.open('ftp.ruby-lang.org') do |ftp|
-        remote_path = Pathname.new('/pub/ruby')
-        ftp.debug_mode = true
-        ftp.passive = true
-        ftp.login
-        ftp.chdir(remote_path)
-        ftp.list('ruby-*.tar.bz2').each do |line|
-          tar_path, tar = File.split(line.split.last)
-          to_clear.delete(tar)
-          remove_if_present(tar) if options[:force]
-          unless File.exist?(tar) && File.size(tar) == ftp.size(remote_path + tar_path + tar)
-            ftp.getbinaryfile(remote_path + tar_path + tar)
+  private
+
+    ArchiveInfo = Struct.new(:path, :name, :full_version, :extension, :version)
+    module ClassMethods
+      def match_ruby_archive(path)
+        name = File.basename(path)
+        if match = /^ruby-((\d+\.\d+\.\d+)-p(\d+))(?:\.(tar\.(?:gz|bz2)|zip))$/.match(name)
+          ArchiveInfo.new.tap do |i|
+            i.path = path
+            i.name = name
+            i.full_version = match[1]
+            i.extension = match[4]
+            i.version = match[2].split('.').map(&:to_i) << match[3].to_i
           end
         end
       end
-      to_clear.each do |tar|
-        remove_if_present(tar)
-      end
 
-      to_clear = rubys
-      tars.each do |tar|
-        ruby = File.basename(tar, '.tar.bz2')
-        to_clear.delete(ruby)
-        remove_if_present(ruby) if options[:force]
-        unless File.directory?(ruby)
-          system('tar', '-xjf', tar)
+      def last_matching_ruby_archive(version, paths)
+        paths.map do |path|
+          match_ruby_archive(path)
+        end.compact.sort_by(&:version).reverse.find do |tar_info|
+          tar_info.full_version.starts_with?(version)
         end
       end
-      to_clear.each do |ruby|
-        remove_if_present(ruby)
+
+      def find_matching_archive(version)
+        paths = sources_path.parent.children.select(&:file?)
+        last_matching_ruby_archive(version, paths)
       end
-    end
 
-    def self.add_rdoc_tasks(options = {})
-      rubys.each do |ruby|
-        version = ruby.split('-', 2)[1]
-        add_rdoc_task(
-          :name_parts => [version],
-          :src_path => ruby,
-          :doc_path => ruby
-        )
+      def download_matching_archive(version)
+        Net::FTP.open('ftp.ruby-lang.org') do |ftp|
+          remote_path = '/pub/ruby'
+          ftp.debug_mode = true
+          ftp.passive = true
+          ftp.login
+          ftp.chdir(remote_path)
+          paths = ftp.list('ruby-*.tar.bz2').map{ |line| "#{remote_path}/#{line.split.last}" }
+
+          if tar = last_matching_ruby_archive(version, paths)
+            dest = sources_path.parent + tar.name
+            unless File.exist?(dest) && File.size(dest) == ftp.size(tar.path)
+              ftp.getbinaryfile(tar.path, dest)
+            end
+          end
+        end
+      end
+
+      def find_or_download_matching_archive(version, options = {})
+        if options[:update] || (archive = find_matching_archive(version)).nil?
+          download_matching_archive(version)
+          if (archive = find_matching_archive(version)).nil?
+            raise ConfigError.new("could not find version of ruby matching #{version.inspect}")
+          end
+        end
+        archive
       end
     end
+    extend ClassMethods
   end
 end

data/lib/sdoc_all/task.rb

@@ -0,0 +1,28 @@
+class SdocAll
+  class Task
+    attr_reader :src_path, :doc_path, :paths, :main, :title
+    def initialize(options = {})
+      @src_path = Pathname.new(options[:src_path]).expand_path
+      @doc_path = options[:doc_path]
+      @paths = options[:paths]
+      @main = options[:main]
+      @title = options[:title]
+    end
+
+    def run(options = {})
+      cmd = %w(sdoc)
+      cmd << '-o' << Base.docs_path + doc_path
+      cmd << '-t' << title
+      cmd << '-T' << 'direct'
+
+      if src_path.directory?
+        Dir.chdir(src_path) do
+          cmd << '-m' << main if main
+          Base.system(*cmd + paths)
+        end
+      else
+        Base.system(*cmd + [src_path])
+      end
+    end
+  end
+end

data/lib/sdoc_all.rb

@@ -11,77 +11,173 @@ require 'progress'
 __DIR__ = File.dirname(__FILE__)
 $:.unshift(__DIR__) unless $:.include?(__DIR__) || $:.include?(File.expand_path(__DIR__))
 
-class SdocAll
-  def self.run(options = {})
-    add_default_options!(options)
+class Array
+  def sort_by!(&block)
+    replace(sort_by(&block))
+  end
+end
 
-    Base.update_all_sources(options)
+class SdocAll
+  module ClassMethods
+    def update?
+      @update.nil? || @update
+    end
 
-    tasks = Base.rdoc_tasks(options)
+    def last_build_sdoc_version_path
+      Base.base_path + 'sdoc.version'
+    end
 
-    selected_tasks = []
-    selected_tasks << tasks.find_or_last_ruby(options[:ruby])
-    selected_tasks << tasks.find_or_last_rails(options[:rails])
-    tasks.gems.group_by{ |task| task.name_parts[0] }.sort_by{ |name, versions| name.downcase }.each do |name, versions|
-      selected_tasks << versions.sort_by{ |version| version.name_parts[1] }.last
+    def last_build_sdoc_version
+      last_build_sdoc_version_path.read rescue nil
     end
-    tasks.plugins.sort_by{ |task| task.name_parts[0] }.each do |task|
-      selected_tasks << task
+
+    def current_sdoc_version
+      Gem.searcher.find('sdoc').version.to_s
     end
 
-    if options[:exclude].is_a?(Array)
-      selected_tasks.delete_if do |task|
-        options[:exclude].any?{ |exclude| task.doc_path[exclude] }
+    def store_current_sdoc_version
+      last_build_sdoc_version_path.open('w') do |f|
+        f.write(current_sdoc_version)
       end
     end
 
-    selected_tasks.each_with_progress('Building documentation') do |task|
-      task.run(options)
-    end
+    def run(options = {})
+      begin
+        read_config
+        tasks = Base.tasks(:update => update? || options[:update])
+
+        if last_build_sdoc_version.nil? || last_build_sdoc_version != current_sdoc_version
+          Base.remove_if_present(Base.docs_path)
+        else
+          Dir.chdir(Base.docs_path) do
+            to_delete = Dir.glob('*')
+            tasks.each do |task|
+              to_delete.delete(task.doc_path)
+            end
+            to_delete.each do |path|
+              Base.remove_if_present(path)
+            end
+          end
+
+          tasks.each do |task|
+            doc_path = Base.docs_path + task.doc_path
+            src_path = task.src_path
+            if doc_path.exist?
+              latest = [src_path.mtime, src_path.ctime].max
+
+              created = Time.parse(File.read(doc_path + 'created.rid')) rescue nil
+              if created && latest < created
+                src_path.find do |path|
+                  Find.prune if path.directory? && path.basename.to_s[0] == ?.
+                  latest = [latest, src_path.mtime, src_path.ctime].max
+                  break unless latest < created
+                end
+              end
+              if created.nil? || latest >= created
+                Base.remove_if_present(doc_path)
+              end
+            end
+          end
+        end
+
+        merge = false
+        tasks.each_with_progress('docs') do |task|
+          unless (Base.docs_path + task.doc_path).directory?
+            puts
+            merge = true
+            task.run(options)
+          end
+        end
 
-    Dir.chdir(options[:docs_path]) do
-      Base.remove_if_present(options[:public_path])
-
-      pathes = []
-      titles = []
-      urls = []
-      selected_tasks.each do |rdoc_task|
-        doc_path = options[:docs_path] + rdoc_task.doc_path
-        if File.file?(doc_path + 'index.html')
-          pathes << rdoc_task.doc_path
-          titles << rdoc_task.title
-          urls << "/docs/#{rdoc_task.doc_path}"
+        if merge || !Base.public_path.exist?
+          Dir.chdir(Base.docs_path) do
+            paths = []
+            titles = []
+            urls = []
+            tasks.each do |task|
+              doc_path = Base.docs_path + task.doc_path
+              if File.file?(doc_path + 'index.html')
+                paths << task.doc_path
+                titles << task.title
+                urls << "/docs/#{task.doc_path}"
+              end
+            end
+
+            if paths.present?
+              Base.remove_if_present(Base.public_path)
+
+              cmd = %w(sdoc-merge)
+              cmd << '-o' << Base.public_path
+              cmd << '-t' << 'all'
+              cmd << '-n' << titles.join(',')
+              cmd << '-u' << urls.join(' ')
+              Base.system(*cmd + paths)
+
+              File.symlink(Base.docs_path, Base.public_path + 'docs')
+            end
+          end
         end
+        store_current_sdoc_version
+      rescue ConfigError => e
+        STDERR.puts e.to_s
       end
+    end
 
-      cmd = %w(sdoc-merge)
-      cmd << '-o' << options[:public_path]
-      cmd << '-t' << 'all'
-      cmd << '-n' << titles.join(',')
-      cmd << '-u' << urls.join(' ')
-      system(*cmd + pathes)
+    def read_config
+      Base.clear
+      config = YAML.load_file('config.yml').symbolize_keys rescue {}
+
+      min_update_interval = if config[:min_update_interval].to_s[/(\d+)\s*(.*)/]
+        value = $1.to_i
+        case $2
+        when /^d/
+          value.days
+        when /^h/
+          value.hours
+        when /^m/
+          value.minutes
+        else
+          value.seconds
+        end
+      else
+        1.hour
+      end
 
-      File.symlink(options[:docs_path], options[:public_path] + 'docs')
+      created = last_build_sdoc_version_path.mtime rescue nil
+      @update = created.nil? || created < min_update_interval.ago
+
+      if config[:sdoc] && config[:sdoc].is_a?(Array) && config[:sdoc].length > 0
+        errors = []
+        config[:sdoc].each do |entry|
+          begin
+            if entry.is_a?(Hash)
+              if entry.length == 1
+                Base.to_document(*entry.shift)
+              else
+                raise ConfigError.new("config entry #{entry.inspect} can not be understood - watch ident")
+              end
+            else
+              Base.to_document(entry, {})
+            end
+          rescue ConfigError => e
+            errors << e
+          end
+        end
+        if errors.present?
+          raise ConfigError.new(errors)
+        end
+      else
+        raise ConfigError.new("config did not specify what to document")
+      end
     end
   end
+  extend ClassMethods
+end
 
-private
-
-  def self.add_default_options!(options)
-    options[:base_path] = Pathname.new(Dir.pwd).freeze
-    options[:public_path] = Pathname.new(options[:base_path] + 'public').freeze
-    options[:docs_path] = Pathname.new(options[:base_path] + 'docs').freeze
-    options[:sources_path] = Pathname.new(options[:base_path] + 'sources').freeze
+require 'sdoc_all/base.rb'
+require 'sdoc_all/task.rb'
+require 'sdoc_all/config_error.rb'
 
-    options[:exclude] ||= %w(gems/actionmailer gems/actionpack gems/activerecord gems/activeresource gems/activesupport gems/rails)
-    options[:plugins_path] = Pathname.new(options[:plugins_path] || File.expand_path('~/.plugins')).freeze
-  end
+Dir.entries("#{__DIR__}/sdoc_all").grep(/\.rb$/).each do |file|
+  require "sdoc_all/#{file}"
 end
-
-require 'sdoc_all/base'
-require 'sdoc_all/ruby'
-require 'sdoc_all/gems'
-require 'sdoc_all/rails'
-require 'sdoc_all/plugins'
-require 'sdoc_all/rdoc_task'
-require 'sdoc_all/rdoc_tasks'

data/lib/tasks/sdoc_all_rake.rb

@@ -0,0 +1,15 @@
+require 'sdoc_all'
+
+task :default => :run
+
+desc "Build/update documentation"
+task :run do
+  SdocAll.run
+end
+
+namespace :run do
+  desc "Force update sources, before building/updating"
+  task :force do
+    SdocAll.run(:update => true)
+  end
+end

data/sdoc_all.gemspec

@@ -2,44 +2,41 @@
 
 Gem::Specification.new do |s|
   s.name = %q{sdoc_all}
-  s.version = "0.1.0"
+  s.version = "0.2.0.1"
 
   s.required_rubygems_version = Gem::Requirement.new(">= 1.2") if s.respond_to? :required_rubygems_version=
   s.authors = ["toy"]
-  s.date = %q{2009-04-22}
+  s.date = %q{2009-04-27}
   s.default_executable = %q{sdoc-all}
   s.description = %q{Command line tool to get documentation for ruby, rails, gems and plugins in one place}
-  s.email = %q{}
+  s.email = %q{ivan@workisfun.ru}
   s.executables = ["sdoc-all"]
-  s.extra_rdoc_files = ["bin/sdoc-all", "lib/sdoc_all/base.rb", "lib/sdoc_all/gems.rb", "lib/sdoc_all/generator/sdoc_all/sdoc_all_generator.rb", "lib/sdoc_all/generator/sdoc_all/templates/Rakefile", "lib/sdoc_all/generator/sdoc_all/templates/sdoc.config.yml.erb", "lib/sdoc_all/plugins.rb", "lib/sdoc_all/rails.rb", "lib/sdoc_all/rdoc_task.rb", "lib/sdoc_all/rdoc_tasks.rb", "lib/sdoc_all/ruby.rb", "lib/sdoc_all.rb", "lib/tasks/sdoc_all.rb", "README.rdoc"]
-  s.files = ["bin/sdoc-all", "lib/sdoc_all/base.rb", "lib/sdoc_all/gems.rb", "lib/sdoc_all/generator/sdoc_all/sdoc_all_generator.rb", "lib/sdoc_all/generator/sdoc_all/templates/Rakefile", "lib/sdoc_all/generator/sdoc_all/templates/sdoc.config.yml.erb", "lib/sdoc_all/plugins.rb", "lib/sdoc_all/rails.rb", "lib/sdoc_all/rdoc_task.rb", "lib/sdoc_all/rdoc_tasks.rb", "lib/sdoc_all/ruby.rb", "lib/sdoc_all.rb", "lib/tasks/sdoc_all.rb", "Manifest", "Rakefile", "README.rdoc", "VERSION.yml", "sdoc_all.gemspec"]
+  s.extra_rdoc_files = ["bin/sdoc-all", "lib/sdoc_all/base.rb", "lib/sdoc_all/config_error.rb", "lib/sdoc_all/gems.rb", "lib/sdoc_all/generator/sdoc_all/sdoc_all_generator.rb", "lib/sdoc_all/generator/sdoc_all/templates/config.yml", "lib/sdoc_all/generator/sdoc_all/templates/Rakefile", "lib/sdoc_all/paths.rb", "lib/sdoc_all/plugins.rb", "lib/sdoc_all/rails.rb", "lib/sdoc_all/ruby.rb", "lib/sdoc_all/task.rb", "lib/sdoc_all.rb", "lib/tasks/sdoc_all_rake.rb", "LICENSE", "README.rdoc"]
+  s.files = ["bin/sdoc-all", "lib/sdoc_all/base.rb", "lib/sdoc_all/config_error.rb", "lib/sdoc_all/gems.rb", "lib/sdoc_all/generator/sdoc_all/sdoc_all_generator.rb", "lib/sdoc_all/generator/sdoc_all/templates/config.yml", "lib/sdoc_all/generator/sdoc_all/templates/Rakefile", "lib/sdoc_all/paths.rb", "lib/sdoc_all/plugins.rb", "lib/sdoc_all/rails.rb", "lib/sdoc_all/ruby.rb", "lib/sdoc_all/task.rb", "lib/sdoc_all.rb", "lib/tasks/sdoc_all_rake.rb", "LICENSE", "Manifest", "Rakefile", "README.rdoc", "spec/sdoc_all/gems_spec.rb", "spec/sdoc_all/paths_spec.rb", "spec/sdoc_all/plugins_spec.rb", "spec/sdoc_all/rails_spec.rb", "spec/sdoc_all/ruby_spec.rb", "spec/sdoc_all_spec.rb", "spec/spec.opts", "spec/spec_helper.rb", "VERSION.yml", "sdoc_all.gemspec"]
   s.has_rdoc = true
   s.homepage = %q{http://github.com/toy/sdoc_all}
   s.rdoc_options = ["--line-numbers", "--inline-source", "--title", "Sdoc_all", "--main", "README.rdoc"]
   s.require_paths = ["lib"]
   s.rubyforge_project = %q{toytoy}
   s.rubygems_version = %q{1.3.2}
-  s.summary = %q{Command line tool to get documentation for ruby, rails, gems and plugins in one place}
+  s.summary = %q{documentation for everything}
 
   if s.respond_to? :specification_version then
     current_version = Gem::Specification::CURRENT_SPECIFICATION_VERSION
     s.specification_version = 3
 
     if Gem::Version.new(Gem::RubyGemsVersion) >= Gem::Version.new('1.2.0') then
-      s.add_runtime_dependency(%q<sdoc>, [">= 0"])
       s.add_runtime_dependency(%q<activesupport>, [">= 0"])
       s.add_runtime_dependency(%q<rake>, [">= 0"])
-      s.add_runtime_dependency(%q<progress>, [">= 0"])
+      s.add_runtime_dependency(%q<progress>, [">= 0", "= 0.0.8"])
     else
-      s.add_dependency(%q<sdoc>, [">= 0"])
       s.add_dependency(%q<activesupport>, [">= 0"])
       s.add_dependency(%q<rake>, [">= 0"])
-      s.add_dependency(%q<progress>, [">= 0"])
+      s.add_dependency(%q<progress>, [">= 0", "= 0.0.8"])
     end
   else
-    s.add_dependency(%q<sdoc>, [">= 0"])
     s.add_dependency(%q<activesupport>, [">= 0"])
     s.add_dependency(%q<rake>, [">= 0"])
-    s.add_dependency(%q<progress>, [">= 0"])
+    s.add_dependency(%q<progress>, [">= 0", "= 0.0.8"])
   end
 end