quarry 0.3.0 → 0.4.0

data/work/sandbox/assert.rb

@@ -0,0 +1,100 @@
+class Object
+  # Asserts a operational relationship.
+  #
+  # 4.assert == 3  #=> Assertion Error
+  #
+  def assert
+    return Assert.new(self, true)
+  end
+
+  # Refutes an operational relationship.
+  #
+  # 4.assert! == 4  #=> Assertion Error
+  #
+  def assert!
+    return Assert.new(self, false)
+  end
+end
+
+# = Assertion
+#
+# Assertion is a special subclass of Exception.
+# An Assertion error is raised when an assertion fails.
+#
+class Assertion < Exception
+end
+
+# = Assert
+#
+# The Assert class is an Assertion functor. It delegates
+# to the underlying object to test if assertions applied
+# to it are successful or not. When they fail it raises
+# and Assertion error.
+#
+class Assert
+
+  hide = instance_methods.reject { |m| m.to_s =~ /^__/ }
+  hide.each { |m| protected m  }
+
+  private
+
+  #
+  def initialize(delegate, predicate)
+    @delegate  = delegate
+    @predicate = predicate
+  end
+
+  #
+  def method_missing(sym, *a, &b)
+    case sym
+    when :raise?, :raises?
+      begin
+        @delegate.call #yield
+        assert false, "Expected #{a[0]} to be raised"
+      rescue Exception => e
+        assert a[0] === e, "Expected #{a[0]} to be raised, but got #{e.class}"
+        return e
+      end
+    else
+      assert(@delegate.__send__(sym, *a, &b), message(@delegate, sym, *a, &b))
+    end
+  end
+
+  #
+  def assert(assertion, msg="failed assertion (no message given)")
+    if @predicate
+      raise Assertion, msg unless assertion
+    else
+      raise Assertion, msg if assertion
+    end
+  end
+
+  #
+  def message(obj, sym, *a, &b)
+    #self.class.message(sym)[@delegate, *a] )
+    if @predicate
+      "#{obj.inspect} #{sym} #{a.collect{|x| x.inspect}.join(',')}"
+    else
+      "NOT #{obj.inspect} #{sym} #{a.collect{|x| x.inspect}.join(',')}"
+    end
+  end
+
+  # TODO: Ultimately better messages would be nice.
+
+  #
+  #def self.message(msg,&block)
+  #  @messages ||= {}
+  #  if block
+  #    @messages[msg] = block
+  #  else
+  #    @messages[msg]
+  #  end
+  #end
+
+  #
+  #message(:==){ |*a| "Expected #{a[0].inspect} to be equal to #{a[1].inspect}" }
+
+end
+
+# Copyright (c) 2008 Tiger Ops
+

data/work/sandbox/bug.rb

@@ -0,0 +1,49 @@
+# Raise a bug.
+
+module Quarry
+  class Bug < Exception; end
+end
+
+module Kernel
+
+  # Raises a ScritBug error with a message.
+  #
+  #   if find_bug then
+  #     bug! "unknown bug found"
+  #   end
+  #
+  #--
+  # Credit goes to Minero Aoki. Cute! :-)
+  #++
+  def bug!(message='Report this bug!')
+    raise Quarry::Bug, "\n[BUG] " + message
+  end
+
+end
+
+
+#  _____         _
+# |_   _|__  ___| |_
+#   | |/ _ \/ __| __|
+#   | |  __/\__ \ |_
+#   |_|\___||___/\__|
+#
+=begin test
+
+  require 'test/unit'
+
+  class TestKernelError < Test::Unit::TestCase
+
+    def test_bug!
+      assert_raises( Bug ) { bug! }
+    end
+
+#     def test_demo
+#       demo(i=''){%{ a = [1,2,3] }}
+#       o = " a = [1,2,3]             #=>  [1, 2, 3]\n"
+#       assert_equal( o, i )
+#     end
+
+  end
+
+=end

data/work/sandbox/build/announce.rb

