rc 0.1.1

data/lib/rc/configuration.rb

@@ -0,0 +1,192 @@
+module RC
+
+  # Configuration
+  #
+  class Configuration < Module
+
+    #
+    # Configuration file pattern. The standard configuration file name is
+    # `Config.rb`, and that name should be used in most cases. However, 
+    # `.config.rb` can also be use and will take precedence if found.
+    # Conversely, `config.rb` (lowercase form) can also be used but has
+    # the least precedence.
+    #
+    # Config files looked for in the order or precedence:
+    #
+    #   * `.config.rb`
+    #   * `Config.rb`
+    #   * `config.rb`
+    #
+    CONFIG_FILE = '{.c,C,c}onfig{.rb,}'
+
+    #
+    # When looking up config file, it one of these is found
+    # then there is no point to looking further.
+    #
+    ROOT_INDICATORS = %w{.git .hg _darcs} #.ruby
+
+    #
+    # Load configuration file from local project or other gem.
+    #
+    # @param options [Hash] Load options.
+    #
+    # @option options [String] :from
+    #   Name of gem or library.
+    #
+    def self.load(options={})
+      if from = options[:from]
+        file = Find.path(CONFIG_FILE, :from=>from).first
+      else
+        file = lookup(CONFIG_FILE)
+      end
+      new(file)
+    end
+
+    #
+    # Initialize new Configuration object.
+    #
+    # @param [String] file
+    #   Configuration file (optional).
+    #
+    def initialize(file=nil)
+      @file = file
+
+      @_list  = []
+      @_state = {}
+
+      # TODO: does this rescue make sense here?
+      begin
+        import_relative(@file) if @file
+      rescue => e
+        raise e if $DEBUG
+        warn e.message
+      end
+    end
+
+    #
+    # Profile block.
+    #
+    # @param [String,Symbol] name
+    #   A profile name.
+    #
+    def profile(name, &block)
+      raise SyntaxError, "nested profile sections" if @_state[:profile]
+      original_state = @_state.dup
+      @_state[:profile] = name.to_s
+      instance_eval(&block)
+      @_state = original_state
+    end
+
+    #
+    # Configure a tool.
+    #
+    # @param [Symbol] tool
+    #   The name of the tool to configure.
+    #
+    # @param [Hash] opts
+    #   Configuration options.
+    #
+    # @options opts [String] :from
+    #   Library from which to extract configuration.
+    #
+    # @example
+    #   profile :coverage do
+    #     config :qed, :from=>'qed'
+    #   end
+    #
+    # @todo Clean this code up.
+    #
+    def config(tool, *args, &block)
+      options = (Hash===args.last ? args.pop : {})
+
+      # @todo Might we have an option to lockdown tool 
+      #       So that we do without ToolConfiguration?
+
+      case args.first
+      when Symbol
+        profile = args.shift
+      when String
+        profile = args.shift unless args.first.index("\n")
+      end
+
+      data = args.shift
+      raise ArgumentError, "must use data or block, not both" if data && block
+      if data
+        data = data.tabto(0)
+        block = Proc.new do
+          YAML.load(data)
+        end
+      end
+
+      from = options[:from]
+
+      raise ArgumentError, "too many arguments"      if args.first
+      raise SyntaxError,   "nested profile sections" if profile && @_state[:profile]
+      #raise ArgumentError, "use block or :from  setting" if options[:from]  && block
+
+      profile = @_state[:profile] unless profile
+
+      if from
+        from_config  = RC.configuration(from)
+        from_tool    = options[:tool]    || tool
+        from_profile = options[:profile] || profile
+        from_config.each do |c|
+          if c.match?(from_tool, from_profile)
+            @_list << Config.new(tool, profile, &c)
+          end
+        end
+
+        return unless block
+      end
+
+      @_list << Config.new(tool, profile, &block)
+    end
+
+    #
+    # @return [Hash] Defined configurations.
+    #
+    def configurations
+      @_list
+    end
+
+    #
+    # @return [ToolConfiguration] Subset of Configuration.
+    #
+    def [](tool)
+      ToolConfiguration.new(tool, self)
+    end
+
+    # Configuration is Enumerable.
+    include Enumerable
+
+    # 
+    def each(&block)
+      @_list.each(&block)
+    end
+
+    #
+    def size
+      @_list.size
+    end
+
+  private
+
+    #
+    # Search upward from working directory.
+    #
+    def self.lookup(glob, flags=0)
+      pwd  = File.expand_path(Dir.pwd)
+      home = File.expand_path('~')
+      while pwd != '/' && pwd != home
+        if file = Dir.glob(File.join(pwd, glob), flags).first
+          return file
+        end
+        break if ROOT_INDICATORS.any?{ |r| File.exist?(File.join(pwd, r)) }
+        pwd = File.dirname(pwd)
+      end
+      return nil   
+    end
+
+  end
+
+end

data/lib/rc/core_ext.rb

