realityforge-buildr 1.5.9

data/lib/buildr/core/console.rb

@@ -0,0 +1,124 @@
+# Licensed to the Apache Software Foundation (ASF) under one or more
+# contributor license agreements.  See the NOTICE file distributed with this
+# work for additional information regarding copyright ownership.  The ASF
+# licenses this file to you under the Apache License, Version 2.0 (the
+# "License"); you may not use this file except in compliance with the License.
+# You may obtain a copy of the License at
+#
+#    http://www.apache.org/licenses/LICENSE-2.0
+#
+# Unless required by applicable law or agreed to in writing, software
+# distributed under the License is distributed on an "AS IS" BASIS, WITHOUT
+# WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.  See the
+# License for the specific language governing permissions and limitations under
+# the License.
+
+module Buildr #nodoc
+
+  # A utility class that helps with colorizing output for interactive shells where appropriate
+  class Console
+    class << self
+      def use_color
+        @use_color.nil? ? false : @use_color
+      end
+
+      def use_color=(use_color)
+        @use_color = use_color
+      end
+
+      # Emit message with color at the start of the message and the clear color command at the end of the sequence.
+      def color(message, color)
+        raise "Unknown color #{color.inspect}" unless [:green, :red, :blue].include?(color)
+        return message unless use_color
+        constants = {:green => "\e[32m", :red => "\e[31m", :blue => "\e[34m"}
+        @java_console.putString("#{constants[color]}#{message}\e[0m") if @java_console
+        "#{constants[color]}#{message}\e[0m"
+      end
+
+      # Return the [rows, columns] of a console or nil if unknown
+      def console_dimensions
+        begin
+          if $stdout.isatty
+            if /solaris/ =~ RUBY_PLATFORM and
+              `stty` =~ /\brows = (\d+).*\bcolumns = (\d+)/
+              [$2, $1].map { |c| x.to_i }
+            else
+              `stty size 2> /dev/null`.split.map { |x| x.to_i }.reverse
+            end
+          else
+            nil
+          end
+        rescue => e
+          nil
+        end
+      end
+
+      # Return the number of columns in console or nil if unknown
+      def output_cols
+        d = console_dimensions
+        d ? d[0] : nil
+      end
+
+      def agree?(message)
+        puts "#{message} (Y or N)"
+        :agree == ask('Y' => :agree, 'N' => :disagree)
+      end
+
+      def ask_password(prompt)
+        puts prompt
+        begin
+          set_no_echo_mode
+          password = $stdin.readline
+          return password.chomp
+        ensure
+          reset_mode
+        end
+      end
+
+      def present_menu(header, options)
+        puts header
+        question_options = {}
+        count = 1
+        options.each_pair do |message, result|
+          puts "#{count}. #{message}"
+          question_options[count.to_s] = result
+          count += 1
+        end
+        ask(question_options)
+      end
+
+      private
+
+      def set_no_echo_mode
+        @state = `stty -g 2>/dev/null`
+        `stty -echo -icanon 2>/dev/null`
+      end
+
+      def reset_mode
+        `stty #{@state} 2>/dev/null`
+        @state = nil
+      end
+
+      def ask(options)
+        keys = options.keys
+        keys_downcased = keys.collect { |k| k.downcase }
+        result = nil
+        show_prompt = false
+        until keys_downcased.include?(result)
+          puts "Invalid response. Valid responses include: #{keys.join(', ')}\n" if show_prompt
+          show_prompt = true
+          result = $stdin.readline
+          result = result.strip.downcase if result
+        end
+        options.each_pair do |key, value|
+          if key.downcase == result
+            return value.is_a?(Proc) ? value.call : value
+          end
+        end
+        return nil
+      end
+    end
+  end
+end
+
+Buildr::Console.use_color = $stdout.isatty

data/lib/buildr/core/doc.rb