@@ -0,0 +1,213 @@
+require 'quarry/build'
+
+module Reap
+
+  # Make a release announcement. Generates and can email a release
+  # announcements. These are nicely formated message and can
+  # email the message to the specified address(es).
+  #
+  # The following settings apply:
+  #
+  #     title        Project title.
+  #     subtitle     Brief one-line description.
+  #     version      Project version.
+  #     description  Long description of project.
+  #     homepage     Project homepage web address.
+  #     slogan       Motto for you project.
+  #     memo         File that contains announcement message.
+  #     template     Custom announcement template file.
+  #     mail_to      Email address(es) to send announcemnt.
+  #
+  # If <em>mail_to</em> is set then these also apply:
+  #
+  #     from         Message FROM address [email].
+  #     subject      Subject of email message ([ANN] title verison).
+  #     server       Email server to route message.
+  #     port         Email server's port.
+  #     domain       Email server's domain name.
+  #     account      Email account name [email].
+  #     login        Login type: plain, cram_md5 or login.
+  #     secure       Uses TLS security, true or false?
+  #
+  # A template file can be specified that uses "$setting" as
+  # substitutes for poject information.
+
+  class Announcement < Build
+
+    # Default layout of release announcement.
+
+    DEFAULT_TEMPLATE = <<-END
+      $title $version
+      $subtitle
+      $homepage
+
+      $summary $description
+
+      $memo
+
+      $slogan
+    END
+
+    # Name of project (ie. unix name).
+    attr_accessor :project
+
+    # Title of project.
+    attr_accessor :title
+
+    # Subtitle of project.
+    attr_accessor :subtitle
+
+    # Version number of project release.
+    attr_accessor :version
+
+    # Description of project.
+    attr_accessor :description
+
+    # Project's homepage.
+    attr_accessor :homepage
+
+    # URL to download.
+    attr_accessor :download
+
+    # Project slogan.
+    attr_accessor :slogan
+
+    # To email address(es). If this is not set then
+    # the announcement is not emailed and instead
+    # is only sent to stdout.
+    attr_accessor :mail_to
+
+    # From email address.
+    attr_accessor :mail_from
+
+    # Memo (personalized message for this release)
+    attr_accessor :memo
+
+    # User defined announcement template.
+    attr_accessor :template
+
+    # Subject line (default is "ANN: project version").
+    attr_accessor :subject
+
+    # Email server
+    attr_accessor :server
+
+    # Emails server port (default is usually correct).
+    attr_accessor :port
+
+    # Email account name (defaults to mail_from).
+    attr_accessor :account
+
+    # User domain (not sure why SMTP requires this?)
+    attr_accessor :domain
+
+    # Login type (plain, login)
+    attr_accessor :login_type
+
+    # Use TLS/SSL true or false?
+    attr_accessor :secure
+
+    # Password (deafults to ENV['PASSWORD']
+    attr_accessor :password
+
+    #
+
+    def subject
+      @subject ||= "ANN: #{title}, v#{version}"
+    end
+
+    #
+
+    def account
+      @account ||= @mail_from
+    end
+
+      #config['mail_to'] = nil if keys['mail_to'].empty?
+
+    # Validate settings.
+
+    def validate
+      raise ArgumentError, "missing title" unless title
+      raise ArgumentError, "missing version" unless version
+    end
+
+    # Announcement message.
+
+    def message
+      # Announce template
+      unless template
+        files = Dir.glob("{ANN,doc/[aA]nn,doc/ANN}{,.txt}")
+        template = files.first
+      end
+      template = File.read(template) if template
+      template = template || DEFAULT_TEMPLATE
+
+      # Announce Memo
+      unless memo
+        files = Dir.glob("{MEMO,doc/[mM]emo,doc/MEMO}{,.txt}")
+        memo = files.first
+      end
+      memo = File.read(memo).fold(true) if memo
+
+      # Strip tiny version zero.
+      #if keys['version'] =~ /[.].*?[.]/
+      #  keys['version'] = keys['version'].chomp('.0')
+      #end
+
+      # Make announcement message
+      message = template.dup
+
+      message.gsub!('$memo',memo) if memo        # insert memo
+      #message.gsub!('$stamp',stamp.to_s)        # insert stamp
+
+      template.scan(/[$].*?\s/m) do |key|
+        key   = key.strip
+        name  = key[1..-1]
+        value = info.send(name)
+        message.gsub!(key, value.to_s.strip)
+      end
+
+      message.gsub!(/(^|[ ])[$].*?(?=[ ]|$)/,'') # remove unused vars
+      message.gsub!("\n\n\n","\n")               # remove any triple blank lines
+      message.rstrip!
+
+      #message = release_announcement(config)
+
+      message
+    end
+
+    #
+
+    def email_message
+      email(message, email_options)
+    end
+
+    #
+
+    def email_options
+      { :to      => mail_to,
+        :from    => mail_from,
+        :subject => subject,
+        :server  => server,
+        :port    => port,
+        :domain  => domain,
+        :account => account,
+        :login   => login,
+        :secure  => secure
+      }
+    end
+
+  end
+
+end
+
+  #       keys = {}
+  #       keys['from'] = info.email
+  #       keys.update info.gather('mail')
+  #       keys.update info.gather('announce')
+  #       keys.update info.select(
+  #         :project, :version, :title, :subtitle, :description,
+  #         :homepage, :download, :slogan
+  #       )
+  #       keys.update override if override
+

