quarry 0.3.0 → 0.4.0

data/work/sandbox/build/pack.rb

@@ -0,0 +1,228 @@
+require 'reap/tool'
+
+
+module Reap
+
+  class Site < Build
+
+    # Remove package products.
+    #
+    # Can task an +omit+ option as a regular expression
+    # omit certain removals.
+
+    def clobber_packages(opts=nil)
+      opts ||= {}
+
+      omit = opts[:omit]
+
+      pkgdir = "pkg"  # FIXME
+
+      packages = glob(File.join(pkgdir, '*'))
+
+      if omit
+        packages.reject!{ |path| omit =~ path }
+      end
+
+      packages.each do |path|
+        rm_r(path)
+      end
+    end
+
+    # Create a Tar'd Gzip package.
+
+    def package_tgz
+      status "Creating .tgz package"
+
+      config = configuration['pack'] || {}
+      config = config['tgz'] || {}
+
+      package = package.clone
+      package.update(config)
+
+      store = config[:store] || 'pkg'
+      templ = config[:template]
+
+      name  = package.stage_name(templ)
+      stage = File.join(store, name)
+      files = package.filelist
+
+      stage(stage, files)
+
+      if dryrun?
+        status "tar -cxf #{name}.tgz"
+      else
+        file = nil
+        cd(store) do
+          file = tgz(name)
+        end
+        transfer(file, store)
+      end
+    end
+
+    # Create Zip package.
+
+    def package_zip
+      status "Creating .zip package"
+
+      config = configuration['pack'] || {}
+      config = config['zip'] || {}
+
+      package = package().clone
+      package.update(config)
+
+      store = config[:store] || 'pkg'
+      templ = config[:template]
+
+      name  = package.stage_name(templ)
+      stage = File.join(store, name)
+      files = package.filelist
+
+      stage(stage, files)
+
+      if dryrun?
+        status "tar -cxf #{name}.zip"
+      else
+        file = nil
+        cd(store) do
+          file = zip(name)
+        end
+        transfer(file, store)
+      end
+    end
+
+    # Create a Gem package.
+    #
+    # TODO: Should this use staging too, like zip/tgz?
+
+    def package_gem
+      status "Creating .gem package"
+
+      config = configuration['pack'] || {}
+      config = config['gem'] || {}
+
+      package = package().clone
+      package.update(config)
+
+      store = config[:store] || 'pkg'
+
+      #dir  = Dir.pwd
+
+      file = nil
+      #cd(dir) do
+        #status "vi #{metadata.name}.gemspec"
+        builder = ::Gem::Builder.new(gemspec(package))
+        status "gem build #{package.name}"
+        unless dryrun?
+          file = builder.build
+          file = File.expand_path(file)
+        end
+      #end
+
+      transfer(file, store)
+    end
+
+    private
+
+    # Create Gem::Specification.
+
+    def gemspec(package)
+      distribute = package.filelist
+      #distribute = Dir.multiglob_with_default( '**/*', distribute )
+
+      ::Gem::Specification.new do |spec|
+        spec.name              = package.name
+        spec.version           = package.version
+        spec.summary           = package.brief
+        spec.description       = package.description
+        spec.author            = package.author
+        spec.email             = package.email
+        spec.rubyforge_project = package.development if /rubyforge.org/ =~ package.development
+        spec.homepage          = package.homepage
+
+        # Platform: ruby, mswin32, i586-linux, powerpc-darwin, current
+        spec.platform = 'ruby'  # TODO current support!
+
+        spec.require_paths = [package.gem_path].flatten.reverse
+
+        #if package.platform != 'ruby'
+        #  spec.require_paths.concat(spec.require_paths.collect{ |d| File.join(d, platform) })
+        #end
+
+        spec.bindir = "bin"
+        spec.executables  = package.executables
+        spec.requirements = package.requirements
+        spec.has_rdoc     = package.document
+
+        if package.dependencies
+          package.dependencies.each do |d,v|
+            spec.add_dependency(*[d,v].compact)
+          end
+        end
+
+        spec.extensions = package.compile
+
+        spec.files = distribute
+
+        spec.test_files = distribute.select{ |f| f =~ /^test\// }  # TODO make test_files configurable
+      end
+    end
+
+    # Transfer package file to storage location.
+
+    def transfer(file, store)
+      # move to store, unless already there
+      dest = File.join(store, File.basename(file))
+      dest = File.expand_path(dest)
+      mv(file, store) unless file == dest
+    end
+
+    # Report that a package has been built.
+    # FIXME
+
+    def report_package_built(type, file)
+      r = ''
+      r << "\n  Successfully built #{type}"
+      r << "\n  Name: #{package.name}"
+      r << "\n  Version: #{package.version}"
+      r << "\n  File: #{File.basename(file)}"
+      say r
+    end
+
+  end
+end
+
+#     # Build packages.
+#     # TODO Move this to Manager ?
+#
+#     def generate_packages
+#       package_files = formats.collect do |format|
+#         #format = clean_type(format)
+#         say '' if format == 'gem'  # FIXME This is here b/c Gems outputs on it's own.
+#         file = create_package(format)
+#         unless dryrun? or (format == 'gem')
+#           report_package_built(format, file) if file
+#         end
+#         file
+#       end
+#       report_packaging_complete(package_files.size)
+#     end
+#
+#     # Create package.
+#
+#     def create_package(type)
+#       package.format = type
+#
+#       builder_class = FormatBuilder.registry[type]
+#       builder = builder_class.new(package, stage_directory, options)
+#       file    = builder.build
+#
+#       transfer(file) unless dryrun?
+#
+#       return file
+#     end
+#
+#     # Report that packaging is complete.
+#
+#     def report_packaging_complete(size)
+#       say "\nSuccessfully built #{size} packages at #{store}/."
+#     end

data/work/sandbox/build/rdoc.rb

@@ -0,0 +1,289 @@
+require 'quarry/build'
+
+module Quarry
+
+  #
+
+  class RDoc < Build
+
+    DEFAULT_TEMPLATE = 'html'
+    DEFAULT_OUTPUT   = 'doc'
+    DEFAULT_INLINE   = true
+    DEFAULT_MERGE    = true
+    DEFAULT_EXCLUDE  = []
+    DEFAULT_INCLUDE  = ['lib', '[A-Z]*']
+    DEFAULT_ADFILE   = 'doc/rdoc_ad.html'
+
+    # common
+
+    attr_accessor :output
+
+    attr_accessor :include
+
+    attr_accessor :exclude
+
+    # rdoc specific.
+
+    attr_accessor :rdoc_output
+
+    attr_accessor :template
+
+    attr_accessor :adfile
+
+    attr_accessor :inline
+
+    attr_accessor :merge
+
+    # Defaults to {output}/rdoc.
+
+    def rdoc_output
+      @rdoc_output || File.join(output, 'rdoc')
+    end
+
+    # ri specific
+
+    attr_accessor :ri_output
+
+    # Defaults to {output}/ri.
+
+    def ri_output
+      @ri_output ||= File.join(output, 'ri')
+    end
+
+
+    # Generate rdocs.
+    #
+    # Generate Rdoc documentation. Settings are the
+    # same as the rdoc command's option, with two
+    # exceptions: +inline+ for +inline-source+ and
+    # +output+ for +op+.
+
+    def rdoc(options=nil)
+      options ||= {}
+      options.rekey!(&:to_s)
+
+      config  = configuration['rdoc']
+      options = RDOC_DEFAULTS.merge(config).merge(options)
+
+      cmdopts = {}
+      cmdopts['template']      = options['template'] || template || DEFAULT_TEMPLATE
+      cmdopts['op']            = options['output']   || output   || DEFAULT_OUTPUT
+      cmdopts['merge']         = options['merge']    || merge    || DEFAULT_MERGE
+      cmdopts['inline-source'] = options['inline']   || incline  || DEFAULT_INLINE
+      cmdopts['exclude']       = options['exclude']  || exlcude  || DEFAULT_EXCLUDE
+
+      output = cmdopts['op']
+
+      files  = options['include'] || include || DEFAULT_INCLUDE
+      adfile = options['adfile']  || adfile  || DEFAULT_ADFILE
+
+      input = files.collect do |i|
+        dir?(i) ? File.join(i,'**','*') : i
+      end
+
+      if out_of_date?(output, *input) or force?
+        rdoc_shell(files, config)
+        rdoc_insert_ads(output, adfile)
+      else
+        puts "Rdocs are current."
+      end
+    end
+
+    # Remove rdocs products.
+
+    def clobber_rdoc(options=nil)
+      options ||= {}
+      options.rekey!(&:to_s)
+
+      config  = configuration['rdoc']
+      options = DEFAULTS_RDOC.merge(config).merge(options)
+
+      dir = options['output']
+
+      rm_r(dir) if File.directory?(dir)
+    end
+
+    private
+
+    # Document target.
+
+    def rdoc_shell(files, config)
+      output = config['op']
+      rm_r(output) if exist?(output) and safe?(output)  # remove old rdocs
+      sh "rdoc #{[files, config].to_console}"
+    end
+
+    # Insert an ad if available.
+
+    def rdoc_insert_ads(site, adfile)
+      return unless adfile && File.file?(adfile)
+      adtext = File.read(adfile)
+      #puts
+      dirs = Dir.glob(File.join(site,'*/'))
+      dirs.each do |dir|
+        files = Dir.glob(File.join(dir, '**/*.html'))
+        files.each do |file|
+          html = file_read(file)
+          bodi = html.index('<body>')
+          html[bodi + 7] = "\n" + adtext
+          #print "Augmenting #{file}..."
+          file_write(file, html) unless dryrun?
+          #puts "[done]"
+        end
+      end
+    end
+
+    public
+
+
+    # generate local ri docs
+    #
+    # Generate RI documentation. This utilizes
+    # rdoc to produce the appropriate files.
+
+    def ri(options=nil)
+      options ||= {}
+      options.rekey!(&:to_s)
+
+      config  = configuration['ri']
+      options = DEFAULTS_RI.merge(config).merge(options)
+
+      cmdopts = {}
+      cmdopts['op']            = options['output']
+      cmdopts['exclude']       = options['exclude']
+
+      output = options['output']
+      files  = options['include'] # || ['lib', '[A-Z]*']
+
+      input = files.collect do |i|
+        dir?(i) ? File.join(i,'**','*') : i
+      end
+
+      if out_of_date?(output, *input) or force?
+        ri_shell(files, config)
+      else
+        puts "RI Docs are current."
+      end
+    end
+
+    # Remove ri products.
+
+    def clobber_ri(options=nil)
+      options ||= {}
+      options.rekey!(&:to_s)
+
+      config  = configuration['ri']
+      options = DEFAULTS_RI.merge(config).merge(options)
+
+      dir = options['output']
+
+      rm_r(dir) if File.directory?(dir)
+    end
+
+    private
+
+    # Shell out to rdoc to create ri docs.
+
+    def ri_shell(files, config)
+      output = config['op']
+      input  = config.delete('include')
+
+      # Check for 'doc' directory.
+      # (Helps to ensure we're in the right place.)
+      #dir!(File.dirname(site))
+
+      # Remove old rdocs.
+      rm_r(output) if exist?(output) and safe?(output)
+
+      #input = input.collect{ |i| glob(i) }.flatten
+      vector = ['--ri', input, config]
+      rdoc(vector.to_console)
+    end
+
+    # Defaults to output.
+
+    attr_accessor :html_output
+
+    def html_ouput
+      @html_output ||= output
+    end
+
+    # Stylesheet to use for html converted files.
+
+    attr_accessor :css
+
+    attr_accessor :metafiles
+
+    def metafiles
+      @files ||= Dir.glob('[A-Z]*')
+    end
+
+    def css
+      @css ||= Dir.glob('*.css').first
+    end
+
+    # Create web index.html from README.
+
+    def html(options=nil)
+      require 'rdoc/markup/simple_markup'
+      require 'rdoc/markup/simple_markup/to_html'
+
+      s = SM::SimpleMarkup.new
+      h = SM::ToHtml.new
+
+      metafiles.each do |file|
+        unless File.exist?(file)
+          puts "Warning: file does not exist -- #{file}"
+        end
+      end
+
+      mkdir_p(output) unless dryrun?
+
+      files.each do |file|
+        name = file.downcase.chomp('.txt')
+        if /^readme/ =~ name
+          name = "index"
+        end
+        path = File.join(dir, name + '.html')
+
+        if dryrun?
+          puts "[DRYRUN] Create #{path}"
+        else
+          next unless out_of_date?(path, file)
+
+          title = "#{package.title} #{name.upcase}"
+
+          input  = File.read(file)
+          output = s.convert(input, h)
+
+          File.open(path, 'w') do |f|
+            f << %{<html>}
+            f << %{<head>}
+            f << %{  <title>#{title}<title>}
+            f << %{  <link rel="stylesheet" TYPE="text/css" HREF="#{css}">} if css
+            f << %{</head>}
+            f << %{<body>}
+            f << output
+            f << %{</body>}
+            f << %{</html>}
+          end
+
+          puts "Created #{path}"
+        end
+      end
+    end
+
+    # Create off-line docs package.
+
+    def package(name, version)
+      #name = release.name
+      #ver  = release.version
+
+      Dir.chdir(output) do
+        zip "-czhvf #{name}-docs-#{version}.zip *"
+      end
+    end
+
+  end
+
+end

data/work/sandbox/build/rubyforge.rb

@@ -0,0 +1,91 @@
+require 'reap/tool'
+
+module Reap
+
+  class Rubyforge < Build
+
+    # Command attributes.
+
+    attr_accessor :project
+    attr_accessor :username
+
+    # For releasing.
+
+    attr_accessor :version
+
+    # Release packages to rubyforge (using icli).
+
+    def release
+      name, version = release.name, release.version
+      sh "icli rubyforge release --version=#{version}"
+    end
+
+    # For publishing.
+
+    attr_accessor :subdir
+    attr_accessor :source
+    attr_accessor :clear
+    attr_accessor :protect
+    attr_accessor :exclude
+
+    def source
+      @source ||= "doc"
+    end
+
+    def username
+      @username ||= ENV['RUBYFORGE_USERNAME']  # good idea here?
+    end
+
+    # Publish website to rubyforge.
+    #
+    # This task publishes the source dir (deafult 'doc')
+    # to a rubyforge website.
+    #
+    # Uses RSync to upload files to webserver.
+
+    def publish
+      if clear
+        protect   = protect().to_a
+        exclude   = exclude().to_a
+      else
+        protect   = %w{usage statcvs statsvn robot.txt wiki} + protect().to_a
+        exclude   = %w{.svn} + exclude().to_a
+      end
+
+      abort "no project"  unless project
+      abort "no username" unless username
+
+      if subdir
+        destination = File.join(project, subdir)
+      else
+        destination = project
+      end
+
+      dir = source.chomp('/') + '/'
+      url = "#{username}@rubyforge.org:/var/www/gforge-projects/#{destination}"
+
+      op = ['-rLvz', '--delete-after']  # maybe -p ?
+
+      # Using commandline filter options didn't seem
+      # to work, so I opted for creating an .rsync_filter file for
+      # all cases.
+
+      unless protect.empty? && exclude.empty?
+        rsync_file = File.join(source,'.rsync-filter')
+        unless file?(rsync_file)
+          File.open(rsync_file, 'w') do |f|
+            exclude.each{|e| f << "- #{e}\n"}
+            protect.each{|e| f << "P #{e}\n"}
+          end
+        end
+        op << "--filter='dir-merge #{rsync_file}'"
+      end
+
+      args = op + [dir, url]
+
+      rsync(*args.to_params)
+    end
+
+  end
+
+end