@@ -0,0 +1,275 @@
+# Licensed to the Apache Software Foundation (ASF) under one or more
+# contributor license agreements.  See the NOTICE file distributed with this
+# work for additional information regarding copyright ownership.  The ASF
+# licenses this file to you under the Apache License, Version 2.0 (the
+# "License"); you may not use this file except in compliance with the License.
+# You may obtain a copy of the License at
+#
+#    http://www.apache.org/licenses/LICENSE-2.0
+#
+# Unless required by applicable law or agreed to in writing, software
+# distributed under the License is distributed on an "AS IS" BASIS, WITHOUT
+# WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.  See the
+# License for the specific language governing permissions and limitations under
+# the License.
+
+module Buildr #:nodoc:
+  module Doc
+    include Extension
+
+    class << self
+      def select_by_lang(lang)
+        fail 'Unable to define doc task for nil language' if lang.nil?
+        engines.detect { |e| e.language.to_sym == lang.to_sym }
+      end
+
+      alias_method :select, :select_by_lang
+
+      def select_by_name(name)
+        fail 'Unable to define doc task for nil' if name.nil?
+        engines.detect { |e| e.to_sym == name.to_sym }
+      end
+
+      def engines
+        @engines ||= []
+      end
+    end
+
+
+    # Base class for any documentation provider.  Defines most
+    # common functionality (things like @into@, @from@ and friends).
+    class Base
+      class << self
+        attr_accessor :language, :source_ext
+
+        def specify(options)
+          @language = options[:language]
+          @source_ext = options[:source_ext]
+        end
+
+        def to_sym
+          @symbol ||= name.split('::').last.downcase.to_sym
+        end
+      end
+
+      attr_reader :project
+
+      def initialize(project)
+        @project = project
+      end
+    end
+
+
+    class DocTask < Rake::Task
+
+      # The target directory for the generated documentation files.
+      attr_reader :target
+
+      # Classpath dependencies.
+      attr_accessor :classpath
+
+      # Additional sourcepaths that are not part of the documented files.
+      attr_accessor :sourcepath
+
+      # Returns the documentation tool options.
+      attr_reader :options
+
+      attr_reader :project # :nodoc:
+
+      def initialize(*args) #:nodoc:
+        super
+        @options = {}
+        @classpath = []
+        @sourcepath = []
+        @files = FileList[]
+        enhance do |task|
+          rm_rf target.to_s
+          mkdir_p target.to_s
+
+          engine.generate(source_files, File.expand_path(target.to_s),
+            options.merge(:classpath => classpath, :sourcepath => sourcepath))
+
+          touch target.to_s
+        end
+      end
+
+      # :call-seq:
+      #   into(path) => self
+      #
+      # Sets the target directory and returns self. This will also set the Javadoc task
+      # as a prerequisite to a file task on the target directory.
+      #
+      # For example:
+      #   package :zip, :classifier=>'docs', :include=>doc.target
+      def into(path)
+        @target = file(path.to_s).enhance([self]) unless @target && @target.to_s == path.to_s
+        self
+      end
+
+      # :call-seq:
+      #   include(*files) => self
+      #
+      # Includes additional source files and directories when generating the documentation
+      # and returns self. When specifying a directory, includes all source files in that directory.
+      def include(*files)
+        files.each do |file|
+          if file.respond_to? :to_ary
+            include(*file.to_ary)
+          else
+            @files.include *files.flatten.compact.collect { |f| File.expand_path(f.to_s) }
+          end
+        end
+        self
+      end
+
+      # :call-seq:
+      #   exclude(*files) => self
+      #
+      # Excludes source files and directories from generating the documentation.
+      def exclude(*files)
+        @files.exclude *files.collect{|f|File.expand_path(f)}
+        self
+      end
+
+      # :call-seq:
+      #   with(*artifacts) => self
+      #
+      # Adds files and artifacts as classpath dependencies, and returns self.
+      def with(*specs)
+        @classpath |= Buildr.artifacts(specs.flatten).uniq
+        self
+      end
+
+      # :call-seq:
+      #   using(options) => self
+      #
+      # Sets the documentation tool options from a hash and returns self.
+      #
+      # For example:
+      #   doc.using :windowtitle=>'My application'
+      def using(*args)
+        args.pop.each { |key, value| @options[key.to_sym] = value } if Hash === args.last
+
+        until args.empty?
+          new_engine = Doc.select_by_name(args.pop)
+          @engine = new_engine.new(project) unless new_engine.nil?
+        end
+
+        self
+      end
+
+      def engine
+        @engine ||= guess_engine
+      end
+
+      # :call-seq:
+      #   engine?(clazz) => boolean
+      #
+      # Check if the underlying engine is an instance of the given class
+      def engine?(clazz)
+        begin
+          @engine ||= guess_engine if project.compile.language
+        rescue
+          return false
+        end
+        @engine.is_a?(clazz) if @engine
+      end
+
+      # :call-seq:
+      #   from(*sources) => self
+      #
+      # Includes files, directories and projects in the documentation and returns self.
+      #
+      # You can call this method with source files and directories containing source files
+      # to include these files in the documentation, similar to #include. You can also call
+      # this method with projects. When called with a project, it includes all the source files compiled
+      # by that project and classpath dependencies used when compiling.
+      #
+      # For example:
+      #   doc.from projects('myapp:foo', 'myapp:bar')
+      def from(*sources)
+        sources.flatten.each do |source|
+          case source
+          when Project
+            self.enhance source.prerequisites
+            self.include source.compile.sources
+            self.with source.compile.dependencies
+          when Rake::Task, String
+            self.include source
+          else
+            fail "Don't know how to generate documentation from #{source || 'nil'}"
+          end
+        end
+        self
+      end
+
+      def prerequisites #:nodoc:
+        super + @files + classpath + sourcepath
+      end
+
+      def source_files #:nodoc:
+        @source_files ||= @files.map(&:to_s).map do |file|
+          Array(engine.class.source_ext).map do |ext|
+            File.directory?(file) ? FileList[File.join(file, "**/*.#{ext}")] : File.expand_path(file)
+          end
+        end.flatten.reject { |file| @files.exclude?(file) }
+      end
+
+      def needed? #:nodoc:
+        return false if source_files.empty?
+        return true unless File.exist?(target.to_s)
+        source_files.map { |src| File.stat(src.to_s).mtime }.max > File.stat(target.to_s).mtime
+      end
+
+    private
+
+      def guess_engine
+        doc_engine = Doc.select project.compile.language
+        fail 'Unable to guess documentation provider for project.' unless doc_engine
+        doc_engine.new project
+      end
+
+      def associate_with(project)
+        @project ||= project
+      end
+    end
+
+
+    first_time do
+      desc 'Create the documentation for this project'
+      Project.local_task :doc
+    end
+
+    before_define(:doc) do |project|
+      DocTask.define_task('doc').tap do |doc|
+        doc.send(:associate_with, project)
+        doc.into project.path_to(:target, :doc)
+      end
+    end
+
+    after_define(:doc) do |project|
+      project.doc.from project
+    end
+
+    # :call-seq:
+    #   doc(*sources) => JavadocTask
+    #
+    # This method returns the project's documentation task. It also accepts a list of source files,
+    # directories and projects to include when generating the docs.
+    #
+    # By default the doc task uses all the source directories from compile.sources and generates
+    # documentation in the target/doc directory. This method accepts sources and adds them by calling
+    # Buildr::Doc::Base#from.
+    #
+    # For example, if you want to generate documentation for a given project that includes all source files
+    # in two of its sub-projects:
+    #   doc projects('myapp:foo', 'myapp:bar').using(:windowtitle=>'Docs for foo and bar')
+    def doc(*sources, &block)
+      task('doc').from(*sources).enhance &block
+    end
+  end
+
+  class Project #:nodoc:
+    include Doc
+  end
+end