data/work/sandbox/build/check.rb

@@ -0,0 +1,109 @@
+require 'quarry/build'
+
+module Quarry
+
+  #
+
+  class Check < Build
+
+    DEFAULT_LOADPATH = ['lib']
+
+    # List of file path(s) of project scripts to check.
+
+    attr_accessor :loadpath
+    attr_accessor :exclude
+
+    alias_method :include, :loadpath
+    alias_method :include=, :loadpath=
+
+    # Veridy syntax of ruby scripts.
+    #
+    # This takes one option +:scripts+ which is a glob or list of globs
+    # of the scripts to check. By default this is all scripts in the libpath(s).
+
+    def syntax(options=nil)
+      options ||= {}
+
+      glob = options[:include] || options[:loadpath] || loadpath || DEFAULT_LOADPATH
+      excl = options[:exclude] || exclude  || []
+
+      if String===glob
+        glob = glob.split(/[:;]/)
+      end
+
+      files = multiglob_r(*glob) - multiglob_r(*excl)
+      max   = files.collect{ |f| f.size }.max
+      errs  = []
+      cnt   = 0
+
+      files.each do |s|
+        next unless File.file?(s)
+        #if not system "ruby -c -Ibin:lib:test #{s} &> /dev/null" then
+        r = system "ruby -c -I#{libpath} #{s} > /dev/null"
+        if r
+          puts("%-#{max}s  [PASS]" % [s]) #if verbose?
+        else
+          puts("%-#{max}s  [FAIL]" % [s]) #if verbose?
+          errs << s #:syntax
+          cnt += 1
+        end
+      end
+
+      if cnt == 0
+        puts "Syntax checks out."
+      else
+        puts "#{cnt} Syntax Failures:\n  "
+        puts errs.join("\n  ")
+      end
+    end
+
+    # Load each script independently to ensure there are no
+    # require dependency issues.
+    #
+    # WARNING! Only do this on scripts that have no toplevel side-effects!
+    #
+    # This takes one option +:scripts+ which is a glob or list of globs
+    # of the scripts to check. By default this is all scripts in the libpath(s).
+    #
+    # FIXME: This isn;t routing output to dev/null as expected.
+
+    def dependencies(options=nil)
+      options ||= {}
+
+      options ||= {}
+
+      glob = options[:include] || options[:loadpath] || loadpath || DEFAULT_LOADPATH
+      excl = options[:exclude] || exclude  || []
+
+      if String===glob
+        glob = glob.split(/[:;]/)
+      end
+
+      files = multiglob_r(*glob) - multiglob_r(*excl)
+      max   = files.collect{ |f| f.size }.max
+      errs  = []
+      cnt   = 0
+
+      files.each do |s|
+        next unless File.file?(s)
+        #if not system "ruby -c -Ibin:lib:test #{s} &> /dev/null" then
+        if r = system("ruby -I#{libpath} #{s} > /dev/null")
+          puts "%-#{max}s  [PASS]" % [s]  #if verbose?
+        else
+          puts "%-#{max}s  [FAIL]" % [s]  #if verbose?
+          errs << s #:load
+          cnt += 1
+        end
+      end
+
+      if cnt == 0
+        puts "Load dependencies check out."
+      else
+        puts "#{cnt} Load Failures:\n  "
+        puts errs.join("\n  ")
+      end
+    end
+
+  end
+
+end

data/work/sandbox/build/gem.rb

@@ -0,0 +1,235 @@
+require 'quarry/build'
+
+begin
+  require 'rubygems/specification'
+  Gem::manage_gems
+rescue LoadError
+  #raise LoadError, "RubyGems is not installed?"
+end
+
+module Qaurry
+
+  class Gem < 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