@@ -0,0 +1,49 @@
+module Kernel
+  #
+  # Evaluate script directly into current scope.
+  #
+  def import(feature)
+    file = Find.load_path(feature).first
+    raise LoadError, "no such file -- #{feature}" unless file
+    instance_eval(::File.read(file), file) if file
+  end
+
+  #
+  # Evaluate script directly into current scope.
+  #
+  def import_relative(file)
+    raise LoadError, "no such file -- #{file}" unless File.file?(file)
+    instance_eval(::File.read(file), file) if file
+  end
+end
+
+class Hash
+  def to_h
+    dup #rehash
+  end unless method_defined?(:to_h)
+end
+
+class String
+  def tabto(n)
+    if self =~ /^( *)\S/
+      indent(n - $1.length)
+    else
+      self
+    end
+  end unless method_defined?(:tabto)
+
+  def indent(n, c=' ')
+    if n >= 0
+      gsub(/^/, c * n)
+    else
+      gsub(/^#{Regexp.escape(c)}{0,#{-n}}/, "")
+    end
+  end unless method_defined?(:indent)
+end
+
+#class Symbol
+#  def /(other)
+#    "#{self}/#{other}".to_sym
+#  end
+#end
+

data/lib/rc/interface.rb

@@ -0,0 +1,163 @@
+module RC
+  # External requirements.
+  require 'yaml'
+  require 'finder'
+
+  # Internal requirements.
+  require 'rc/core_ext'
+  require 'rc/config'
+  require 'rc/configuration'
+  require 'rc/tool_configuration'
+  require 'rc/properties'
+
+  #
+  # Configuration file pattern. The standard configuration file name is
+  # `Config.rb`, and that name should be used in most cases. However, 
+  # `.config.rb` can also be use and will take precedence if found.
+  # Conversely, `config.rb` (lowercase form) can also be used but has
+  # the least precedence.
+  #
+  # Config files looked for in the order or precedence:
+  #
+  #   * `.config.rb`
+  #   * `Config.rb`
+  #   * `config.rb`
+  #
+  FILE_PATTERN = '{.c,C,c}onfig{.rb,}'
+
+  #
+  def self.cache
+    @cache ||= {}
+  end
+
+  #
+  def self.clear!
+    @cache = {}
+  end
+
+  #
+  def self.configuration(gem=nil)
+    key = gem ? gem.to_s : nil #Dir.pwd
+    cache[key] ||= Configuration.load(:from=>gem)
+  end
+
+  #
+  # @return [Array] List of profiles for given `tool`.
+  #
+  def self.profiles(tool, options={})
+    tool = tool.to_s
+    gem  = options[:from]
+    configuration(gem).map{ |c| c.tool.to_s }
+  end
+
+  #
+  # Get current tool.
+  #
+  def self.current_tool
+    File.basename(ENV['tool'] || $0)
+  end
+
+  #
+  # Set current tool.
+  #
+  def self.current_tool=(tool)
+    ENV['tool'] = tool.to_s
+  end
+
+  #
+  # Get current profile.
+  #
+  def self.current_profile
+    ENV['profile']
+  end
+
+  #
+  # Set current profile.
+  #
+  def self.current_profile=(profile)
+    if profile
+      ENV['profile'] = profile.to_s
+    else
+      ENV['profile'] = nil
+    end
+  end
+
+  #
+  # Project properties.
+  #
+  def self.properties
+    $properties ||= Properties.new
+  end
+
+  #
+  # Get/set configuration processor. Tools can use this
+  # to gain control over the configuration procedure.
+  #
+  # The block should take a single argument of the current
+  # Configuration.
+  #
+  # This might be used to save the configuration for
+  # a later execution, or to evaluate the procedures
+  # in a special scope, or both.
+  #
+  # Keep in mind that if configurations are evaluated in
+  # a different scope, they may not be able to utilize
+  # any shared methods defined in the config file.
+  #
+  # @example
+  #   RC.processor('qed') do |config|
+  #     if i = ARGV.index('--profile') || ARGV.index('-p')
+  #       ENV['profile'] = ARGV[i+1]
+  #     end
+  #     RC.configure
+  #   end
+  #
+  def self.processor(tool, &block)
+    @processors ||= {}
+    @processors[tool.to_s] = block if block
+    @processors[tool.to_s]
+  end
+
+  #
+  # Setup configuration.
+  #
+  def self.configure(options={})
+    tool    = options[:tool]    || current_tool
+    profile = options[:profile] || current_profile
+
+    configuration.each do |c|
+      c.call if c.match?(tool, profile)
+    end
+  end
+
+  #
+  # Start RC.
+  #
+  def self.bootstrap
+    properties  # prime global properties
+
+    tweak = File.join(File.dirname(__FILE__), 'tweaks', current_tool + '.rb')
+    if File.exist?(tweak)
+      require tweak
+    else
+      begin
+        require current_tool
+      rescue LoadError      
+      end
+    end
+
+    if proc = processor(current_tool)
+      tool_config = ToolConfiguration.new(current_tool, configuration)
+      proc.call(tool_config)
+    else
+      configure
+    end
+  end
+
+  # @todo: I'm sure this, #bootstrap and #processor can be simplifed.
+  def self.run(tool, &block)
+    processor(tool, &block)
+    require 'rc'
+  end
+
+end

data/lib/rc/properties.rb

@@ -0,0 +1,44 @@
+module RC
+
+  # Currently properties derive from a project's .ruby file.
+  # This will be expanded upon in future version to allow 
+  # additional customization.
+  #
+  # @todo Lookup project root directory.
+  #
+  class Properties
+
+    #
+    #
+    #
+    DATA_FILE = '.ruby'
+
+    #
+    #
+    #
+    def initialize
+      @data = {}
+
+      if file = Dir[DATA_FILE].first
+        @data.update(YAML.load_file(file))
+      end
+    end
+
+    #
+    #
+    #
+    def method_missing(s)
+      @data[s.to_s]
+    end
+
+  private
+
+    # @todo Support gemspec as properties source ?
+    def import_gemspec
+      file = Dir['{*,,pkg/*}.gemspec'].first
+      # ...
+    end
+
+  end
+
+end