data/lib/buildr/core/environment.rb

@@ -0,0 +1,128 @@
+# Licensed to the Apache Software Foundation (ASF) under one or more
+# contributor license agreements.  See the NOTICE file distributed with this
+# work for additional information regarding copyright ownership.  The ASF
+# licenses this file to you under the Apache License, Version 2.0 (the
+# "License"); you may not use this file except in compliance with the License.
+# You may obtain a copy of the License at
+#
+#    http://www.apache.org/licenses/LICENSE-2.0
+#
+# Unless required by applicable law or agreed to in writing, software
+# distributed under the License is distributed on an "AS IS" BASIS, WITHOUT
+# WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.  See the
+# License for the specific language governing permissions and limitations under
+# the License.
+
+module Buildr #:nodoc:
+
+  # Collection of options for controlling Buildr.
+  class Options
+
+    # We use this to present environment variable as arrays.
+    class EnvArray < Array #:nodoc:
+
+      def initialize(name)
+        @name = name.upcase
+        replace((ENV[@name] || ENV[@name.downcase] || '').split(/\s*,\s*/).reject(&:empty?))
+      end
+
+      (Array.instance_methods - Object.instance_methods - Enumerable.instance_methods - ['each']).sort.each do |method|
+        class_eval %{def #{method}(*args, &block) ; result = super ; write_envarray ; result ; end}
+      end
+
+    private
+
+      def write_envarray
+        ENV[@name.downcase] = nil
+        ENV[@name] = map(&:to_s).join(',')
+      end
+
+    end
+
+
+    # Wraps around the proxy environment variables:
+    # * :http -- HTTP_PROXY
+    # * :https -- HTTPS_PROXY
+    # * :exclude -- NO_PROXY
+    class Proxies
+
+      # Returns the HTTP_PROXY URL.
+      def http
+        ENV['HTTP_PROXY'] || ENV['http_proxy']
+      end
+
+      # Sets the HTTP_PROXY URL.
+      def http=(url)
+        ENV['http_proxy'] = nil
+        ENV['HTTP_PROXY'] = url
+      end
+
+      # Returns the HTTPS_PROXY URL.
+      def https
+        ENV['HTTPS_PROXY'] || ENV['https_proxy']
+      end
+
+      # Sets the HTTPS_PROXY URL.
+      def https=(url)
+        ENV['https_proxy'] = nil
+        ENV['HTTPS_PROXY'] = url
+      end
+
+      # Returns list of hosts to exclude from proxying (NO_PROXY).
+      def exclude
+        @exclude ||= EnvArray.new('NO_PROXY')
+      end
+
+      # Sets list of hosts to exclude from proxy (NO_PROXY). Accepts host name, array of names,
+      # or nil to clear the list.
+      def exclude=(url)
+        exclude.clear
+        exclude.concat [url].flatten if url
+        exclude
+      end
+
+    end
+
+    # :call-seq:
+    #   proxy => options
+    #
+    # Returns the proxy options. Currently supported options are:
+    # * :http -- HTTP proxy for use when downloading.
+    # * :exclude -- Do not use proxy for these hosts/domains.
+    #
+    # For example:
+    #   options.proxy.http = 'http://proxy.acme.com:8080'
+    # You can also set it using the environment variable HTTP_PROXY.
+    #
+    # You can exclude individual hosts from being proxied, or entire domains, for example:
+    #   options.proxy.exclude = 'optimus'
+    #   options.proxy.exclude = ['optimus', 'prime']
+    #   options.proxy.exclude << '*.internal'
+    def proxy
+      @proxy ||= Proxies.new
+    end
+
+  end
+
+
+  class << self
+
+    # :call-seq:
+    #   options => Options
+    #
+    # Returns the Buildr options. See Options.
+    def options
+      @options ||= Options.new
+    end
+
+  end
+
+  # :call-seq:
+  #   options => Options
+  #
+  # Returns the Buildr options. See Options.
+  def options
+    Buildr.options
+  end
+
+end